201 files changed, 15472 insertions, 0 deletions

diff --git a/enigma/src/main/java/cuchaz/enigma/ClassProvider.java b/enigma/src/main/java/cuchaz/enigma/ClassProvider.java
new file mode 100644
index 0000000..2b91379
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/ClassProvider.java
@@ -0,0 +1,10 @@
+package cuchaz.enigma;
+
+import org.objectweb.asm.tree.ClassNode;
+
+import javax.annotation.Nullable;
+
+public interface ClassProvider {
+        @Nullable
+        ClassNode getClassNode(String name);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/Enigma.java b/enigma/src/main/java/cuchaz/enigma/Enigma.java
new file mode 100644
index 0000000..73c9a09
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/Enigma.java
@@ -0,0 +1,139 @@
+/*******************************************************************************
+ * 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;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableListMultimap;
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.api.EnigmaPlugin;
+import cuchaz.enigma.api.EnigmaPluginContext;
+import cuchaz.enigma.api.service.EnigmaService;
+import cuchaz.enigma.api.service.EnigmaServiceFactory;
+import cuchaz.enigma.api.service.EnigmaServiceType;
+import cuchaz.enigma.api.service.JarIndexerService;
+import cuchaz.enigma.utils.Utils;
+import org.objectweb.asm.Opcodes;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.ServiceLoader;
+
+public class Enigma {
+    public static final String NAME = "Enigma";
+        public static final String VERSION;
+        public static final String URL = "https://fabricmc.net";
+    public static final int ASM_VERSION = Opcodes.ASM8;
+
+    private final EnigmaProfile profile;
+        private final EnigmaServices services;
+
+        private Enigma(EnigmaProfile profile, EnigmaServices services) {
+                this.profile = profile;
+                this.services = services;
+        }
+
+        public static Enigma create() {
+                return new Builder().build();
+        }
+
+        public static Builder builder() {
+                return new Builder();
+        }
+
+        public EnigmaProject openJar(Path path, ProgressListener progress) throws IOException {
+                ClassCache classCache = ClassCache.of(path);
+                JarIndex jarIndex = classCache.index(progress);
+
+                services.get(JarIndexerService.TYPE).forEach(indexer -> indexer.acceptJar(classCache, jarIndex));
+
+                return new EnigmaProject(this, classCache, jarIndex, Utils.zipSha1(path));
+        }
+
+        public EnigmaProfile getProfile() {
+                return profile;
+        }
+
+        public EnigmaServices getServices() {
+                return services;
+        }
+
+        public static class Builder {
+                private EnigmaProfile profile = EnigmaProfile.EMPTY;
+                private Iterable<EnigmaPlugin> plugins = ServiceLoader.load(EnigmaPlugin.class);
+
+                private Builder() {
+                }
+
+                public Builder setProfile(EnigmaProfile profile) {
+                        Preconditions.checkNotNull(profile, "profile cannot be null");
+                        this.profile = profile;
+                        return this;
+                }
+
+                public Builder setPlugins(Iterable<EnigmaPlugin> plugins) {
+                        Preconditions.checkNotNull(plugins, "plugins cannot be null");
+                        this.plugins = plugins;
+                        return this;
+                }
+
+                public Enigma build() {
+                        PluginContext pluginContext = new PluginContext(profile);
+                        for (EnigmaPlugin plugin : plugins) {
+                                plugin.init(pluginContext);
+                        }
+
+                        EnigmaServices services = pluginContext.buildServices();
+                        return new Enigma(profile, services);
+                }
+        }
+
+        private static class PluginContext implements EnigmaPluginContext {
+                private final EnigmaProfile profile;
+
+                private final ImmutableListMultimap.Builder<EnigmaServiceType<?>, EnigmaService> services = ImmutableListMultimap.builder();
+
+                PluginContext(EnigmaProfile profile) {
+                        this.profile = profile;
+                }
+
+                @Override
+                public <T extends EnigmaService> void registerService(String id, EnigmaServiceType<T> serviceType, EnigmaServiceFactory<T> factory) {
+                        List<EnigmaProfile.Service> serviceProfiles = profile.getServiceProfiles(serviceType);
+
+                        for (EnigmaProfile.Service serviceProfile : serviceProfiles) {
+                                if (serviceProfile.matches(id)) {
+                                        T service = factory.create(serviceProfile::getArgument);
+                                        services.put(serviceType, service);
+                                        break;
+                                }
+                        }
+                }
+
+                EnigmaServices buildServices() {
+                        return new EnigmaServices(services.build());
+                }
+        }
+
+        static {
+                String version = null;
+
+                try {
+                        version = Utils.readResourceToString("/version.txt");
+                } catch (Throwable t) {
+                        version = "Unknown Version";
+                }
+
+                VERSION = version;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/EnigmaProfile.java b/enigma/src/main/java/cuchaz/enigma/EnigmaProfile.java
new file mode 100644
index 0000000..daf2727
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/EnigmaProfile.java
@@ -0,0 +1,131 @@
+package cuchaz.enigma;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.annotations.SerializedName;
+import com.google.gson.reflect.TypeToken;
+import cuchaz.enigma.api.service.EnigmaServiceType;
+import cuchaz.enigma.translation.mapping.serde.MappingFileNameFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
+
+import javax.annotation.Nullable;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public final class EnigmaProfile {
+        public static final EnigmaProfile EMPTY = new EnigmaProfile(new ServiceContainer(ImmutableMap.of()));
+
+        private static final MappingSaveParameters DEFAULT_MAPPING_SAVE_PARAMETERS = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
+        private static final Gson GSON = new GsonBuilder()
+                        .registerTypeAdapter(ServiceContainer.class, (JsonDeserializer<ServiceContainer>) EnigmaProfile::loadServiceContainer)
+                        .create();
+        private static final Type SERVICE_LIST_TYPE = new TypeToken<List<Service>>() {
+        }.getType();
+
+        @SerializedName("services")
+        private final ServiceContainer serviceProfiles;
+
+        @SerializedName("mapping_save_parameters")
+        private final MappingSaveParameters mappingSaveParameters = null;
+
+        private EnigmaProfile(ServiceContainer serviceProfiles) {
+                this.serviceProfiles = serviceProfiles;
+        }
+
+        public static EnigmaProfile read(@Nullable Path file) throws IOException {
+                if (file != null) {
+                        try (BufferedReader reader = Files.newBufferedReader(file)) {
+                                return EnigmaProfile.parse(reader);
+                        }
+                } else {
+                        try (BufferedReader reader = new BufferedReader(new InputStreamReader(EnigmaProfile.class.getResourceAsStream("/profile.json"), StandardCharsets.UTF_8))) {
+                                return EnigmaProfile.parse(reader);
+                        } catch (IOException ex) {
+                                System.err.println("Failed to load default profile, will use empty profile: " + ex.getMessage());
+                                return EnigmaProfile.EMPTY;
+                        }
+                }
+        }
+
+        public static EnigmaProfile parse(Reader reader) {
+                return GSON.fromJson(reader, EnigmaProfile.class);
+        }
+
+        private static ServiceContainer loadServiceContainer(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                if (!json.isJsonObject()) {
+                        throw new JsonParseException("services must be an Object!");
+                }
+
+                JsonObject object = json.getAsJsonObject();
+
+                ImmutableMap.Builder<String, List<Service>> builder = ImmutableMap.builder();
+
+                for (Map.Entry<String, JsonElement> entry : object.entrySet()) {
+                        JsonElement value = entry.getValue();
+                        if (value.isJsonObject()) {
+                                builder.put(entry.getKey(), Collections.singletonList(GSON.fromJson(value, Service.class)));
+                        } else if (value.isJsonArray()) {
+                                builder.put(entry.getKey(), GSON.fromJson(value, SERVICE_LIST_TYPE));
+                        } else {
+                                throw new JsonParseException(String.format("Don't know how to convert %s to a list of service!", value));
+                        }
+                }
+
+                return new ServiceContainer(builder.build());
+        }
+
+        public List<Service> getServiceProfiles(EnigmaServiceType<?> serviceType) {
+                return serviceProfiles.get(serviceType.key);
+        }
+
+        public MappingSaveParameters getMappingSaveParameters() {
+                //noinspection ConstantConditions
+                return mappingSaveParameters == null ? EnigmaProfile.DEFAULT_MAPPING_SAVE_PARAMETERS : mappingSaveParameters;
+        }
+
+        public static class Service {
+                private final String id;
+                private final Map<String, String> args;
+
+                Service(String id, Map<String, String> args) {
+                        this.id = id;
+                        this.args = args;
+                }
+
+                public boolean matches(String id) {
+                        return this.id.equals(id);
+                }
+
+                public Optional<String> getArgument(String key) {
+                        return args != null ? Optional.ofNullable(args.get(key)) : Optional.empty();
+                }
+        }
+
+        static final class ServiceContainer {
+                private final Map<String, List<Service>> services;
+
+                ServiceContainer(Map<String, List<Service>> services) {
+                        this.services = services;
+                }
+
+                List<Service> get(String key) {
+                        return services.getOrDefault(key, Collections.emptyList());
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java b/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java
new file mode 100644
index 0000000..43ea14e
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java
@@ -0,0 +1,288 @@
+package cuchaz.enigma;
+
+import com.google.common.base.Functions;
+import com.google.common.base.Preconditions;
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.api.service.NameProposalService;
+import cuchaz.enigma.bytecode.translators.SourceFixVisitor;
+import cuchaz.enigma.bytecode.translators.TranslationClassVisitor;
+import cuchaz.enigma.source.*;
+import cuchaz.enigma.translation.ProposingTranslator;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.*;
+import cuchaz.enigma.translation.mapping.tree.DeltaTrackingTree;
+import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import cuchaz.enigma.utils.I18n;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import java.util.stream.Collectors;
+
+public class EnigmaProject {
+        private final Enigma enigma;
+
+        private final ClassCache classCache;
+        private final JarIndex jarIndex;
+        private final byte[] jarChecksum;
+
+        private EntryRemapper mapper;
+
+        public EnigmaProject(Enigma enigma, ClassCache classCache, JarIndex jarIndex, byte[] jarChecksum) {
+                Preconditions.checkArgument(jarChecksum.length == 20);
+                this.enigma = enigma;
+                this.classCache = classCache;
+                this.jarIndex = jarIndex;
+                this.jarChecksum = jarChecksum;
+
+                this.mapper = EntryRemapper.empty(jarIndex);
+        }
+
+        public void setMappings(EntryTree<EntryMapping> mappings) {
+                if (mappings != null) {
+                        mapper = EntryRemapper.mapped(jarIndex, mappings);
+                } else {
+                        mapper = EntryRemapper.empty(jarIndex);
+                }
+        }
+
+        public Enigma getEnigma() {
+                return enigma;
+        }
+
+        public ClassCache getClassCache() {
+                return classCache;
+        }
+
+        public JarIndex getJarIndex() {
+                return jarIndex;
+        }
+
+        public byte[] getJarChecksum() {
+                return jarChecksum;
+        }
+
+        public EntryRemapper getMapper() {
+                return mapper;
+        }
+
+        public void dropMappings(ProgressListener progress) {
+                DeltaTrackingTree<EntryMapping> mappings = mapper.getObfToDeobf();
+
+                Collection<Entry<?>> dropped = dropMappings(mappings, progress);
+                for (Entry<?> entry : dropped) {
+                        mappings.trackChange(entry);
+                }
+        }
+
+        private Collection<Entry<?>> dropMappings(EntryTree<EntryMapping> mappings, ProgressListener progress) {
+                // drop mappings that don't match the jar
+                MappingsChecker checker = new MappingsChecker(jarIndex, mappings);
+                MappingsChecker.Dropped dropped = checker.dropBrokenMappings(progress);
+
+                Map<Entry<?>, String> droppedMappings = dropped.getDroppedMappings();
+                for (Map.Entry<Entry<?>, String> mapping : droppedMappings.entrySet()) {
+                        System.out.println("WARNING: Couldn't find " + mapping.getKey() + " (" + mapping.getValue() + ") in jar. Mapping was dropped.");
+                }
+
+                return droppedMappings.keySet();
+        }
+
+        public Decompiler createDecompiler(DecompilerService decompilerService) {
+                return decompilerService.create(name -> {
+                        ClassNode node = this.getClassCache().getClassNode(name);
+
+                        if (node == null) {
+                                return null;
+                        }
+
+                        ClassNode fixedNode = new ClassNode();
+                        node.accept(new SourceFixVisitor(Enigma.ASM_VERSION, fixedNode, getJarIndex()));
+                        return fixedNode;
+                }, new SourceSettings(true, true));
+        }
+
+        public boolean isRenamable(Entry<?> obfEntry) {
+                if (obfEntry instanceof MethodEntry) {
+                        // HACKHACK: Object methods are not obfuscated identifiers
+                        MethodEntry obfMethodEntry = (MethodEntry) obfEntry;
+                        String name = obfMethodEntry.getName();
+                        String sig = obfMethodEntry.getDesc().toString();
+                        if (name.equals("clone") && sig.equals("()Ljava/lang/Object;")) {
+                                return false;
+                        } else if (name.equals("equals") && sig.equals("(Ljava/lang/Object;)Z")) {
+                                return false;
+                        } else if (name.equals("finalize") && sig.equals("()V")) {
+                                return false;
+                        } else if (name.equals("getClass") && sig.equals("()Ljava/lang/Class;")) {
+                                return false;
+                        } else if (name.equals("hashCode") && sig.equals("()I")) {
+                                return false;
+                        } else if (name.equals("notify") && sig.equals("()V")) {
+                                return false;
+                        } else if (name.equals("notifyAll") && sig.equals("()V")) {
+                                return false;
+                        } else if (name.equals("toString") && sig.equals("()Ljava/lang/String;")) {
+                                return false;
+                        } else if (name.equals("wait") && sig.equals("()V")) {
+                                return false;
+                        } else if (name.equals("wait") && sig.equals("(J)V")) {
+                                return false;
+                        } else if (name.equals("wait") && sig.equals("(JI)V")) {
+                                return false;
+                        }
+                } else if (obfEntry instanceof LocalVariableEntry && !((LocalVariableEntry) obfEntry).isArgument()) {
+                        return false;
+                }
+
+                return this.jarIndex.getEntryIndex().hasEntry(obfEntry);
+        }
+
+        public boolean isRenamable(EntryReference<Entry<?>, Entry<?>> obfReference) {
+                return obfReference.isNamed() && isRenamable(obfReference.getNameableEntry());
+        }
+
+        public JarExport exportRemappedJar(ProgressListener progress) {
+                Collection<ClassEntry> classEntries = jarIndex.getEntryIndex().getClasses();
+
+                NameProposalService[] nameProposalServices = getEnigma().getServices().get(NameProposalService.TYPE).toArray(new NameProposalService[0]);
+                Translator deobfuscator = nameProposalServices.length == 0 ? mapper.getDeobfuscator() : new ProposingTranslator(mapper, nameProposalServices);
+
+                AtomicInteger count = new AtomicInteger();
+                progress.init(classEntries.size(), I18n.translate("progress.classes.deobfuscating"));
+
+                Map<String, ClassNode> compiled = classEntries.parallelStream()
+                                .map(entry -> {
+                                        ClassEntry translatedEntry = deobfuscator.translate(entry);
+                                        progress.step(count.getAndIncrement(), translatedEntry.toString());
+
+                                        ClassNode node = classCache.getClassNode(entry.getFullName());
+                                        if (node != null) {
+                                                ClassNode translatedNode = new ClassNode();
+                                                node.accept(new TranslationClassVisitor(deobfuscator, Enigma.ASM_VERSION, new SourceFixVisitor(Enigma.ASM_VERSION, translatedNode, jarIndex)));
+                                                return translatedNode;
+                                        }
+
+                                        return null;
+                                })
+                                .filter(Objects::nonNull)
+                                .collect(Collectors.toMap(n -> n.name, Functions.identity()));
+
+                return new JarExport(jarIndex, compiled);
+        }
+
+        public static final class JarExport {
+                private final JarIndex jarIndex;
+                private final Map<String, ClassNode> compiled;
+
+                JarExport(JarIndex jarIndex, Map<String, ClassNode> compiled) {
+                        this.jarIndex = jarIndex;
+                        this.compiled = compiled;
+                }
+
+                public void write(Path path, ProgressListener progress) throws IOException {
+                        progress.init(this.compiled.size(), I18n.translate("progress.jar.writing"));
+
+                        try (JarOutputStream out = new JarOutputStream(Files.newOutputStream(path))) {
+                                AtomicInteger count = new AtomicInteger();
+
+                                for (ClassNode node : this.compiled.values()) {
+                                        progress.step(count.getAndIncrement(), node.name);
+
+                                        String entryName = node.name.replace('.', '/') + ".class";
+
+                                        ClassWriter writer = new ClassWriter(0);
+                                        node.accept(writer);
+
+                                        out.putNextEntry(new JarEntry(entryName));
+                                        out.write(writer.toByteArray());
+                                        out.closeEntry();
+                                }
+                        }
+                }
+
+                public SourceExport decompile(ProgressListener progress, DecompilerService decompilerService) {
+                        Collection<ClassNode> classes = this.compiled.values().stream()
+                                        .filter(classNode -> classNode.name.indexOf('$') == -1)
+                                        .collect(Collectors.toList());
+
+                        progress.init(classes.size(), I18n.translate("progress.classes.decompiling"));
+
+                        //create a common instance outside the loop as mappings shouldn't be changing while this is happening
+                        Decompiler decompiler = decompilerService.create(compiled::get, new SourceSettings(false, false));
+
+                        AtomicInteger count = new AtomicInteger();
+
+                        Collection<ClassSource> decompiled = classes.parallelStream()
+                                        .map(translatedNode -> {
+                                                progress.step(count.getAndIncrement(), translatedNode.name);
+
+                                                String source = decompileClass(translatedNode, decompiler);
+                                                return new ClassSource(translatedNode.name, source);
+                                        })
+                                        .collect(Collectors.toList());
+
+                        return new SourceExport(decompiled);
+                }
+
+                private String decompileClass(ClassNode translatedNode, Decompiler decompiler) {
+                        return decompiler.getSource(translatedNode.name).asString();
+                }
+        }
+
+        public static final class SourceExport {
+                private final Collection<ClassSource> decompiled;
+
+                SourceExport(Collection<ClassSource> decompiled) {
+                        this.decompiled = decompiled;
+                }
+
+                public void write(Path path, ProgressListener progress) throws IOException {
+                        progress.init(decompiled.size(), I18n.translate("progress.sources.writing"));
+
+                        int count = 0;
+                        for (ClassSource source : decompiled) {
+                                progress.step(count++, source.name);
+
+                                Path sourcePath = source.resolvePath(path);
+                                source.writeTo(sourcePath);
+                        }
+                }
+        }
+
+        private static class ClassSource {
+                private final String name;
+                private final String source;
+
+                ClassSource(String name, String source) {
+                        this.name = name;
+                        this.source = source;
+                }
+
+                void writeTo(Path path) throws IOException {
+                        Files.createDirectories(path.getParent());
+                        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
+                                writer.write(source);
+                        }
+                }
+
+                Path resolvePath(Path root) {
+                        return root.resolve(name.replace('.', '/') + ".java");
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/EnigmaServices.java b/enigma/src/main/java/cuchaz/enigma/EnigmaServices.java
new file mode 100644
index 0000000..df3b7bb
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/EnigmaServices.java
@@ -0,0 +1,20 @@
+package cuchaz.enigma;
+
+import com.google.common.collect.ImmutableListMultimap;
+import cuchaz.enigma.api.service.EnigmaService;
+import cuchaz.enigma.api.service.EnigmaServiceType;
+
+import java.util.List;
+
+public final class EnigmaServices {
+        private final ImmutableListMultimap<EnigmaServiceType<?>, EnigmaService> services;
+
+        EnigmaServices(ImmutableListMultimap<EnigmaServiceType<?>, EnigmaService> services) {
+                this.services = services;
+        }
+
+        @SuppressWarnings("unchecked")
+        public <T extends EnigmaService> List<T> get(EnigmaServiceType<T> type) {
+                return (List<T>) services.get(type);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/ProgressListener.java b/enigma/src/main/java/cuchaz/enigma/ProgressListener.java
new file mode 100644
index 0000000..6da3b81
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/ProgressListener.java
@@ -0,0 +1,19 @@
+package cuchaz.enigma;
+
+public interface ProgressListener {
+        static ProgressListener none() {
+                return new ProgressListener() {
+                        @Override
+                        public void init(int totalWork, String title) {
+                        }
+
+                        @Override
+                        public void step(int numDone, String message) {
+                        }
+                };
+        }
+
+        void init(int totalWork, String title);
+
+        void step(int numDone, String message);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/Access.java b/enigma/src/main/java/cuchaz/enigma/analysis/Access.java
new file mode 100644
index 0000000..82ca669
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/Access.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import cuchaz.enigma.translation.representation.AccessFlags;
+
+import java.lang.reflect.Modifier;
+
+public enum Access {
+
+        PUBLIC, PROTECTED, PACKAGE, PRIVATE;
+
+        public static Access get(AccessFlags flags) {
+                return get(flags.getFlags());
+        }
+
+        public static Access get(int modifiers) {
+                boolean isPublic = Modifier.isPublic(modifiers);
+                boolean isProtected = Modifier.isProtected(modifiers);
+                boolean isPrivate = Modifier.isPrivate(modifiers);
+
+                if (isPublic && !isProtected && !isPrivate) {
+                        return PUBLIC;
+                } else if (!isPublic && isProtected && !isPrivate) {
+                        return PROTECTED;
+                } else if (!isPublic && !isProtected && isPrivate) {
+                        return PRIVATE;
+                } else if (!isPublic && !isProtected && !isPrivate) {
+                        return PACKAGE;
+                }
+                // assume public by default
+                return PUBLIC;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/BuiltinPlugin.java b/enigma/src/main/java/cuchaz/enigma/analysis/BuiltinPlugin.java
new file mode 100644
index 0000000..4685b39
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/BuiltinPlugin.java
@@ -0,0 +1,156 @@
+package cuchaz.enigma.analysis;
+
+import cuchaz.enigma.Enigma;
+import cuchaz.enigma.api.EnigmaPlugin;
+import cuchaz.enigma.api.EnigmaPluginContext;
+import cuchaz.enigma.api.service.JarIndexerService;
+import cuchaz.enigma.api.service.NameProposalService;
+import cuchaz.enigma.source.DecompilerService;
+import cuchaz.enigma.source.Decompilers;
+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.utils.Pair;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.analysis.Analyzer;
+import org.objectweb.asm.tree.analysis.Frame;
+import org.objectweb.asm.tree.analysis.SourceInterpreter;
+import org.objectweb.asm.tree.analysis.SourceValue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+public final class BuiltinPlugin implements EnigmaPlugin {
+
+        public BuiltinPlugin() {
+        }
+
+        @Override
+        public void init(EnigmaPluginContext ctx) {
+                registerEnumNamingService(ctx);
+                registerDecompilerServices(ctx);
+        }
+
+        private void registerEnumNamingService(EnigmaPluginContext ctx) {
+                final Map<Entry<?>, String> names = new HashMap<>();
+                final EnumFieldNameFindingVisitor visitor = new EnumFieldNameFindingVisitor(names);
+
+                ctx.registerService("enigma:enum_initializer_indexer", JarIndexerService.TYPE, ctx1 -> (classCache, jarIndex) -> classCache.visit(() -> visitor, ClassReader.SKIP_FRAMES));
+                ctx.registerService("enigma:enum_name_proposer", NameProposalService.TYPE, ctx1 -> (obfEntry, remapper) -> Optional.ofNullable(names.get(obfEntry)));
+        }
+
+        private void registerDecompilerServices(EnigmaPluginContext ctx) {
+                ctx.registerService("enigma:procyon", DecompilerService.TYPE, ctx1 -> Decompilers.PROCYON);
+                ctx.registerService("enigma:cfr", DecompilerService.TYPE, ctx1 -> Decompilers.CFR);
+        }
+
+        private static final class EnumFieldNameFindingVisitor extends ClassVisitor {
+
+                private ClassEntry clazz;
+                private String className;
+                private final Map<Entry<?>, String> mappings;
+                private final Set<Pair<String, String>> enumFields = new HashSet<>();
+                private final List<MethodNode> classInits = new ArrayList<>();
+
+                EnumFieldNameFindingVisitor(Map<Entry<?>, String> mappings) {
+                        super(Enigma.ASM_VERSION);
+                        this.mappings = mappings;
+                }
+
+                @Override
+                public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+                        super.visit(version, access, name, signature, superName, interfaces);
+                        this.className = name;
+                        this.clazz = new ClassEntry(name);
+                        this.enumFields.clear();
+                        this.classInits.clear();
+                }
+
+                @Override
+                public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
+                        if ((access & Opcodes.ACC_ENUM) != 0) {
+                                if (!enumFields.add(new Pair<>(name, descriptor))) {
+                                        throw new IllegalArgumentException("Found two enum fields with the same name \"" + name + "\" and desc \"" + descriptor + "\"!");
+                                }
+                        }
+                        return super.visitField(access, name, descriptor, signature, value);
+                }
+
+                @Override
+                public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+                        if ("<clinit>".equals(name)) {
+                                MethodNode node = new MethodNode(api, access, name, descriptor, signature, exceptions);
+                                classInits.add(node);
+                                return node;
+                        }
+                        return super.visitMethod(access, name, descriptor, signature, exceptions);
+                }
+
+                @Override
+                public void visitEnd() {
+                        super.visitEnd();
+                        try {
+                                collectResults();
+                        } catch (Exception ex) {
+                                throw new RuntimeException(ex);
+                        }
+                }
+
+                private void collectResults() throws Exception {
+                        String owner = className;
+                        Analyzer<SourceValue> analyzer = new Analyzer<>(new SourceInterpreter());
+
+                        for (MethodNode mn : classInits) {
+                                Frame<SourceValue>[] frames = analyzer.analyze(className, mn);
+
+                                InsnList instrs = mn.instructions;
+                                for (int i = 1; i < instrs.size(); i++) {
+                                        AbstractInsnNode instr1 = instrs.get(i - 1);
+                                        AbstractInsnNode instr2 = instrs.get(i);
+                                        String s = null;
+
+                                        if (instr2.getOpcode() == Opcodes.PUTSTATIC
+                                                        && ((FieldInsnNode) instr2).owner.equals(owner)
+                                                        && enumFields.contains(new Pair<>(((FieldInsnNode) instr2).name, ((FieldInsnNode) instr2).desc))
+                                                        && instr1.getOpcode() == Opcodes.INVOKESPECIAL
+                                                        && "<init>".equals(((MethodInsnNode) instr1).name)) {
+
+                                                for (int j = 0; j < frames[i - 1].getStackSize(); j++) {
+                                                        SourceValue sv = frames[i - 1].getStack(j);
+                                                        for (AbstractInsnNode ci : sv.insns) {
+                                                                if (ci instanceof LdcInsnNode && ((LdcInsnNode) ci).cst instanceof String) {
+                                                                        //if (s == null || !s.equals(((LdcInsnNode) ci).cst)) {
+                                                                        if (s == null) {
+                                                                                s = (String) (((LdcInsnNode) ci).cst);
+                                                                                // stringsFound++;
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                        }
+
+                                        if (s != null) {
+                                                mappings.put(new FieldEntry(clazz, ((FieldInsnNode) instr2).name, new TypeDescriptor(((FieldInsnNode) instr2).desc)), s);
+                                        }
+                                        // report otherwise?
+                                }
+                        }
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ClassCache.java b/enigma/src/main/java/cuchaz/enigma/analysis/ClassCache.java
new file mode 100644
index 0000000..a3d24e3
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/ClassCache.java
@@ -0,0 +1,126 @@
+package cuchaz.enigma.analysis;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.collect.ImmutableSet;
+import cuchaz.enigma.ClassProvider;
+import cuchaz.enigma.Enigma;
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.bytecode.translators.LocalVariableFixVisitor;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.tree.ClassNode;
+
+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.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+public final class ClassCache implements AutoCloseable, ClassProvider {
+        private final FileSystem fileSystem;
+        private final ImmutableSet<String> classNames;
+
+        private final Cache<String, ClassNode> nodeCache = CacheBuilder.newBuilder()
+                        .maximumSize(128)
+                        .expireAfterAccess(1, TimeUnit.MINUTES)
+                        .build();
+
+        private ClassCache(FileSystem fileSystem, ImmutableSet<String> classNames) {
+                this.fileSystem = fileSystem;
+                this.classNames = classNames;
+        }
+
+        public static ClassCache of(Path jarPath) throws IOException {
+                FileSystem fileSystem = FileSystems.newFileSystem(jarPath, (ClassLoader) null);
+                ImmutableSet<String> classNames = collectClassNames(fileSystem);
+
+                return new ClassCache(fileSystem, classNames);
+        }
+
+        private static ImmutableSet<String> collectClassNames(FileSystem fileSystem) throws IOException {
+                ImmutableSet.Builder<String> classNames = ImmutableSet.builder();
+                for (Path root : fileSystem.getRootDirectories()) {
+                        Files.walk(root).map(Path::toString)
+                                        .forEach(path -> {
+                                                if (path.endsWith(".class")) {
+                                                        String name = path.substring(1, path.length() - ".class".length());
+                                                        classNames.add(name);
+                                                }
+                                        });
+                }
+
+                return classNames.build();
+        }
+
+        @Nullable
+        @Override
+        public ClassNode getClassNode(String name) {
+                if (!classNames.contains(name)) {
+                        return null;
+                }
+
+                try {
+                        return nodeCache.get(name, () -> parseNode(name));
+                } catch (ExecutionException e) {
+                        throw new RuntimeException(e);
+                }
+        }
+
+        private ClassNode parseNode(String name) throws IOException {
+                ClassReader reader = getReader(name);
+
+                ClassNode node = new ClassNode();
+
+                LocalVariableFixVisitor visitor = new LocalVariableFixVisitor(Enigma.ASM_VERSION, node);
+                reader.accept(visitor, 0);
+
+                return node;
+        }
+
+        private ClassReader getReader(String name) throws IOException {
+                Path path = fileSystem.getPath(name + ".class");
+                byte[] bytes = Files.readAllBytes(path);
+                return new ClassReader(bytes);
+        }
+
+        public int getClassCount() {
+                return classNames.size();
+        }
+
+        public void visit(Supplier<ClassVisitor> visitorSupplier, int readFlags) {
+                for (String className : classNames) {
+                        ClassVisitor visitor = visitorSupplier.get();
+
+                        ClassNode cached = nodeCache.getIfPresent(className);
+                        if (cached != null) {
+                                cached.accept(visitor);
+                                continue;
+                        }
+
+                        try {
+                                ClassReader reader = getReader(className);
+                                reader.accept(visitor, readFlags);
+                        } catch (IOException e) {
+                                System.out.println("Failed to visit class " + className);
+                                e.printStackTrace();
+                        }
+                }
+        }
+
+        @Override
+        public void close() throws IOException {
+                this.fileSystem.close();
+        }
+
+        public JarIndex index(ProgressListener progress) {
+                JarIndex index = JarIndex.empty();
+                index.indexJar(this, progress);
+                return index;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
new file mode 100644
index 0000000..0fc44ca
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import com.google.common.collect.Lists;
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import java.util.Collection;
+import java.util.List;
+
+public class ClassImplementationsTreeNode extends DefaultMutableTreeNode {
+        private final Translator translator;
+        private final ClassEntry entry;
+
+        public ClassImplementationsTreeNode(Translator translator, ClassEntry entry) {
+                this.translator = translator;
+                this.entry = entry;
+        }
+
+        public static ClassImplementationsTreeNode findNode(ClassImplementationsTreeNode node, MethodEntry entry) {
+                // is this the node?
+                if (node.entry.equals(entry.getParent())) {
+                        return node;
+                }
+
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        ClassImplementationsTreeNode foundNode = findNode((ClassImplementationsTreeNode) node.getChildAt(i), entry);
+                        if (foundNode != null) {
+                                return foundNode;
+                        }
+                }
+                return null;
+        }
+
+        public ClassEntry getClassEntry() {
+                return this.entry;
+        }
+
+        @Override
+        public String toString() {
+                return translator.translate(entry).toString();
+        }
+
+        public void load(JarIndex index) {
+                // get all method implementations
+                List<ClassImplementationsTreeNode> nodes = Lists.newArrayList();
+                InheritanceIndex inheritanceIndex = index.getInheritanceIndex();
+
+                Collection<ClassEntry> inheritors = inheritanceIndex.getChildren(entry);
+                for (ClassEntry inheritor : inheritors) {
+                        nodes.add(new ClassImplementationsTreeNode(translator, inheritor));
+                }
+
+                // add them to this node
+                nodes.forEach(this::add);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
new file mode 100644
index 0000000..7904c5f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import com.google.common.collect.Lists;
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import java.util.List;
+
+public class ClassInheritanceTreeNode extends DefaultMutableTreeNode {
+        private final Translator translator;
+        private final ClassEntry obfClassEntry;
+
+        public ClassInheritanceTreeNode(Translator translator, String obfClassName) {
+                this.translator = translator;
+                this.obfClassEntry = new ClassEntry(obfClassName);
+        }
+
+        public static ClassInheritanceTreeNode findNode(ClassInheritanceTreeNode node, ClassEntry entry) {
+                // is this the node?
+                if (node.getObfClassName().equals(entry.getFullName())) {
+                        return node;
+                }
+
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        ClassInheritanceTreeNode foundNode = findNode((ClassInheritanceTreeNode) node.getChildAt(i), entry);
+                        if (foundNode != null) {
+                                return foundNode;
+                        }
+                }
+                return null;
+        }
+
+        public String getObfClassName() {
+                return this.obfClassEntry.getFullName();
+        }
+
+        @Override
+        public String toString() {
+                return translator.translate(obfClassEntry).getFullName();
+        }
+
+        public void load(InheritanceIndex ancestries, boolean recurse) {
+                // get all the child nodes
+                List<ClassInheritanceTreeNode> nodes = Lists.newArrayList();
+                for (ClassEntry inheritor : ancestries.getChildren(this.obfClassEntry)) {
+                        nodes.add(new ClassInheritanceTreeNode(translator, inheritor.getFullName()));
+                }
+
+                // add them to this node
+                nodes.forEach(this::add);
+
+                if (recurse) {
+                        for (ClassInheritanceTreeNode node : nodes) {
+                                node.load(ancestries, true);
+                        }
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ClassReferenceTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/ClassReferenceTreeNode.java
new file mode 100644
index 0000000..90d8a6c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/ClassReferenceTreeNode.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import com.google.common.collect.Sets;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.analysis.index.ReferenceIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreeNode;
+import java.util.Set;
+
+public class ClassReferenceTreeNode extends DefaultMutableTreeNode
+        implements ReferenceTreeNode<ClassEntry, MethodDefEntry> {
+
+        private Translator deobfuscatingTranslator;
+        private ClassEntry entry;
+        private EntryReference<ClassEntry, MethodDefEntry> reference;
+
+        public ClassReferenceTreeNode(Translator deobfuscatingTranslator, ClassEntry entry) {
+                this.deobfuscatingTranslator = deobfuscatingTranslator;
+                this.entry = entry;
+                this.reference = null;
+        }
+
+        public ClassReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference<ClassEntry, MethodDefEntry> reference) {
+                this.deobfuscatingTranslator = deobfuscatingTranslator;
+                this.entry = reference.entry;
+                this.reference = reference;
+        }
+
+        @Override
+        public ClassEntry getEntry() {
+                return this.entry;
+        }
+
+        @Override
+        public EntryReference<ClassEntry, MethodDefEntry> getReference() {
+                return this.reference;
+        }
+
+        @Override
+        public String toString() {
+                if (this.reference != null) {
+                        return String.format("%s", this.deobfuscatingTranslator.translate(this.reference.context));
+                }
+                return this.deobfuscatingTranslator.translate(this.entry).getFullName();
+        }
+
+        public void load(JarIndex index, boolean recurse) {
+                ReferenceIndex referenceIndex = index.getReferenceIndex();
+
+                // get all the child nodes
+                for (EntryReference<ClassEntry, MethodDefEntry> reference : referenceIndex.getReferencesToClass(this.entry)) {
+                        add(new ClassReferenceTreeNode(this.deobfuscatingTranslator, reference));
+                }
+
+                if (recurse && this.children != null) {
+                        for (Object child : this.children) {
+                                if (child instanceof ClassReferenceTreeNode) {
+                                        ClassReferenceTreeNode node = (ClassReferenceTreeNode) child;
+
+                                        // don't recurse into ancestor
+                                        Set<Entry<?>> ancestors = Sets.newHashSet();
+                                        TreeNode n = node;
+                                        while (n.getParent() != null) {
+                                                n = n.getParent();
+                                                if (n instanceof ClassReferenceTreeNode) {
+                                                        ancestors.add(((ClassReferenceTreeNode) n).getEntry());
+                                                }
+                                        }
+                                        if (ancestors.contains(node.getEntry())) {
+                                                continue;
+                                        }
+
+                                        node.load(index, true);
+                                }
+                        }
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/EntryReference.java b/enigma/src/main/java/cuchaz/enigma/analysis/EntryReference.java
new file mode 100644
index 0000000..320f945
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/EntryReference.java
@@ -0,0 +1,140 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import cuchaz.enigma.translation.Translatable;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.EntryMap;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+public class EntryReference<E extends Entry<?>, C extends Entry<?>> implements Translatable {
+
+        private static final List<String> CONSTRUCTOR_NON_NAMES = Arrays.asList("this", "super", "static");
+        public E entry;
+        public C context;
+        public ReferenceTargetType targetType;
+
+        private boolean sourceName;
+
+        public EntryReference(E entry, String sourceName) {
+                this(entry, sourceName, null);
+        }
+
+        public EntryReference(E entry, String sourceName, C context) {
+                this(entry, sourceName, context, ReferenceTargetType.none());
+        }
+
+        public EntryReference(E entry, String sourceName, C context, ReferenceTargetType targetType) {
+                if (entry == null) {
+                        throw new IllegalArgumentException("Entry cannot be null!");
+                }
+
+                this.entry = entry;
+                this.context = context;
+                this.targetType = targetType;
+
+                this.sourceName = sourceName != null && !sourceName.isEmpty();
+                if (entry instanceof MethodEntry && ((MethodEntry) entry).isConstructor() && CONSTRUCTOR_NON_NAMES.contains(sourceName)) {
+                        this.sourceName = false;
+                }
+        }
+
+        public EntryReference(E entry, C context, EntryReference<E, C> other) {
+                this.entry = entry;
+                this.context = context;
+                this.sourceName = other.sourceName;
+                this.targetType = other.targetType;
+        }
+
+        public ClassEntry getLocationClassEntry() {
+                if (context != null) {
+                        return context.getContainingClass();
+                }
+                return entry.getContainingClass();
+        }
+
+        public boolean isNamed() {
+                return this.sourceName;
+        }
+
+        public Entry<?> getNameableEntry() {
+                if (entry instanceof MethodEntry && ((MethodEntry) entry).isConstructor()) {
+                        // renaming a constructor really means renaming the class
+                        return entry.getContainingClass();
+                }
+                return entry;
+        }
+
+        public String getNameableName() {
+                return getNameableEntry().getName();
+        }
+
+        @Override
+        public int hashCode() {
+                if (context != null) {
+                        return Objects.hash(entry.hashCode(), context.hashCode());
+                }
+                return entry.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object other) {
+                return other instanceof EntryReference && equals((EntryReference<?, ?>) other);
+        }
+
+        public boolean equals(EntryReference<?, ?> other) {
+                // check entry first
+                boolean isEntrySame = entry.equals(other.entry);
+                if (!isEntrySame) {
+                        return false;
+                }
+
+                // check caller
+                if (context == null && other.context == null) {
+                        return true;
+                } else if (context != null && other.context != null) {
+                        return context.equals(other.context);
+                }
+                return false;
+        }
+
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append(entry);
+
+                if (context != null) {
+                        buf.append(" called from ");
+                        buf.append(context);
+                }
+
+                if (targetType != null && targetType.getKind() != ReferenceTargetType.Kind.NONE) {
+                        buf.append(" on target of type ");
+                        buf.append(targetType);
+                }
+
+                return buf.toString();
+        }
+
+        @Override
+        public Translatable translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+                return new EntryReference<>(translator.translate(entry), translator.translate(context), this);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
new file mode 100644
index 0000000..4beab7f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.analysis.index.ReferenceIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+public class FieldReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode<FieldEntry, MethodDefEntry> {
+
+        private final Translator translator;
+        private FieldEntry entry;
+        private EntryReference<FieldEntry, MethodDefEntry> reference;
+
+        public FieldReferenceTreeNode(Translator translator, FieldEntry entry) {
+                this.translator = translator;
+                this.entry = entry;
+                this.reference = null;
+        }
+
+        private FieldReferenceTreeNode(Translator translator, EntryReference<FieldEntry, MethodDefEntry> reference) {
+                this.translator = translator;
+                this.entry = reference.entry;
+                this.reference = reference;
+        }
+
+        @Override
+        public FieldEntry getEntry() {
+                return this.entry;
+        }
+
+        @Override
+        public EntryReference<FieldEntry, MethodDefEntry> getReference() {
+                return this.reference;
+        }
+
+        @Override
+        public String toString() {
+                if (this.reference != null) {
+                        return String.format("%s", translator.translate(this.reference.context));
+                }
+                return translator.translate(entry).toString();
+        }
+
+        public void load(JarIndex index, boolean recurse) {
+                ReferenceIndex referenceIndex = index.getReferenceIndex();
+
+                // get all the child nodes
+                if (this.reference == null) {
+                        for (EntryReference<FieldEntry, MethodDefEntry> reference : referenceIndex.getReferencesToField(this.entry)) {
+                                add(new FieldReferenceTreeNode(translator, reference));
+                        }
+                } else {
+                        for (EntryReference<MethodEntry, MethodDefEntry> reference : referenceIndex.getReferencesToMethod(this.reference.context)) {
+                                add(new MethodReferenceTreeNode(translator, reference));
+                        }
+                }
+
+                if (recurse && children != null) {
+                        for (Object node : children) {
+                                if (node instanceof MethodReferenceTreeNode) {
+                                        ((MethodReferenceTreeNode) node).load(index, true, false);
+                                } else if (node instanceof FieldReferenceTreeNode) {
+                                        ((FieldReferenceTreeNode) node).load(index, true);
+                                }
+                        }
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/IndexSimpleVerifier.java b/enigma/src/main/java/cuchaz/enigma/analysis/IndexSimpleVerifier.java
new file mode 100644
index 0000000..ec8f323
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/IndexSimpleVerifier.java
@@ -0,0 +1,154 @@
+package cuchaz.enigma.analysis;
+
+import cuchaz.enigma.Enigma;
+import cuchaz.enigma.analysis.index.EntryIndex;
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.analysis.BasicValue;
+import org.objectweb.asm.tree.analysis.SimpleVerifier;
+
+import java.util.Set;
+
+public class IndexSimpleVerifier extends SimpleVerifier {
+    private static final Type OBJECT_TYPE = Type.getType("Ljava/lang/Object;");
+    private final EntryIndex entryIndex;
+    private final InheritanceIndex inheritanceIndex;
+
+    public IndexSimpleVerifier(EntryIndex entryIndex, InheritanceIndex inheritanceIndex) {
+        super(Enigma.ASM_VERSION, null, null, null, false);
+        this.entryIndex = entryIndex;
+        this.inheritanceIndex = inheritanceIndex;
+    }
+
+    @Override
+    protected boolean isSubTypeOf(BasicValue value, BasicValue expected) {
+        Type expectedType = expected.getType();
+        Type type = value.getType();
+        switch (expectedType.getSort()) {
+            case Type.INT:
+            case Type.FLOAT:
+            case Type.LONG:
+            case Type.DOUBLE:
+                return type.equals(expectedType);
+            case Type.ARRAY:
+            case Type.OBJECT:
+                if (type.equals(NULL_TYPE)) {
+                    return true;
+                } else if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
+                    if (isAssignableFrom(expectedType, type)) {
+                        return true;
+                    } else if (isInterface(expectedType)) {
+                        return isAssignableFrom(OBJECT_TYPE, type);
+                    } else {
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            default:
+                throw new AssertionError();
+        }
+    }
+
+    @Override
+    protected boolean isInterface(Type type) {
+        AccessFlags classAccess = entryIndex.getClassAccess(new ClassEntry(type.getInternalName()));
+        if (classAccess != null) {
+            return classAccess.isInterface();
+        }
+
+        Class<?> clazz = getClass(type);
+        if (clazz != null) {
+            return clazz.isInterface();
+        }
+
+        return false;
+    }
+
+    @Override
+    protected Type getSuperClass(Type type) {
+        ClassDefEntry definition = entryIndex.getDefinition(new ClassEntry(type.getInternalName()));
+        if (definition != null) {
+            return Type.getType('L' + definition.getSuperClass().getFullName() + ';');
+        }
+
+        Class<?> clazz = getClass(type);
+        if (clazz != null) {
+            return Type.getType(clazz.getSuperclass());
+        }
+
+        return OBJECT_TYPE;
+    }
+
+    @Override
+    protected boolean isAssignableFrom(Type type1, Type type2) {
+        if (type1.equals(type2)) {
+            return true;
+        }
+
+        if (type2.equals(NULL_TYPE)) {
+            return true;
+        }
+
+        if (type1.getSort() == Type.ARRAY) {
+            return type2.getSort() == Type.ARRAY && isAssignableFrom(Type.getType(type1.getDescriptor().substring(1)), Type.getType(type2.getDescriptor().substring(1)));
+        }
+
+        if (type2.getSort() == Type.ARRAY) {
+            return type1.equals(OBJECT_TYPE);
+        }
+
+        if (type1.getSort() == Type.OBJECT && type2.getSort() == Type.OBJECT) {
+            if (type1.equals(OBJECT_TYPE)) {
+                return true;
+            }
+
+            ClassEntry class1 = new ClassEntry(type1.getInternalName());
+            ClassEntry class2 = new ClassEntry(type2.getInternalName());
+
+            if (entryIndex.hasClass(class1) && entryIndex.hasClass(class2)) {
+                return inheritanceIndex.getAncestors(class2).contains(class1);
+            }
+
+            Class<?> class1Class = getClass(Type.getType('L' + class1.getFullName() + ';'));
+            Class<?> class2Class = getClass(Type.getType('L' + class2.getFullName() + ';'));
+
+            if (class1Class == null) {
+                return true; // missing classes to find out
+            }
+
+            if (class2Class != null) {
+                return class1Class.isAssignableFrom(class2Class);
+            }
+
+            if (entryIndex.hasClass(class2)) {
+                Set<ClassEntry> ancestors = inheritanceIndex.getAncestors(class2);
+
+                for (ClassEntry ancestorEntry : ancestors) {
+                    Class<?> ancestor = getClass(Type.getType('L' + ancestorEntry.getFullName() + ';'));
+                    if (ancestor == null || class1Class.isAssignableFrom(ancestor)) {
+                        return true; // assignable, or missing classes to find out
+                    }
+                }
+
+                return false;
+            }
+
+            return true; // missing classes to find out
+        }
+
+        return false;
+    }
+
+    @Override
+    protected final Class<?> getClass(Type type) {
+        try {
+            return Class.forName(type.getSort() == Type.ARRAY ? type.getDescriptor().replace('/', '.') : type.getClassName(), false, null);
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/IndexTreeBuilder.java b/enigma/src/main/java/cuchaz/enigma/analysis/IndexTreeBuilder.java
new file mode 100644
index 0000000..0c2dfd7
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/IndexTreeBuilder.java
@@ -0,0 +1,74 @@
+package cuchaz.enigma.analysis;
+
+import com.google.common.collect.Lists;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.ResolutionStrategy;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import java.util.Collection;
+import java.util.List;
+
+public class IndexTreeBuilder {
+        private final JarIndex index;
+
+        public IndexTreeBuilder(JarIndex index) {
+                this.index = index;
+        }
+
+        public ClassInheritanceTreeNode buildClassInheritance(Translator translator, ClassEntry obfClassEntry) {
+                // get the root node
+                List<String> ancestry = Lists.newArrayList();
+                ancestry.add(obfClassEntry.getFullName());
+                for (ClassEntry classEntry : index.getInheritanceIndex().getAncestors(obfClassEntry)) {
+                        ancestry.add(classEntry.getFullName());
+                }
+
+                ClassInheritanceTreeNode rootNode = new ClassInheritanceTreeNode(translator, ancestry.get(ancestry.size() - 1));
+
+                // expand all children recursively
+                rootNode.load(index.getInheritanceIndex(), true);
+
+                return rootNode;
+        }
+
+        public ClassImplementationsTreeNode buildClassImplementations(Translator translator, ClassEntry obfClassEntry) {
+                if (index.getInheritanceIndex().isParent(obfClassEntry)) {
+                        ClassImplementationsTreeNode node = new ClassImplementationsTreeNode(translator, obfClassEntry);
+                        node.load(index);
+                        return node;
+                }
+                return null;
+        }
+
+        public MethodInheritanceTreeNode buildMethodInheritance(Translator translator, MethodEntry obfMethodEntry) {
+                MethodEntry resolvedEntry = index.getEntryResolver().resolveFirstEntry(obfMethodEntry, ResolutionStrategy.RESOLVE_ROOT);
+
+                // make a root node at the base
+                MethodInheritanceTreeNode rootNode = new MethodInheritanceTreeNode(
+                                translator, resolvedEntry,
+                                index.getEntryIndex().hasMethod(resolvedEntry)
+                );
+
+                // expand the full tree
+                rootNode.load(index);
+
+                return rootNode;
+        }
+
+        public List<MethodImplementationsTreeNode> buildMethodImplementations(Translator translator, MethodEntry obfMethodEntry) {
+                EntryResolver resolver = index.getEntryResolver();
+                Collection<MethodEntry> resolvedEntries = resolver.resolveEntry(obfMethodEntry, ResolutionStrategy.RESOLVE_ROOT);
+
+                List<MethodImplementationsTreeNode> nodes = Lists.newArrayList();
+                for (MethodEntry resolvedEntry : resolvedEntries) {
+                        MethodImplementationsTreeNode node = new MethodImplementationsTreeNode(translator, resolvedEntry);
+                        node.load(index);
+                        nodes.add(node);
+                }
+
+                return nodes;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/InterpreterPair.java b/enigma/src/main/java/cuchaz/enigma/analysis/InterpreterPair.java
new file mode 100644
index 0000000..fad10bf
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/InterpreterPair.java
@@ -0,0 +1,130 @@
+package cuchaz.enigma.analysis;
+
+import cuchaz.enigma.Enigma;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.analysis.AnalyzerException;
+import org.objectweb.asm.tree.analysis.Interpreter;
+import org.objectweb.asm.tree.analysis.Value;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class InterpreterPair<V extends Value, W extends Value> extends Interpreter<InterpreterPair.PairValue<V, W>> {
+    private final Interpreter<V> left;
+    private final Interpreter<W> right;
+
+    public InterpreterPair(Interpreter<V> left, Interpreter<W> right) {
+        super(Enigma.ASM_VERSION);
+        this.left = left;
+        this.right = right;
+    }
+
+    @Override
+    public PairValue<V, W> newValue(Type type) {
+        return pair(
+                left.newValue(type),
+                right.newValue(type)
+        );
+    }
+
+    @Override
+    public PairValue<V, W> newOperation(AbstractInsnNode insn) throws AnalyzerException {
+        return pair(
+                left.newOperation(insn),
+                right.newOperation(insn)
+        );
+    }
+
+    @Override
+    public PairValue<V, W> copyOperation(AbstractInsnNode insn, PairValue<V, W> value) throws AnalyzerException {
+        return pair(
+                left.copyOperation(insn, value.left),
+                right.copyOperation(insn, value.right)
+        );
+    }
+
+    @Override
+    public PairValue<V, W> unaryOperation(AbstractInsnNode insn, PairValue<V, W> value) throws AnalyzerException {
+        return pair(
+                left.unaryOperation(insn, value.left),
+                right.unaryOperation(insn, value.right)
+        );
+    }
+
+    @Override
+    public PairValue<V, W> binaryOperation(AbstractInsnNode insn, PairValue<V, W> value1, PairValue<V, W> value2) throws AnalyzerException {
+        return pair(
+                left.binaryOperation(insn, value1.left, value2.left),
+                right.binaryOperation(insn, value1.right, value2.right)
+        );
+    }
+
+    @Override
+    public PairValue<V, W> ternaryOperation(AbstractInsnNode insn, PairValue<V, W> value1, PairValue<V, W> value2, PairValue<V, W> value3) throws AnalyzerException {
+        return pair(
+                left.ternaryOperation(insn, value1.left, value2.left, value3.left),
+                right.ternaryOperation(insn, value1.right, value2.right, value3.right)
+        );
+    }
+
+    @Override
+    public PairValue<V, W> naryOperation(AbstractInsnNode insn, List<? extends PairValue<V, W>> values) throws AnalyzerException {
+        return pair(
+                left.naryOperation(insn, values.stream().map(v -> v.left).collect(Collectors.toList())),
+                right.naryOperation(insn, values.stream().map(v -> v.right).collect(Collectors.toList()))
+        );
+    }
+
+    @Override
+    public void returnOperation(AbstractInsnNode insn, PairValue<V, W> value, PairValue<V, W> expected) throws AnalyzerException {
+        left.returnOperation(insn, value.left, expected.left);
+        right.returnOperation(insn, value.right, expected.right);
+    }
+
+    @Override
+    public PairValue<V, W> merge(PairValue<V, W> value1, PairValue<V, W> value2) {
+        return pair(
+                left.merge(value1.left, value2.left),
+                right.merge(value1.right, value2.right)
+        );
+    }
+
+    private PairValue<V, W> pair(V left, W right) {
+        if (left == null && right == null) {
+            return null;
+        }
+
+        return new PairValue<>(left, right);
+    }
+
+    public static final class PairValue<V extends Value, W extends Value> implements Value {
+        public final V left;
+        public final W right;
+
+        public PairValue(V left, W right) {
+            if (left == null && right == null) {
+                throw new IllegalArgumentException("should use null rather than pair of nulls");
+            }
+
+            this.left = left;
+            this.right = right;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            return o instanceof InterpreterPair.PairValue && Objects.equals(left, ((PairValue) o).left) && Objects.equals(right, ((PairValue) o).right);
+        }
+
+        @Override
+        public int hashCode() {
+            return left.hashCode() * 31 + right.hashCode();
+        }
+
+        @Override
+        public int getSize() {
+            return (left == null ? right : left).getSize();
+        }
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
new file mode 100644
index 0000000..b09f7ac
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import com.google.common.collect.Lists;
+import cuchaz.enigma.analysis.index.EntryIndex;
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import java.util.Collection;
+import java.util.List;
+
+public class MethodImplementationsTreeNode extends DefaultMutableTreeNode {
+
+        private final Translator translator;
+        private MethodEntry entry;
+
+        public MethodImplementationsTreeNode(Translator translator, MethodEntry entry) {
+                this.translator = translator;
+                if (entry == null) {
+                        throw new IllegalArgumentException("Entry cannot be null!");
+                }
+
+                this.entry = entry;
+        }
+
+        public static MethodImplementationsTreeNode findNode(MethodImplementationsTreeNode node, MethodEntry entry) {
+                // is this the node?
+                if (node.getMethodEntry().equals(entry)) {
+                        return node;
+                }
+
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        MethodImplementationsTreeNode foundNode = findNode((MethodImplementationsTreeNode) node.getChildAt(i), entry);
+                        if (foundNode != null) {
+                                return foundNode;
+                        }
+                }
+                return null;
+        }
+
+        public MethodEntry getMethodEntry() {
+                return this.entry;
+        }
+
+        @Override
+        public String toString() {
+                MethodEntry translatedEntry = translator.translate(entry);
+                String className = translatedEntry.getParent().getFullName();
+                String methodName = translatedEntry.getName();
+                return className + "." + methodName + "()";
+        }
+
+        public void load(JarIndex index) {
+                // get all method implementations
+                List<MethodImplementationsTreeNode> nodes = Lists.newArrayList();
+                EntryIndex entryIndex = index.getEntryIndex();
+                InheritanceIndex inheritanceIndex = index.getInheritanceIndex();
+
+                Collection<ClassEntry> descendants = inheritanceIndex.getDescendants(entry.getParent());
+                for (ClassEntry inheritor : descendants) {
+                        MethodEntry methodEntry = entry.withParent(inheritor);
+                        if (entryIndex.hasMethod(methodEntry)) {
+                                nodes.add(new MethodImplementationsTreeNode(translator, methodEntry));
+                        }
+                }
+
+                // add them to this node
+                nodes.forEach(this::add);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
new file mode 100644
index 0000000..e77b5cc
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
@@ -0,0 +1,95 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import cuchaz.enigma.analysis.index.EntryIndex;
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+public class MethodInheritanceTreeNode extends DefaultMutableTreeNode {
+
+        private final Translator translator;
+        private MethodEntry entry;
+        private boolean implemented;
+
+        public MethodInheritanceTreeNode(Translator translator, MethodEntry entry, boolean implemented) {
+                this.translator = translator;
+                this.entry = entry;
+                this.implemented = implemented;
+        }
+
+        public static MethodInheritanceTreeNode findNode(MethodInheritanceTreeNode node, MethodEntry entry) {
+                // is this the node?
+                if (node.getMethodEntry().equals(entry)) {
+                        return node;
+                }
+
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        MethodInheritanceTreeNode foundNode = findNode((MethodInheritanceTreeNode) node.getChildAt(i), entry);
+                        if (foundNode != null) {
+                                return foundNode;
+                        }
+                }
+                return null;
+        }
+
+        public MethodEntry getMethodEntry() {
+                return this.entry;
+        }
+
+        public boolean isImplemented() {
+                return this.implemented;
+        }
+
+        @Override
+        public String toString() {
+                MethodEntry translatedEntry = translator.translate(entry);
+                String className = translatedEntry.getContainingClass().getFullName();
+
+                if (!this.implemented) {
+                        return className;
+                } else {
+                        String methodName = translatedEntry.getName();
+                        return className + "." + methodName + "()";
+                }
+        }
+
+        /**
+         * Returns true if there is sub-node worthy to display.
+         */
+        public boolean load(JarIndex index) {
+                // get all the child nodes
+                EntryIndex entryIndex = index.getEntryIndex();
+                InheritanceIndex inheritanceIndex = index.getInheritanceIndex();
+
+                boolean ret = false;
+                for (ClassEntry inheritorEntry : inheritanceIndex.getChildren(this.entry.getParent())) {
+                        MethodEntry methodEntry = new MethodEntry(inheritorEntry, this.entry.getName(), this.entry.getDesc());
+
+                        MethodInheritanceTreeNode node = new MethodInheritanceTreeNode(translator, methodEntry, entryIndex.hasMethod(methodEntry));
+                        boolean childOverride = node.load(index);
+
+                        if (childOverride || node.implemented) {
+                                this.add(node);
+                                ret = true;
+                        }
+                }
+
+                return ret;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/MethodNodeWithAction.java b/enigma/src/main/java/cuchaz/enigma/analysis/MethodNodeWithAction.java
new file mode 100644
index 0000000..8117103
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/MethodNodeWithAction.java
@@ -0,0 +1,19 @@
+package cuchaz.enigma.analysis;
+
+import org.objectweb.asm.tree.MethodNode;
+
+import java.util.function.Consumer;
+
+public class MethodNodeWithAction extends MethodNode {
+    private final Consumer<MethodNode> action;
+
+    public MethodNodeWithAction(int api, int access, String name, String descriptor, String signature, String[] exceptions, Consumer<MethodNode> action) {
+        super(api, access, name, descriptor, signature, exceptions);
+        this.action = action;
+    }
+
+    @Override
+    public void visitEnd() {
+        action.accept(this);
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/MethodReferenceTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/MethodReferenceTreeNode.java
new file mode 100644
index 0000000..8995eb5
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/MethodReferenceTreeNode.java
@@ -0,0 +1,113 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import com.google.common.collect.Sets;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.analysis.index.ReferenceIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreeNode;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Set;
+
+public class MethodReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode<MethodEntry, MethodDefEntry> {
+
+        private final Translator translator;
+        private MethodEntry entry;
+        private EntryReference<MethodEntry, MethodDefEntry> reference;
+
+        public MethodReferenceTreeNode(Translator translator, MethodEntry entry) {
+                this.translator = translator;
+                this.entry = entry;
+                this.reference = null;
+        }
+
+        public MethodReferenceTreeNode(Translator translator, EntryReference<MethodEntry, MethodDefEntry> reference) {
+                this.translator = translator;
+                this.entry = reference.entry;
+                this.reference = reference;
+        }
+
+        @Override
+        public MethodEntry getEntry() {
+                return this.entry;
+        }
+
+        @Override
+        public EntryReference<MethodEntry, MethodDefEntry> getReference() {
+                return this.reference;
+        }
+
+        @Override
+        public String toString() {
+                if (this.reference != null) {
+                        return String.format("%s", translator.translate(this.reference.context));
+                }
+                return translator.translate(this.entry).getName();
+        }
+
+        public void load(JarIndex index, boolean recurse, boolean recurseMethod) {
+                // get all the child nodes
+                Collection<EntryReference<MethodEntry, MethodDefEntry>> references = getReferences(index, recurseMethod);
+
+                for (EntryReference<MethodEntry, MethodDefEntry> reference : references) {
+                        add(new MethodReferenceTreeNode(translator, reference));
+                }
+
+                if (recurse && this.children != null) {
+                        for (Object child : this.children) {
+                                if (child instanceof MethodReferenceTreeNode) {
+                                        MethodReferenceTreeNode node = (MethodReferenceTreeNode) child;
+
+                                        // don't recurse into ancestor
+                                        Set<Entry<?>> ancestors = Sets.newHashSet();
+                                        TreeNode n = node;
+                                        while (n.getParent() != null) {
+                                                n = n.getParent();
+                                                if (n instanceof MethodReferenceTreeNode) {
+                                                        ancestors.add(((MethodReferenceTreeNode) n).getEntry());
+                                                }
+                                        }
+                                        if (ancestors.contains(node.getEntry())) {
+                                                continue;
+                                        }
+
+                                        node.load(index, true, false);
+                                }
+                        }
+                }
+        }
+
+        private Collection<EntryReference<MethodEntry, MethodDefEntry>> getReferences(JarIndex index, boolean recurseMethod) {
+                ReferenceIndex referenceIndex = index.getReferenceIndex();
+
+                if (recurseMethod) {
+                        Collection<EntryReference<MethodEntry, MethodDefEntry>> references = new ArrayList<>();
+
+                        EntryResolver entryResolver = index.getEntryResolver();
+                        for (MethodEntry methodEntry : entryResolver.resolveEquivalentMethods(entry)) {
+                                references.addAll(referenceIndex.getReferencesToMethod(methodEntry));
+                        }
+
+                        return references;
+                } else {
+                        return referenceIndex.getReferencesToMethod(entry);
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ReferenceTargetType.java b/enigma/src/main/java/cuchaz/enigma/analysis/ReferenceTargetType.java
new file mode 100644
index 0000000..5b19d18
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/ReferenceTargetType.java
@@ -0,0 +1,74 @@
+package cuchaz.enigma.analysis;
+
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+
+public abstract class ReferenceTargetType {
+    private static final None NONE = new None();
+    private static final Uninitialized UNINITIALIZED = new Uninitialized();
+
+    public abstract Kind getKind();
+
+    public static None none() {
+        return NONE;
+    }
+
+    public static Uninitialized uninitialized() {
+        return UNINITIALIZED;
+    }
+
+    public static ClassType classType(ClassEntry name) {
+        return new ClassType(name);
+    }
+
+    public enum Kind {
+        NONE,
+        UNINITIALIZED,
+        CLASS_TYPE
+    }
+
+    public static class None extends ReferenceTargetType {
+        @Override
+        public Kind getKind() {
+            return Kind.NONE;
+        }
+
+        @Override
+        public String toString() {
+            return "(none)";
+        }
+    }
+
+    public static class Uninitialized extends ReferenceTargetType {
+        @Override
+        public Kind getKind() {
+            return Kind.UNINITIALIZED;
+        }
+
+        @Override
+        public String toString() {
+            return "(uninitialized)";
+        }
+    }
+
+    public static class ClassType extends ReferenceTargetType {
+        private final ClassEntry entry;
+
+        private ClassType(ClassEntry entry) {
+            this.entry = entry;
+        }
+
+        public ClassEntry getEntry() {
+            return entry;
+        }
+
+        @Override
+        public Kind getKind() {
+            return Kind.CLASS_TYPE;
+        }
+
+        @Override
+        public String toString() {
+            return entry.toString();
+        }
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ReferenceTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/ReferenceTreeNode.java
new file mode 100644
index 0000000..c0a3a75
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/ReferenceTreeNode.java
@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * 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.analysis;
+
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+public interface ReferenceTreeNode<E extends Entry<?>, C extends Entry<?>> {
+        E getEntry();
+
+        EntryReference<E, C> getReference();
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/BridgeMethodIndex.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/BridgeMethodIndex.java
new file mode 100644
index 0000000..a4b1aac
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/BridgeMethodIndex.java
@@ -0,0 +1,156 @@
+package cuchaz.enigma.analysis.index;
+
+import com.google.common.collect.Maps;
+import cuchaz.enigma.translation.representation.AccessFlags;
+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.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import javax.annotation.Nullable;
+import java.util.*;
+
+public class BridgeMethodIndex implements JarIndexer {
+        private final EntryIndex entryIndex;
+        private final InheritanceIndex inheritanceIndex;
+        private final ReferenceIndex referenceIndex;
+
+        private final Map<MethodEntry, MethodEntry> bridgeToSpecialized = Maps.newHashMap();
+        private final Map<MethodEntry, MethodEntry> specializedToBridge = Maps.newHashMap();
+
+        public BridgeMethodIndex(EntryIndex entryIndex, InheritanceIndex inheritanceIndex, ReferenceIndex referenceIndex) {
+                this.entryIndex = entryIndex;
+                this.inheritanceIndex = inheritanceIndex;
+                this.referenceIndex = referenceIndex;
+        }
+
+        public void findBridgeMethods() {
+                // look for access and bridged methods
+                for (MethodEntry methodEntry : entryIndex.getMethods()) {
+                        MethodDefEntry methodDefEntry = (MethodDefEntry) methodEntry;
+
+                        AccessFlags access = methodDefEntry.getAccess();
+                        if (access == null || !access.isSynthetic()) {
+                                continue;
+                        }
+
+                        indexSyntheticMethod(methodDefEntry, access);
+                }
+        }
+
+        @Override
+        public void processIndex(JarIndex index) {
+                Map<MethodEntry, MethodEntry> copiedAccessToBridge = new HashMap<>(specializedToBridge);
+
+                for (Map.Entry<MethodEntry, MethodEntry> entry : copiedAccessToBridge.entrySet()) {
+                        MethodEntry specializedEntry = entry.getKey();
+                        MethodEntry bridgeEntry = entry.getValue();
+                        if (bridgeEntry.getName().equals(specializedEntry.getName())) {
+                                continue;
+                        }
+
+                        MethodEntry renamedSpecializedEntry = specializedEntry.withName(bridgeEntry.getName());
+                        specializedToBridge.put(renamedSpecializedEntry, specializedToBridge.get(specializedEntry));
+                }
+        }
+
+        private void indexSyntheticMethod(MethodDefEntry syntheticMethod, AccessFlags access) {
+                MethodEntry specializedMethod = findSpecializedMethod(syntheticMethod);
+                if (specializedMethod == null) {
+                        return;
+                }
+
+                if (access.isBridge() || isPotentialBridge(syntheticMethod, specializedMethod)) {
+                        bridgeToSpecialized.put(syntheticMethod, specializedMethod);
+                        specializedToBridge.put(specializedMethod, syntheticMethod);
+                }
+        }
+
+        private MethodEntry findSpecializedMethod(MethodEntry method) {
+                // we want to find all compiler-added methods that directly call another with no processing
+
+                // get all the methods that we call
+                final Collection<MethodEntry> referencedMethods = referenceIndex.getMethodsReferencedBy(method);
+
+                // is there just one?
+                if (referencedMethods.size() != 1) {
+                        return null;
+                }
+
+                return referencedMethods.stream().findFirst().orElse(null);
+        }
+
+        private boolean isPotentialBridge(MethodDefEntry bridgeMethod, MethodEntry specializedMethod) {
+                // Bridge methods only exist for inheritance purposes, if we're private, final, or static, we cannot be inherited
+                AccessFlags bridgeAccess = bridgeMethod.getAccess();
+                if (bridgeAccess.isPrivate() || bridgeAccess.isFinal() || bridgeAccess.isStatic()) {
+                        return false;
+                }
+
+                MethodDescriptor bridgeDesc = bridgeMethod.getDesc();
+                MethodDescriptor specializedDesc = specializedMethod.getDesc();
+                List<TypeDescriptor> bridgeArguments = bridgeDesc.getArgumentDescs();
+                List<TypeDescriptor> specializedArguments = specializedDesc.getArgumentDescs();
+
+                // A bridge method will always have the same number of arguments
+                if (bridgeArguments.size() != specializedArguments.size()) {
+                        return false;
+                }
+
+                // Check that all argument types are bridge-compatible
+                for (int i = 0; i < bridgeArguments.size(); i++) {
+                        if (!areTypesBridgeCompatible(bridgeArguments.get(i), specializedArguments.get(i))) {
+                                return false;
+                        }
+                }
+
+                // Check that the return type is bridge-compatible
+                return areTypesBridgeCompatible(bridgeDesc.getReturnDesc(), specializedDesc.getReturnDesc());
+        }
+
+        private boolean areTypesBridgeCompatible(TypeDescriptor bridgeDesc, TypeDescriptor specializedDesc) {
+                if (bridgeDesc.equals(specializedDesc)) {
+                        return true;
+                }
+
+                // Either the descs will be equal, or they are both types and different through a generic
+                if (bridgeDesc.isType() && specializedDesc.isType()) {
+                        ClassEntry bridgeType = bridgeDesc.getTypeEntry();
+                        ClassEntry accessedType = specializedDesc.getTypeEntry();
+
+                        // If the given types are completely unrelated to each other, this can't be bridge compatible
+                        InheritanceIndex.Relation relation = inheritanceIndex.computeClassRelation(accessedType, bridgeType);
+                        return relation != InheritanceIndex.Relation.UNRELATED;
+                }
+
+                return false;
+        }
+
+        public boolean isBridgeMethod(MethodEntry entry) {
+                return bridgeToSpecialized.containsKey(entry);
+        }
+
+        public boolean isSpecializedMethod(MethodEntry entry) {
+                return specializedToBridge.containsKey(entry);
+        }
+
+        @Nullable
+        public MethodEntry getBridgeFromSpecialized(MethodEntry specialized) {
+                return specializedToBridge.get(specialized);
+        }
+
+        public MethodEntry getSpecializedFromBridge(MethodEntry bridge) {
+                return bridgeToSpecialized.get(bridge);
+        }
+
+        /** Includes "renamed specialized -> bridge" entries. */
+        public Map<MethodEntry, MethodEntry> getSpecializedToBridge() {
+                return Collections.unmodifiableMap(specializedToBridge);
+        }
+
+        /** Only "bridge -> original name" entries. **/
+        public Map<MethodEntry, MethodEntry> getBridgeToSpecialized() {
+                return Collections.unmodifiableMap(bridgeToSpecialized);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/EntryIndex.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/EntryIndex.java
new file mode 100644
index 0000000..9a2726e
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/EntryIndex.java
@@ -0,0 +1,102 @@
+package cuchaz.enigma.analysis.index;
+
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.entry.*;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+public class EntryIndex implements JarIndexer {
+        private Map<ClassEntry, AccessFlags> classes = new HashMap<>();
+        private Map<FieldEntry, AccessFlags> fields = new HashMap<>();
+        private Map<MethodEntry, AccessFlags> methods = new HashMap<>();
+        private Map<ClassEntry, ClassDefEntry> definitions = new HashMap<>();
+
+        @Override
+        public void indexClass(ClassDefEntry classEntry) {
+                definitions.put(classEntry, classEntry);
+                classes.put(classEntry, classEntry.getAccess());
+        }
+
+        @Override
+        public void indexMethod(MethodDefEntry methodEntry) {
+                methods.put(methodEntry, methodEntry.getAccess());
+        }
+
+        @Override
+        public void indexField(FieldDefEntry fieldEntry) {
+                fields.put(fieldEntry, fieldEntry.getAccess());
+        }
+
+        public boolean hasClass(ClassEntry entry) {
+                return classes.containsKey(entry);
+        }
+
+        public boolean hasMethod(MethodEntry entry) {
+                return methods.containsKey(entry);
+        }
+
+        public boolean hasField(FieldEntry entry) {
+                return fields.containsKey(entry);
+        }
+
+        public boolean hasEntry(Entry<?> entry) {
+                if (entry instanceof ClassEntry) {
+                        return hasClass((ClassEntry) entry);
+                } else if (entry instanceof MethodEntry) {
+                        return hasMethod((MethodEntry) entry);
+                } else if (entry instanceof FieldEntry) {
+                        return hasField((FieldEntry) entry);
+                } else if (entry instanceof LocalVariableEntry) {
+                        return hasMethod(((LocalVariableEntry) entry).getParent());
+                }
+
+                return false;
+        }
+
+        @Nullable
+        public AccessFlags getMethodAccess(MethodEntry entry) {
+                return methods.get(entry);
+        }
+
+        @Nullable
+        public AccessFlags getFieldAccess(FieldEntry entry) {
+                return fields.get(entry);
+        }
+
+        @Nullable
+        public AccessFlags getClassAccess(ClassEntry entry) {
+                return classes.get(entry);
+        }
+
+        @Nullable
+        public AccessFlags getEntryAccess(Entry<?> entry) {
+                if (entry instanceof MethodEntry) {
+                        return getMethodAccess((MethodEntry) entry);
+                } else if (entry instanceof FieldEntry) {
+                        return getFieldAccess((FieldEntry) entry);
+                } else if (entry instanceof LocalVariableEntry) {
+                        return getMethodAccess(((LocalVariableEntry) entry).getParent());
+                }
+
+                return null;
+        }
+
+        public ClassDefEntry getDefinition(ClassEntry entry) {
+                return definitions.get(entry);
+        }
+
+        public Collection<ClassEntry> getClasses() {
+                return classes.keySet();
+        }
+
+        public Collection<MethodEntry> getMethods() {
+                return methods.keySet();
+        }
+
+        public Collection<FieldEntry> getFields() {
+                return fields.keySet();
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/IndexClassVisitor.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/IndexClassVisitor.java
new file mode 100644
index 0000000..f9cb23c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/IndexClassVisitor.java
@@ -0,0 +1,40 @@
+package cuchaz.enigma.analysis.index;
+
+import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
+import cuchaz.enigma.translation.representation.entry.FieldDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+
+public class IndexClassVisitor extends ClassVisitor {
+        private final JarIndexer indexer;
+        private ClassDefEntry classEntry;
+
+        public IndexClassVisitor(JarIndex indexer, int api) {
+                super(api);
+                this.indexer = indexer;
+        }
+
+        @Override
+        public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+                classEntry = ClassDefEntry.parse(access, name, signature, superName, interfaces);
+                indexer.indexClass(classEntry);
+
+                super.visit(version, access, name, signature, superName, interfaces);
+        }
+
+        @Override
+        public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
+                indexer.indexField(FieldDefEntry.parse(classEntry, access, name, desc, signature));
+
+                return super.visitField(access, name, desc, signature, value);
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+                indexer.indexMethod(MethodDefEntry.parse(classEntry, access, name, desc, signature));
+
+                return super.visitMethod(access, name, desc, signature, exceptions);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/IndexReferenceVisitor.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/IndexReferenceVisitor.java
new file mode 100644
index 0000000..f3d419e
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/IndexReferenceVisitor.java
@@ -0,0 +1,180 @@
+package cuchaz.enigma.analysis.index;
+
+import cuchaz.enigma.analysis.IndexSimpleVerifier;
+import cuchaz.enigma.analysis.InterpreterPair;
+import cuchaz.enigma.analysis.MethodNodeWithAction;
+import cuchaz.enigma.analysis.ReferenceTargetType;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.Lambda;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.Signature;
+import cuchaz.enigma.translation.representation.entry.*;
+import org.objectweb.asm.*;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.InvokeDynamicInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.analysis.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class IndexReferenceVisitor extends ClassVisitor {
+        private final JarIndexer indexer;
+        private final EntryIndex entryIndex;
+        private final InheritanceIndex inheritanceIndex;
+        private ClassEntry classEntry;
+        private String className;
+
+        public IndexReferenceVisitor(JarIndexer indexer, EntryIndex entryIndex, InheritanceIndex inheritanceIndex, int api) {
+                super(api);
+                this.indexer = indexer;
+                this.entryIndex = entryIndex;
+                this.inheritanceIndex = inheritanceIndex;
+        }
+
+        @Override
+        public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+                classEntry = new ClassEntry(name);
+                className = name;
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+                MethodDefEntry entry = new MethodDefEntry(classEntry, name, new MethodDescriptor(desc), Signature.createSignature(signature), new AccessFlags(access));
+                return new MethodNodeWithAction(api, access, name, desc, signature, exceptions, methodNode -> {
+                        try {
+                                new Analyzer<>(new MethodInterpreter(entry, indexer, entryIndex, inheritanceIndex)).analyze(className, methodNode);
+                        } catch (AnalyzerException e) {
+                                throw new RuntimeException(e);
+                        }
+                });
+        }
+
+        private static class MethodInterpreter extends InterpreterPair<BasicValue, SourceValue> {
+                private final MethodDefEntry callerEntry;
+                private JarIndexer indexer;
+
+                public MethodInterpreter(MethodDefEntry callerEntry, JarIndexer indexer, EntryIndex entryIndex, InheritanceIndex inheritanceIndex) {
+                        super(new IndexSimpleVerifier(entryIndex, inheritanceIndex), new SourceInterpreter());
+                        this.callerEntry = callerEntry;
+                        this.indexer = indexer;
+                }
+
+                @Override
+                public PairValue<BasicValue, SourceValue> newOperation(AbstractInsnNode insn) throws AnalyzerException {
+                        if (insn.getOpcode() == Opcodes.GETSTATIC) {
+                                FieldInsnNode field = (FieldInsnNode) insn;
+                                indexer.indexFieldReference(callerEntry, FieldEntry.parse(field.owner, field.name, field.desc), ReferenceTargetType.none());
+                        }
+
+                        return super.newOperation(insn);
+                }
+
+                @Override
+                public PairValue<BasicValue, SourceValue> unaryOperation(AbstractInsnNode insn, PairValue<BasicValue, SourceValue> value) throws AnalyzerException {
+                        if (insn.getOpcode() == Opcodes.PUTSTATIC) {
+                                FieldInsnNode field = (FieldInsnNode) insn;
+                                indexer.indexFieldReference(callerEntry, FieldEntry.parse(field.owner, field.name, field.desc), ReferenceTargetType.none());
+                        }
+
+                        if (insn.getOpcode() == Opcodes.GETFIELD) {
+                                FieldInsnNode field = (FieldInsnNode) insn;
+                                indexer.indexFieldReference(callerEntry, FieldEntry.parse(field.owner, field.name, field.desc), getReferenceTargetType(value, insn));
+                        }
+
+                        return super.unaryOperation(insn, value);
+                }
+
+
+                @Override
+                public PairValue<BasicValue, SourceValue> binaryOperation(AbstractInsnNode insn, PairValue<BasicValue, SourceValue> value1, PairValue<BasicValue, SourceValue> value2) throws AnalyzerException {
+                        if (insn.getOpcode() == Opcodes.PUTFIELD) {
+                                FieldInsnNode field = (FieldInsnNode) insn;
+                                FieldEntry fieldEntry = FieldEntry.parse(field.owner, field.name, field.desc);
+                                indexer.indexFieldReference(callerEntry, fieldEntry, ReferenceTargetType.none());
+                        }
+
+                        return super.binaryOperation(insn, value1, value2);
+                }
+
+                @Override
+                public PairValue<BasicValue, SourceValue> naryOperation(AbstractInsnNode insn, List<? extends PairValue<BasicValue, SourceValue>> values) throws AnalyzerException {
+                        if (insn.getOpcode() == Opcodes.INVOKEINTERFACE || insn.getOpcode() == Opcodes.INVOKESPECIAL || insn.getOpcode() == Opcodes.INVOKEVIRTUAL) {
+                                MethodInsnNode methodInsn = (MethodInsnNode) insn;
+                                indexer.indexMethodReference(callerEntry, MethodEntry.parse(methodInsn.owner, methodInsn.name, methodInsn.desc), getReferenceTargetType(values.get(0), insn));
+                        }
+
+                        if (insn.getOpcode() == Opcodes.INVOKESTATIC) {
+                                MethodInsnNode methodInsn = (MethodInsnNode) insn;
+                                indexer.indexMethodReference(callerEntry, MethodEntry.parse(methodInsn.owner, methodInsn.name, methodInsn.desc), ReferenceTargetType.none());
+                        }
+
+                        if (insn.getOpcode() == Opcodes.INVOKEDYNAMIC) {
+                                InvokeDynamicInsnNode invokeDynamicInsn = (InvokeDynamicInsnNode) insn;
+                                List<AbstractInsnNode> args = values.stream().map(v -> v.right.insns.stream().findFirst().orElseThrow(AssertionError::new)).collect(Collectors.toList());
+
+                                if ("java/lang/invoke/LambdaMetafactory".equals(invokeDynamicInsn.bsm.getOwner()) && "metafactory".equals(invokeDynamicInsn.bsm.getName())) {
+                                        Type samMethodType = (Type) invokeDynamicInsn.bsmArgs[0];
+                                        Handle implMethod = (Handle) invokeDynamicInsn.bsmArgs[1];
+                                        Type instantiatedMethodType = (Type) invokeDynamicInsn.bsmArgs[2];
+
+                                        ReferenceTargetType targetType;
+                                        if (implMethod.getTag() != Opcodes.H_GETSTATIC && implMethod.getTag() != Opcodes.H_PUTFIELD && implMethod.getTag() != Opcodes.H_INVOKESTATIC) {
+                                                if (instantiatedMethodType.getArgumentTypes().length < Type.getArgumentTypes(implMethod.getDesc()).length) {
+                                                        targetType = getReferenceTargetType(values.get(0), insn);
+                                                } else {
+                                                        targetType = ReferenceTargetType.none(); // no "this" argument
+                                                }
+                                        } else {
+                                                targetType = ReferenceTargetType.none();
+                                        }
+
+                                        indexer.indexLambda(callerEntry, new Lambda(
+                                                        invokeDynamicInsn.name,
+                                                        new MethodDescriptor(invokeDynamicInsn.desc),
+                                                        new MethodDescriptor(samMethodType.getDescriptor()),
+                                                        getHandleEntry(implMethod),
+                                                        new MethodDescriptor(instantiatedMethodType.getDescriptor())
+                                        ), targetType);
+                                }
+                        }
+
+                        return super.naryOperation(insn, values);
+                }
+
+                private ReferenceTargetType getReferenceTargetType(PairValue<BasicValue, SourceValue> target, AbstractInsnNode insn) throws AnalyzerException {
+                        if (target.left == BasicValue.UNINITIALIZED_VALUE) {
+                                return ReferenceTargetType.uninitialized();
+                        }
+
+                        if (target.left.getType().getSort() == Type.OBJECT) {
+                                return ReferenceTargetType.classType(new ClassEntry(target.left.getType().getInternalName()));
+                        }
+
+                        if (target.left.getType().getSort() == Type.ARRAY) {
+                                return ReferenceTargetType.classType(new ClassEntry("java/lang/Object"));
+                        }
+
+                        throw new AnalyzerException(insn, "called method on or accessed field of non-object type");
+                }
+
+                private static ParentedEntry<?> getHandleEntry(Handle handle) {
+                        switch (handle.getTag()) {
+                                case Opcodes.H_GETFIELD:
+                                case Opcodes.H_GETSTATIC:
+                                case Opcodes.H_PUTFIELD:
+                                case Opcodes.H_PUTSTATIC:
+                                        return FieldEntry.parse(handle.getOwner(), handle.getName(), handle.getDesc());
+                                case Opcodes.H_INVOKEINTERFACE:
+                                case Opcodes.H_INVOKESPECIAL:
+                                case Opcodes.H_INVOKESTATIC:
+                                case Opcodes.H_INVOKEVIRTUAL:
+                                case Opcodes.H_NEWINVOKESPECIAL:
+                                        return MethodEntry.parse(handle.getOwner(), handle.getName(), handle.getDesc());
+                        }
+
+                        throw new RuntimeException("Invalid handle tag " + handle.getTag());
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/InheritanceIndex.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/InheritanceIndex.java
new file mode 100644
index 0000000..1ab2abd
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/InheritanceIndex.java
@@ -0,0 +1,127 @@
+/*******************************************************************************
+ * 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.analysis.index;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Set;
+
+public class InheritanceIndex implements JarIndexer {
+        private final EntryIndex entryIndex;
+
+        private Multimap<ClassEntry, ClassEntry> classParents = HashMultimap.create();
+        private Multimap<ClassEntry, ClassEntry> classChildren = HashMultimap.create();
+
+        public InheritanceIndex(EntryIndex entryIndex) {
+                this.entryIndex = entryIndex;
+        }
+
+        @Override
+        public void indexClass(ClassDefEntry classEntry) {
+                if (classEntry.isJre()) {
+                        return;
+                }
+
+                ClassEntry superClass = classEntry.getSuperClass();
+                if (superClass != null && !superClass.getName().equals("java/lang/Object")) {
+                        indexParent(classEntry, superClass);
+                }
+
+                for (ClassEntry interfaceEntry : classEntry.getInterfaces()) {
+                        indexParent(classEntry, interfaceEntry);
+                }
+        }
+
+        private void indexParent(ClassEntry childEntry, ClassEntry parentEntry) {
+                classParents.put(childEntry, parentEntry);
+                classChildren.put(parentEntry, childEntry);
+        }
+
+        public Collection<ClassEntry> getParents(ClassEntry classEntry) {
+                return classParents.get(classEntry);
+        }
+
+        public Collection<ClassEntry> getChildren(ClassEntry classEntry) {
+                return classChildren.get(classEntry);
+        }
+
+        public Collection<ClassEntry> getDescendants(ClassEntry classEntry) {
+                Collection<ClassEntry> descendants = new HashSet<>();
+
+                LinkedList<ClassEntry> descendantQueue = new LinkedList<>();
+                descendantQueue.push(classEntry);
+
+                while (!descendantQueue.isEmpty()) {
+                        ClassEntry descendant = descendantQueue.pop();
+                        Collection<ClassEntry> children = getChildren(descendant);
+
+                        children.forEach(descendantQueue::push);
+                        descendants.addAll(children);
+                }
+
+                return descendants;
+        }
+
+        public Set<ClassEntry> getAncestors(ClassEntry classEntry) {
+                Set<ClassEntry> ancestors = Sets.newHashSet();
+
+                LinkedList<ClassEntry> ancestorQueue = new LinkedList<>();
+                ancestorQueue.push(classEntry);
+
+                while (!ancestorQueue.isEmpty()) {
+                        ClassEntry ancestor = ancestorQueue.pop();
+                        Collection<ClassEntry> parents = getParents(ancestor);
+
+                        parents.forEach(ancestorQueue::push);
+                        ancestors.addAll(parents);
+                }
+
+                return ancestors;
+        }
+
+        public Relation computeClassRelation(ClassEntry classEntry, ClassEntry potentialAncestor) {
+                if (potentialAncestor.getName().equals("java/lang/Object")) return Relation.RELATED;
+                if (!entryIndex.hasClass(classEntry)) return Relation.UNKNOWN;
+
+                for (ClassEntry ancestor : getAncestors(classEntry)) {
+                        if (potentialAncestor.equals(ancestor)) {
+                                return Relation.RELATED;
+                        } else if (!entryIndex.hasClass(ancestor)) {
+                                return Relation.UNKNOWN;
+                        }
+                }
+
+                return Relation.UNRELATED;
+        }
+
+        public boolean isParent(ClassEntry classEntry) {
+                return classChildren.containsKey(classEntry);
+        }
+
+        public boolean hasParents(ClassEntry classEntry) {
+                Collection<ClassEntry> parents = classParents.get(classEntry);
+                return parents != null && !parents.isEmpty();
+        }
+
+        public enum Relation {
+                RELATED,
+                UNRELATED,
+                UNKNOWN
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndex.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndex.java
new file mode 100644
index 0000000..de3f5f5
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndex.java
@@ -0,0 +1,170 @@
+/*******************************************************************************
+ * 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.analysis.index;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import cuchaz.enigma.Enigma;
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.ReferenceTargetType;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.IndexEntryResolver;
+import cuchaz.enigma.translation.representation.Lambda;
+import cuchaz.enigma.translation.representation.entry.*;
+import cuchaz.enigma.utils.I18n;
+
+import org.objectweb.asm.ClassReader;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+public class JarIndex implements JarIndexer {
+        private final EntryIndex entryIndex;
+        private final InheritanceIndex inheritanceIndex;
+        private final ReferenceIndex referenceIndex;
+        private final BridgeMethodIndex bridgeMethodIndex;
+        private final PackageVisibilityIndex packageVisibilityIndex;
+        private final EntryResolver entryResolver;
+
+        private final Collection<JarIndexer> indexers;
+
+        private final Multimap<String, MethodDefEntry> methodImplementations = HashMultimap.create();
+
+        public JarIndex(EntryIndex entryIndex, InheritanceIndex inheritanceIndex, ReferenceIndex referenceIndex, BridgeMethodIndex bridgeMethodIndex, PackageVisibilityIndex packageVisibilityIndex) {
+                this.entryIndex = entryIndex;
+                this.inheritanceIndex = inheritanceIndex;
+                this.referenceIndex = referenceIndex;
+                this.bridgeMethodIndex = bridgeMethodIndex;
+                this.packageVisibilityIndex = packageVisibilityIndex;
+                this.indexers = Arrays.asList(entryIndex, inheritanceIndex, referenceIndex, bridgeMethodIndex, packageVisibilityIndex);
+                this.entryResolver = new IndexEntryResolver(this);
+        }
+
+        public static JarIndex empty() {
+                EntryIndex entryIndex = new EntryIndex();
+                InheritanceIndex inheritanceIndex = new InheritanceIndex(entryIndex);
+                ReferenceIndex referenceIndex = new ReferenceIndex();
+                BridgeMethodIndex bridgeMethodIndex = new BridgeMethodIndex(entryIndex, inheritanceIndex, referenceIndex);
+                PackageVisibilityIndex packageVisibilityIndex = new PackageVisibilityIndex();
+                return new JarIndex(entryIndex, inheritanceIndex, referenceIndex, bridgeMethodIndex, packageVisibilityIndex);
+        }
+
+        public void indexJar(ClassCache classCache, ProgressListener progress) {
+                progress.init(4, I18n.translate("progress.jar.indexing"));
+
+                progress.step(1, I18n.translate("progress.jar.indexing.entries"));
+                classCache.visit(() -> new IndexClassVisitor(this, Enigma.ASM_VERSION), ClassReader.SKIP_CODE);
+
+                progress.step(2, I18n.translate("progress.jar.indexing.references"));
+                classCache.visit(() -> new IndexReferenceVisitor(this, entryIndex, inheritanceIndex, Enigma.ASM_VERSION), 0);
+
+                progress.step(3, I18n.translate("progress.jar.indexing.methods"));
+                bridgeMethodIndex.findBridgeMethods();
+
+                progress.step(4, I18n.translate("progress.jar.indexing.process"));
+                processIndex(this);
+        }
+
+        @Override
+        public void processIndex(JarIndex index) {
+                indexers.forEach(indexer -> indexer.processIndex(index));
+        }
+
+        @Override
+        public void indexClass(ClassDefEntry classEntry) {
+                if (classEntry.isJre()) {
+                        return;
+                }
+
+                for (ClassEntry interfaceEntry : classEntry.getInterfaces()) {
+                        if (classEntry.equals(interfaceEntry)) {
+                                throw new IllegalArgumentException("Class cannot be its own interface! " + classEntry);
+                        }
+                }
+
+                indexers.forEach(indexer -> indexer.indexClass(classEntry));
+        }
+
+        @Override
+        public void indexField(FieldDefEntry fieldEntry) {
+                if (fieldEntry.getParent().isJre()) {
+                        return;
+                }
+
+                indexers.forEach(indexer -> indexer.indexField(fieldEntry));
+        }
+
+        @Override
+        public void indexMethod(MethodDefEntry methodEntry) {
+                if (methodEntry.getParent().isJre()) {
+                        return;
+                }
+
+                indexers.forEach(indexer -> indexer.indexMethod(methodEntry));
+
+                if (!methodEntry.isConstructor()) {
+                        methodImplementations.put(methodEntry.getParent().getFullName(), methodEntry);
+                }
+        }
+
+        @Override
+        public void indexMethodReference(MethodDefEntry callerEntry, MethodEntry referencedEntry, ReferenceTargetType targetType) {
+                if (callerEntry.getParent().isJre()) {
+                        return;
+                }
+
+                indexers.forEach(indexer -> indexer.indexMethodReference(callerEntry, referencedEntry, targetType));
+        }
+
+        @Override
+        public void indexFieldReference(MethodDefEntry callerEntry, FieldEntry referencedEntry, ReferenceTargetType targetType) {
+                if (callerEntry.getParent().isJre()) {
+                        return;
+                }
+
+                indexers.forEach(indexer -> indexer.indexFieldReference(callerEntry, referencedEntry, targetType));
+        }
+
+        @Override
+        public void indexLambda(MethodDefEntry callerEntry, Lambda lambda, ReferenceTargetType targetType) {
+                if (callerEntry.getParent().isJre()) {
+                        return;
+                }
+
+                indexers.forEach(indexer -> indexer.indexLambda(callerEntry, lambda, targetType));
+        }
+
+        public EntryIndex getEntryIndex() {
+                return entryIndex;
+        }
+
+        public InheritanceIndex getInheritanceIndex() {
+                return this.inheritanceIndex;
+        }
+
+        public ReferenceIndex getReferenceIndex() {
+                return referenceIndex;
+        }
+
+        public BridgeMethodIndex getBridgeMethodIndex() {
+                return bridgeMethodIndex;
+        }
+
+        public PackageVisibilityIndex getPackageVisibilityIndex() {
+                return packageVisibilityIndex;
+        }
+
+        public EntryResolver getEntryResolver() {
+                return entryResolver;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndexer.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndexer.java
new file mode 100644
index 0000000..f17e7c9
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndexer.java
@@ -0,0 +1,28 @@
+package cuchaz.enigma.analysis.index;
+
+import cuchaz.enigma.analysis.ReferenceTargetType;
+import cuchaz.enigma.translation.representation.Lambda;
+import cuchaz.enigma.translation.representation.entry.*;
+
+public interface JarIndexer {
+        default void indexClass(ClassDefEntry classEntry) {
+        }
+
+        default void indexField(FieldDefEntry fieldEntry) {
+        }
+
+        default void indexMethod(MethodDefEntry methodEntry) {
+        }
+
+        default void indexMethodReference(MethodDefEntry callerEntry, MethodEntry referencedEntry, ReferenceTargetType targetType) {
+        }
+
+        default void indexFieldReference(MethodDefEntry callerEntry, FieldEntry referencedEntry, ReferenceTargetType targetType) {
+        }
+
+        default void indexLambda(MethodDefEntry callerEntry, Lambda lambda, ReferenceTargetType targetType) {
+        }
+
+        default void processIndex(JarIndex index) {
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/PackageVisibilityIndex.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/PackageVisibilityIndex.java
new file mode 100644
index 0000000..64de5f3
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/PackageVisibilityIndex.java
@@ -0,0 +1,147 @@
+package cuchaz.enigma.analysis.index;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.ReferenceTargetType;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.entry.*;
+
+import java.util.*;
+
+public class PackageVisibilityIndex implements JarIndexer {
+        private static boolean requiresSamePackage(AccessFlags entryAcc, EntryReference ref, InheritanceIndex inheritanceIndex) {
+                if (entryAcc.isPublic()) {
+                        return false;
+                }
+
+                if (entryAcc.isProtected()) {
+                        ClassEntry contextClass = ref.context.getContainingClass();
+                        ClassEntry referencedClass = ref.entry.getContainingClass();
+
+                        if (!inheritanceIndex.getAncestors(contextClass).contains(referencedClass)) {
+                                return true; // access to protected member not in superclass
+                        }
+
+                        if (ref.targetType.getKind() == ReferenceTargetType.Kind.NONE) {
+                                return false; // access to superclass or static superclass member
+                        }
+
+                        // access to instance member only valid if target's class assignable to context class
+                        return !(ref.targetType.getKind() == ReferenceTargetType.Kind.UNINITIALIZED ||
+                                        ((ReferenceTargetType.ClassType) ref.targetType).getEntry().equals(contextClass) ||
+                                        inheritanceIndex.getAncestors(((ReferenceTargetType.ClassType) ref.targetType).getEntry()).contains(contextClass));
+                }
+
+                return true;
+        }
+
+        private final HashMultimap<ClassEntry, ClassEntry> connections = HashMultimap.create();
+        private final List<Set<ClassEntry>> partitions = Lists.newArrayList();
+        private final Map<ClassEntry, Set<ClassEntry>> classPartitions = Maps.newHashMap();
+
+        private void addConnection(ClassEntry classA, ClassEntry classB) {
+                if (classA != classB) {
+                        connections.put(classA, classB);
+                        connections.put(classB, classA);
+                }
+        }
+
+        private void buildPartition(Set<ClassEntry> unassignedClasses, Set<ClassEntry> partition, ClassEntry member) {
+                for (ClassEntry connected : connections.get(member)) {
+                        if (unassignedClasses.remove(connected)) {
+                                partition.add(connected);
+                                buildPartition(unassignedClasses, partition, connected);
+                        }
+                }
+        }
+
+        private void addConnections(EntryIndex entryIndex, ReferenceIndex referenceIndex, InheritanceIndex inheritanceIndex) {
+                for (FieldEntry entry : entryIndex.getFields()) {
+                        AccessFlags entryAcc = entryIndex.getFieldAccess(entry);
+                        if (!entryAcc.isPublic() && !entryAcc.isPrivate()) {
+                                for (EntryReference<FieldEntry, MethodDefEntry> ref : referenceIndex.getReferencesToField(entry)) {
+                                        if (requiresSamePackage(entryAcc, ref, inheritanceIndex)) {
+                                                addConnection(ref.entry.getContainingClass(), ref.context.getContainingClass());
+                                        }
+                                }
+                        }
+                }
+
+                for (MethodEntry entry : entryIndex.getMethods()) {
+                        AccessFlags entryAcc = entryIndex.getMethodAccess(entry);
+                        if (!entryAcc.isPublic() && !entryAcc.isPrivate()) {
+                                for (EntryReference<MethodEntry, MethodDefEntry> ref : referenceIndex.getReferencesToMethod(entry)) {
+                                        if (requiresSamePackage(entryAcc, ref, inheritanceIndex)) {
+                                                addConnection(ref.entry.getContainingClass(), ref.context.getContainingClass());
+                                        }
+                                }
+                        }
+                }
+
+                for (ClassEntry entry : entryIndex.getClasses()) {
+                        AccessFlags entryAcc = entryIndex.getClassAccess(entry);
+                        if (!entryAcc.isPublic() && !entryAcc.isPrivate()) {
+                                for (EntryReference<ClassEntry, FieldDefEntry> ref : referenceIndex.getFieldTypeReferencesToClass(entry)) {
+                                        if (requiresSamePackage(entryAcc, ref, inheritanceIndex)) {
+                                                addConnection(ref.entry.getContainingClass(), ref.context.getContainingClass());
+                                        }
+                                }
+
+                                for (EntryReference<ClassEntry, MethodDefEntry> ref : referenceIndex.getMethodTypeReferencesToClass(entry)) {
+                                        if (requiresSamePackage(entryAcc, ref, inheritanceIndex)) {
+                                                addConnection(ref.entry.getContainingClass(), ref.context.getContainingClass());
+                                        }
+                                }
+                        }
+
+                        for (ClassEntry parent : inheritanceIndex.getParents(entry)) {
+                                AccessFlags parentAcc = entryIndex.getClassAccess(parent);
+                                if (parentAcc != null && !parentAcc.isPublic() && !parentAcc.isPrivate()) {
+                                        addConnection(entry, parent);
+                                }
+                        }
+
+                        ClassEntry outerClass = entry.getOuterClass();
+                        if (outerClass != null) {
+                                addConnection(entry, outerClass);
+                        }
+                }
+        }
+
+        private void addPartitions(EntryIndex entryIndex) {
+                Set<ClassEntry> unassignedClasses = Sets.newHashSet(entryIndex.getClasses());
+                while (!unassignedClasses.isEmpty()) {
+                        Iterator<ClassEntry> iterator = unassignedClasses.iterator();
+                        ClassEntry initialEntry = iterator.next();
+                        iterator.remove();
+
+                        HashSet<ClassEntry> partition = Sets.newHashSet();
+                        partition.add(initialEntry);
+                        buildPartition(unassignedClasses, partition, initialEntry);
+                        partitions.add(partition);
+                        for (ClassEntry entry : partition) {
+                                classPartitions.put(entry, partition);
+                        }
+                }
+        }
+
+        public Collection<Set<ClassEntry>> getPartitions() {
+                return partitions;
+        }
+
+        public Set<ClassEntry> getPartition(ClassEntry classEntry) {
+                return classPartitions.get(classEntry);
+        }
+
+        @Override
+        public void processIndex(JarIndex index) {
+                EntryIndex entryIndex = index.getEntryIndex();
+                ReferenceIndex referenceIndex = index.getReferenceIndex();
+                InheritanceIndex inheritanceIndex = index.getInheritanceIndex();
+                addConnections(entryIndex, referenceIndex, inheritanceIndex);
+                addPartitions(entryIndex);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/ReferenceIndex.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/ReferenceIndex.java
new file mode 100644
index 0000000..b6797c2
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/ReferenceIndex.java
@@ -0,0 +1,148 @@
+package cuchaz.enigma.analysis.index;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.ReferenceTargetType;
+import cuchaz.enigma.translation.mapping.ResolutionStrategy;
+import cuchaz.enigma.translation.representation.Lambda;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.*;
+
+import java.util.Collection;
+import java.util.Map;
+
+public class ReferenceIndex implements JarIndexer {
+        private Multimap<MethodEntry, MethodEntry> methodReferences = HashMultimap.create();
+
+        private Multimap<MethodEntry, EntryReference<MethodEntry, MethodDefEntry>> referencesToMethods = HashMultimap.create();
+        private Multimap<ClassEntry, EntryReference<ClassEntry, MethodDefEntry>> referencesToClasses = HashMultimap.create();
+        private Multimap<FieldEntry, EntryReference<FieldEntry, MethodDefEntry>> referencesToFields = HashMultimap.create();
+        private Multimap<ClassEntry, EntryReference<ClassEntry, FieldDefEntry>> fieldTypeReferences = HashMultimap.create();
+        private Multimap<ClassEntry, EntryReference<ClassEntry, MethodDefEntry>> methodTypeReferences = HashMultimap.create();
+
+        @Override
+        public void indexMethod(MethodDefEntry methodEntry) {
+            indexMethodDescriptor(methodEntry, methodEntry.getDesc());
+        }
+
+        private void indexMethodDescriptor(MethodDefEntry entry, MethodDescriptor descriptor) {
+                for (TypeDescriptor typeDescriptor : descriptor.getArgumentDescs()) {
+                        indexMethodTypeDescriptor(entry, typeDescriptor);
+                }
+                indexMethodTypeDescriptor(entry, descriptor.getReturnDesc());
+        }
+
+        private void indexMethodTypeDescriptor(MethodDefEntry method, TypeDescriptor typeDescriptor) {
+                if (typeDescriptor.isType()) {
+                        ClassEntry referencedClass = typeDescriptor.getTypeEntry();
+                        methodTypeReferences.put(referencedClass, new EntryReference<>(referencedClass, referencedClass.getName(), method));
+                } else if (typeDescriptor.isArray()) {
+                        indexMethodTypeDescriptor(method, typeDescriptor.getArrayType());
+                }
+        }
+
+        @Override
+        public void indexField(FieldDefEntry fieldEntry) {
+            indexFieldTypeDescriptor(fieldEntry, fieldEntry.getDesc());
+        }
+
+        private void indexFieldTypeDescriptor(FieldDefEntry field, TypeDescriptor typeDescriptor) {
+                if (typeDescriptor.isType()) {
+                        ClassEntry referencedClass = typeDescriptor.getTypeEntry();
+                        fieldTypeReferences.put(referencedClass, new EntryReference<>(referencedClass, referencedClass.getName(), field));
+                } else if (typeDescriptor.isArray()) {
+                    indexFieldTypeDescriptor(field, typeDescriptor.getArrayType());
+                }
+        }
+
+        @Override
+        public void indexMethodReference(MethodDefEntry callerEntry, MethodEntry referencedEntry, ReferenceTargetType targetType) {
+                referencesToMethods.put(referencedEntry, new EntryReference<>(referencedEntry, referencedEntry.getName(), callerEntry, targetType));
+                methodReferences.put(callerEntry, referencedEntry);
+
+                if (referencedEntry.isConstructor()) {
+                        ClassEntry referencedClass = referencedEntry.getParent();
+                        referencesToClasses.put(referencedClass, new EntryReference<>(referencedClass, referencedEntry.getName(), callerEntry, targetType));
+                }
+        }
+
+        @Override
+        public void indexFieldReference(MethodDefEntry callerEntry, FieldEntry referencedEntry, ReferenceTargetType targetType) {
+                referencesToFields.put(referencedEntry, new EntryReference<>(referencedEntry, referencedEntry.getName(), callerEntry, targetType));
+        }
+
+        @Override
+        public void indexLambda(MethodDefEntry callerEntry, Lambda lambda, ReferenceTargetType targetType) {
+                if (lambda.getImplMethod() instanceof MethodEntry) {
+                        indexMethodReference(callerEntry, (MethodEntry) lambda.getImplMethod(), targetType);
+                } else {
+                        indexFieldReference(callerEntry, (FieldEntry) lambda.getImplMethod(), targetType);
+                }
+
+                indexMethodDescriptor(callerEntry, lambda.getInvokedType());
+                indexMethodDescriptor(callerEntry, lambda.getSamMethodType());
+                indexMethodDescriptor(callerEntry, lambda.getInstantiatedMethodType());
+        }
+
+        @Override
+        public void processIndex(JarIndex index) {
+                methodReferences = remapReferences(index, methodReferences);
+                referencesToMethods = remapReferencesTo(index, referencesToMethods);
+                referencesToClasses = remapReferencesTo(index, referencesToClasses);
+                referencesToFields = remapReferencesTo(index, referencesToFields);
+                fieldTypeReferences = remapReferencesTo(index, fieldTypeReferences);
+                methodTypeReferences = remapReferencesTo(index, methodTypeReferences);
+        }
+
+        private <K extends Entry<?>, V extends Entry<?>> Multimap<K, V> remapReferences(JarIndex index, Multimap<K, V> multimap) {
+                final int keySetSize = multimap.keySet().size();
+                Multimap<K, V> resolved = HashMultimap.create(multimap.keySet().size(), keySetSize == 0 ? 0 : multimap.size() / keySetSize);
+                for (Map.Entry<K, V> entry : multimap.entries()) {
+                        resolved.put(remap(index, entry.getKey()), remap(index, entry.getValue()));
+                }
+                return resolved;
+        }
+
+        private <E extends Entry<?>, C extends Entry<?>> Multimap<E, EntryReference<E, C>> remapReferencesTo(JarIndex index, Multimap<E, EntryReference<E, C>> multimap) {
+                final int keySetSize = multimap.keySet().size();
+                Multimap<E, EntryReference<E, C>> resolved = HashMultimap.create(keySetSize, keySetSize == 0 ? 0 : multimap.size() / keySetSize);
+                for (Map.Entry<E, EntryReference<E, C>> entry : multimap.entries()) {
+                        resolved.put(remap(index, entry.getKey()), remap(index, entry.getValue()));
+                }
+                return resolved;
+        }
+
+        private <E extends Entry<?>> E remap(JarIndex index, E entry) {
+                return index.getEntryResolver().resolveFirstEntry(entry, ResolutionStrategy.RESOLVE_CLOSEST);
+        }
+
+        private <E extends Entry<?>, C extends Entry<?>> EntryReference<E, C> remap(JarIndex index, EntryReference<E, C> reference) {
+                return index.getEntryResolver().resolveFirstReference(reference, ResolutionStrategy.RESOLVE_CLOSEST);
+        }
+
+        public Collection<MethodEntry> getMethodsReferencedBy(MethodEntry entry) {
+                return methodReferences.get(entry);
+        }
+
+        public Collection<EntryReference<FieldEntry, MethodDefEntry>> getReferencesToField(FieldEntry entry) {
+                return referencesToFields.get(entry);
+        }
+
+        public Collection<EntryReference<ClassEntry, MethodDefEntry>> getReferencesToClass(ClassEntry entry) {
+                return referencesToClasses.get(entry);
+        }
+
+        public Collection<EntryReference<MethodEntry, MethodDefEntry>> getReferencesToMethod(MethodEntry entry) {
+                return referencesToMethods.get(entry);
+        }
+
+        public Collection<EntryReference<ClassEntry, FieldDefEntry>> getFieldTypeReferencesToClass(ClassEntry entry) {
+                return fieldTypeReferences.get(entry);
+        }
+
+        public Collection<EntryReference<ClassEntry, MethodDefEntry>> getMethodTypeReferencesToClass(ClassEntry entry) {
+                return methodTypeReferences.get(entry);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/EnigmaPlugin.java b/enigma/src/main/java/cuchaz/enigma/api/EnigmaPlugin.java
new file mode 100644
index 0000000..bdd6015
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/EnigmaPlugin.java
@@ -0,0 +1,5 @@
+package cuchaz.enigma.api;
+
+public interface EnigmaPlugin {
+        void init(EnigmaPluginContext ctx);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/EnigmaPluginContext.java b/enigma/src/main/java/cuchaz/enigma/api/EnigmaPluginContext.java
new file mode 100644
index 0000000..a59051a
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/EnigmaPluginContext.java
@@ -0,0 +1,9 @@
+package cuchaz.enigma.api;
+
+import cuchaz.enigma.api.service.EnigmaService;
+import cuchaz.enigma.api.service.EnigmaServiceFactory;
+import cuchaz.enigma.api.service.EnigmaServiceType;
+
+public interface EnigmaPluginContext {
+        <T extends EnigmaService> void registerService(String id, EnigmaServiceType<T> serviceType, EnigmaServiceFactory<T> factory);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaService.java b/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaService.java
new file mode 100644
index 0000000..526dda7
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaService.java
@@ -0,0 +1,4 @@
+package cuchaz.enigma.api.service;
+
+public interface EnigmaService {
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceContext.java b/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceContext.java
new file mode 100644
index 0000000..9e433fb
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceContext.java
@@ -0,0 +1,11 @@
+package cuchaz.enigma.api.service;
+
+import java.util.Optional;
+
+public interface EnigmaServiceContext<T extends EnigmaService> {
+        static <T extends EnigmaService> EnigmaServiceContext<T> empty() {
+                return key -> Optional.empty();
+        }
+
+        Optional<String> getArgument(String key);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceFactory.java b/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceFactory.java
new file mode 100644
index 0000000..7c10ac2
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceFactory.java
@@ -0,0 +1,5 @@
+package cuchaz.enigma.api.service;
+
+public interface EnigmaServiceFactory<T extends EnigmaService> {
+        T create(EnigmaServiceContext<T> ctx);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceType.java b/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceType.java
new file mode 100644
index 0000000..358828f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/service/EnigmaServiceType.java
@@ -0,0 +1,29 @@
+package cuchaz.enigma.api.service;
+
+public final class EnigmaServiceType<T extends EnigmaService> {
+        public final String key;
+
+        private EnigmaServiceType(String key) {
+                this.key = key;
+        }
+
+        public static <T extends EnigmaService> EnigmaServiceType<T> create(String key) {
+                return new EnigmaServiceType<>(key);
+        }
+
+        @Override
+        public int hashCode() {
+                return key.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) return true;
+
+                if (obj instanceof EnigmaServiceType) {
+                        return ((EnigmaServiceType) obj).key.equals(key);
+                }
+
+                return false;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/service/JarIndexerService.java b/enigma/src/main/java/cuchaz/enigma/api/service/JarIndexerService.java
new file mode 100644
index 0000000..0cda199
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/service/JarIndexerService.java
@@ -0,0 +1,10 @@
+package cuchaz.enigma.api.service;
+
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.index.JarIndex;
+
+public interface JarIndexerService extends EnigmaService {
+        EnigmaServiceType<JarIndexerService> TYPE = EnigmaServiceType.create("jar_indexer");
+
+        void acceptJar(ClassCache classCache, JarIndex jarIndex);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/service/NameProposalService.java b/enigma/src/main/java/cuchaz/enigma/api/service/NameProposalService.java
new file mode 100644
index 0000000..4c357db
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/service/NameProposalService.java
@@ -0,0 +1,12 @@
+package cuchaz.enigma.api.service;
+
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.util.Optional;
+
+public interface NameProposalService extends EnigmaService {
+        EnigmaServiceType<NameProposalService> TYPE = EnigmaServiceType.create("name_proposal");
+
+        Optional<String> proposeName(Entry<?> obfEntry, EntryRemapper remapper);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/api/service/ObfuscationTestService.java b/enigma/src/main/java/cuchaz/enigma/api/service/ObfuscationTestService.java
new file mode 100644
index 0000000..af0cf30
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/api/service/ObfuscationTestService.java
@@ -0,0 +1,9 @@
+package cuchaz.enigma.api.service;
+
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+public interface ObfuscationTestService extends EnigmaService {
+        EnigmaServiceType<ObfuscationTestService> TYPE = EnigmaServiceType.create("obfuscation_test");
+
+        boolean testDeobfuscated(Entry<?> entry);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/AsmObjectTranslator.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/AsmObjectTranslator.java
new file mode 100644
index 0000000..1a2b47f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/AsmObjectTranslator.java
@@ -0,0 +1,46 @@
+package cuchaz.enigma.bytecode.translators;
+
+import cuchaz.enigma.translation.Translator;
+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.MethodEntry;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Type;
+
+public class AsmObjectTranslator {
+        public static Type translateType(Translator translator, Type type) {
+                String descString = type.getDescriptor();
+                switch (type.getSort()) {
+                        case Type.OBJECT: {
+                                ClassEntry classEntry = new ClassEntry(type.getInternalName());
+                                return Type.getObjectType(translator.translate(classEntry).getFullName());
+                        }
+                        case Type.ARRAY: {
+                                TypeDescriptor descriptor = new TypeDescriptor(descString);
+                                return Type.getType(translator.translate(descriptor).toString());
+                        }
+                        case Type.METHOD: {
+                                MethodDescriptor descriptor = new MethodDescriptor(descString);
+                                return Type.getMethodType(translator.translate(descriptor).toString());
+                        }
+                }
+                return type;
+        }
+
+        public static Handle translateHandle(Translator translator, Handle handle) {
+                MethodEntry entry = new MethodEntry(new ClassEntry(handle.getOwner()), handle.getName(), new MethodDescriptor(handle.getDesc()));
+                MethodEntry translatedMethod = translator.translate(entry);
+                ClassEntry ownerClass = translatedMethod.getParent();
+                return new Handle(handle.getTag(), ownerClass.getFullName(), translatedMethod.getName(), translatedMethod.getDesc().toString(), handle.isInterface());
+        }
+
+        public static Object translateValue(Translator translator, Object value) {
+                if (value instanceof Type) {
+                        return translateType(translator, (Type) value);
+                } else if (value instanceof Handle) {
+                        return translateHandle(translator, (Handle) value);
+                }
+                return value;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/LocalVariableFixVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/LocalVariableFixVisitor.java
new file mode 100644
index 0000000..cfd8fbe
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/LocalVariableFixVisitor.java
@@ -0,0 +1,126 @@
+package cuchaz.enigma.bytecode.translators;
+
+import com.google.common.base.CharMatcher;
+import cuchaz.enigma.translation.LocalNameGenerator;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LocalVariableFixVisitor extends ClassVisitor {
+        private ClassDefEntry ownerEntry;
+
+        public LocalVariableFixVisitor(int api, ClassVisitor visitor) {
+                super(api, visitor);
+        }
+
+        @Override
+        public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+                ownerEntry = ClassDefEntry.parse(access, name, signature, superName, interfaces);
+                super.visit(version, access, name, signature, superName, interfaces);
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+                MethodDefEntry methodEntry = MethodDefEntry.parse(ownerEntry, access, name, descriptor, signature);
+                return new Method(api, methodEntry, super.visitMethod(access, name, descriptor, signature, exceptions));
+        }
+
+        private class Method extends MethodVisitor {
+                private final MethodDefEntry methodEntry;
+                private final Map<Integer, String> parameterNames = new HashMap<>();
+                private final Map<Integer, Integer> parameterIndices = new HashMap<>();
+                private boolean hasParameterTable;
+                private int parameterIndex = 0;
+
+                Method(int api, MethodDefEntry methodEntry, MethodVisitor visitor) {
+                        super(api, visitor);
+                        this.methodEntry = methodEntry;
+
+                        int lvIndex = methodEntry.getAccess().isStatic() ? 0 : 1;
+                        List<TypeDescriptor> parameters = methodEntry.getDesc().getArgumentDescs();
+                        for (int parameterIndex = 0; parameterIndex < parameters.size(); parameterIndex++) {
+                                TypeDescriptor param = parameters.get(parameterIndex);
+                                parameterIndices.put(lvIndex, parameterIndex);
+                                lvIndex += param.getSize();
+                        }
+                }
+
+                @Override
+                public void visitParameter(String name, int access) {
+                        hasParameterTable = true;
+                        super.visitParameter(fixParameterName(parameterIndex, name), fixParameterAccess(parameterIndex, access));
+                        parameterIndex++;
+                }
+
+                @Override
+                public void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index) {
+                        if (index == 0 && !methodEntry.getAccess().isStatic()) {
+                                name = "this";
+                        } else if (parameterIndices.containsKey(index)) {
+                                name = fixParameterName(parameterIndices.get(index), name);
+                        } else if (isInvalidName(name)) {
+                                name = LocalNameGenerator.generateLocalVariableName(index, new TypeDescriptor(desc));
+                        }
+
+                        super.visitLocalVariable(name, desc, signature, start, end, index);
+                }
+
+                private boolean isInvalidName(String name) {
+                        return name == null || name.isEmpty() || !CharMatcher.ascii().matchesAllOf(name);
+                }
+
+                @Override
+                public void visitEnd() {
+                        if (!hasParameterTable) {
+                                List<TypeDescriptor> arguments = methodEntry.getDesc().getArgumentDescs();
+                                for (int argumentIndex = 0; argumentIndex < arguments.size(); argumentIndex++) {
+                                        super.visitParameter(fixParameterName(argumentIndex, null), fixParameterAccess(argumentIndex, 0));
+                                }
+                        }
+
+                        super.visitEnd();
+                }
+
+                private String fixParameterName(int index, String name) {
+                        if (parameterNames.get(index) != null) {
+                                return parameterNames.get(index); // to make sure that LVT names are consistent with parameter table names
+                        }
+
+                        if (isInvalidName(name)) {
+                                List<TypeDescriptor> arguments = methodEntry.getDesc().getArgumentDescs();
+                                name = LocalNameGenerator.generateArgumentName(index, arguments.get(index), arguments);
+                        }
+
+                        if (index == 0 && ownerEntry.getAccess().isEnum() && methodEntry.getName().equals("<init>")) {
+                                name = "name";
+                        }
+
+                        if (index == 1 && ownerEntry.getAccess().isEnum() && methodEntry.getName().equals("<init>")) {
+                                name = "ordinal";
+                        }
+
+                        parameterNames.put(index, name);
+                        return name;
+                }
+
+                private int fixParameterAccess(int index, int access) {
+                        if (index == 0 && ownerEntry.getAccess().isEnum() && methodEntry.getName().equals("<init>")) {
+                                access |= Opcodes.ACC_SYNTHETIC;
+                        }
+
+                        if (index == 1 && ownerEntry.getAccess().isEnum() && methodEntry.getName().equals("<init>")) {
+                                access |= Opcodes.ACC_SYNTHETIC;
+                        }
+
+                        return access;
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/SourceFixVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/SourceFixVisitor.java
new file mode 100644
index 0000000..2b750ea
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/SourceFixVisitor.java
@@ -0,0 +1,39 @@
+package cuchaz.enigma.bytecode.translators;
+
+import cuchaz.enigma.analysis.index.BridgeMethodIndex;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public class SourceFixVisitor extends ClassVisitor {
+        private final JarIndex index;
+        private ClassDefEntry ownerEntry;
+
+        public SourceFixVisitor(int api, ClassVisitor visitor, JarIndex index) {
+                super(api, visitor);
+                this.index = index;
+        }
+
+        @Override
+        public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+                ownerEntry = ClassDefEntry.parse(access, name, signature, superName, interfaces);
+                super.visit(version, access, name, signature, superName, interfaces);
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+                MethodDefEntry methodEntry = MethodDefEntry.parse(ownerEntry, access, name, descriptor, signature);
+
+                BridgeMethodIndex bridgeIndex = index.getBridgeMethodIndex();
+                if (bridgeIndex.isBridgeMethod(methodEntry)) {
+                        access |= Opcodes.ACC_BRIDGE;
+                } else if (bridgeIndex.isSpecializedMethod(methodEntry)) {
+                        name = bridgeIndex.getBridgeFromSpecialized(methodEntry).getName();
+                }
+
+                return super.visitMethod(access, name, descriptor, signature, exceptions);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationAnnotationVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationAnnotationVisitor.java
new file mode 100644
index 0000000..cb843ad
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationAnnotationVisitor.java
@@ -0,0 +1,51 @@
+package cuchaz.enigma.bytecode.translators;
+
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import org.objectweb.asm.AnnotationVisitor;
+
+public class TranslationAnnotationVisitor extends AnnotationVisitor {
+        private final Translator translator;
+        private final ClassEntry annotationEntry;
+
+        public TranslationAnnotationVisitor(Translator translator, ClassEntry annotationEntry, int api, AnnotationVisitor av) {
+                super(api, av);
+                this.translator = translator;
+                this.annotationEntry = annotationEntry;
+        }
+
+        @Override
+        public void visit(String name, Object value) {
+                super.visit(name, AsmObjectTranslator.translateValue(translator, value));
+        }
+
+        @Override
+        public AnnotationVisitor visitArray(String name) {
+                return new TranslationAnnotationVisitor(translator, annotationEntry, api, super.visitArray(name));
+        }
+
+        @Override
+        public AnnotationVisitor visitAnnotation(String name, String desc) {
+                TypeDescriptor type = new TypeDescriptor(desc);
+                if (name != null) {
+                        FieldEntry annotationField = translator.translate(new FieldEntry(annotationEntry, name, type));
+                        return super.visitAnnotation(annotationField.getName(), annotationField.getDesc().toString());
+                } else {
+                        return super.visitAnnotation(null, translator.translate(type).toString());
+                }
+        }
+
+        @Override
+        public void visitEnum(String name, String desc, String value) {
+                TypeDescriptor type = new TypeDescriptor(desc);
+                FieldEntry enumField = translator.translate(new FieldEntry(type.getTypeEntry(), value, type));
+                if (name != null) {
+                        FieldEntry annotationField = translator.translate(new FieldEntry(annotationEntry, name, type));
+                        super.visitEnum(annotationField.getName(), annotationField.getDesc().toString(), enumField.getName());
+                } else {
+                        super.visitEnum(null, translator.translate(type).toString(), enumField.getName());
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java
new file mode 100644
index 0000000..e4c41d3
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java
@@ -0,0 +1,102 @@
+/*******************************************************************************
+ * 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.bytecode.translators;
+
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.*;
+import org.objectweb.asm.*;
+
+import java.util.Arrays;
+
+public class TranslationClassVisitor extends ClassVisitor {
+        private final Translator translator;
+
+        private ClassDefEntry obfClassEntry;
+
+        public TranslationClassVisitor(Translator translator, int api, ClassVisitor cv) {
+                super(api, cv);
+                this.translator = translator;
+        }
+
+        @Override
+        public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+                obfClassEntry = ClassDefEntry.parse(access, name, signature, superName, interfaces);
+
+                ClassDefEntry translatedEntry = translator.translate(obfClassEntry);
+                String translatedSuper = translatedEntry.getSuperClass() != null ? translatedEntry.getSuperClass().getFullName() : null;
+                String[] translatedInterfaces = Arrays.stream(translatedEntry.getInterfaces()).map(ClassEntry::getFullName).toArray(String[]::new);
+
+                super.visit(version, translatedEntry.getAccess().getFlags(), translatedEntry.getFullName(), translatedEntry.getSignature().toString(), translatedSuper, translatedInterfaces);
+        }
+
+        @Override
+        public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
+                FieldDefEntry entry = FieldDefEntry.parse(obfClassEntry, access, name, desc, signature);
+                FieldDefEntry translatedEntry = translator.translate(entry);
+                FieldVisitor fv = super.visitField(translatedEntry.getAccess().getFlags(), translatedEntry.getName(), translatedEntry.getDesc().toString(), translatedEntry.getSignature().toString(), value);
+                return new TranslationFieldVisitor(translator, translatedEntry, api, fv);
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+                MethodDefEntry entry = MethodDefEntry.parse(obfClassEntry, access, name, desc, signature);
+                MethodDefEntry translatedEntry = translator.translate(entry);
+                String[] translatedExceptions = new String[exceptions.length];
+                for (int i = 0; i < exceptions.length; i++) {
+                        translatedExceptions[i] = translator.translate(new ClassEntry(exceptions[i])).getFullName();
+                }
+                MethodVisitor mv = super.visitMethod(translatedEntry.getAccess().getFlags(), translatedEntry.getName(), translatedEntry.getDesc().toString(), translatedEntry.getSignature().toString(), translatedExceptions);
+                return new TranslationMethodVisitor(translator, obfClassEntry, entry, api, mv);
+        }
+
+        @Override
+        public void visitInnerClass(String name, String outerName, String innerName, int access) {
+                ClassDefEntry classEntry = ClassDefEntry.parse(access, name, obfClassEntry.getSignature().toString(), null, new String[0]);
+                ClassDefEntry translatedEntry = translator.translate(classEntry);
+                ClassEntry translatedOuterClass = translatedEntry.getOuterClass();
+                if (translatedOuterClass == null) {
+                        throw new IllegalStateException("Translated inner class did not have outer class");
+                }
+
+                // Anonymous classes do not specify an outer or inner name. As we do not translate from the given parameter, ignore if the input is null
+                String translatedName = translatedEntry.getFullName();
+                String translatedOuterName = outerName != null ? translatedOuterClass.getFullName() : null;
+                String translatedInnerName = innerName != null ? translatedEntry.getName() : null;
+                super.visitInnerClass(translatedName, translatedOuterName, translatedInnerName, translatedEntry.getAccess().getFlags());
+        }
+
+        @Override
+        public void visitOuterClass(String owner, String name, String desc) {
+                if (desc != null) {
+                        MethodEntry translatedEntry = translator.translate(new MethodEntry(new ClassEntry(owner), name, new MethodDescriptor(desc)));
+                        super.visitOuterClass(translatedEntry.getParent().getFullName(), translatedEntry.getName(), translatedEntry.getDesc().toString());
+                } else {
+                        super.visitOuterClass(owner, name, desc);
+                }
+        }
+
+        @Override
+        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+                TypeDescriptor translatedDesc = translator.translate(new TypeDescriptor(desc));
+                AnnotationVisitor av = super.visitAnnotation(translatedDesc.toString(), visible);
+                return new TranslationAnnotationVisitor(translator, translatedDesc.getTypeEntry(), api, av);
+        }
+
+        @Override
+        public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) {
+                TypeDescriptor translatedDesc = translator.translate(new TypeDescriptor(desc));
+                AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, translatedDesc.toString(), visible);
+                return new TranslationAnnotationVisitor(translator, translatedDesc.getTypeEntry(), api, av);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationFieldVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationFieldVisitor.java
new file mode 100644
index 0000000..28fc199
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationFieldVisitor.java
@@ -0,0 +1,33 @@
+package cuchaz.enigma.bytecode.translators;
+
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.FieldDefEntry;
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.TypePath;
+
+public class TranslationFieldVisitor extends FieldVisitor {
+        private final FieldDefEntry fieldEntry;
+        private final Translator translator;
+
+        public TranslationFieldVisitor(Translator translator, FieldDefEntry fieldEntry, int api, FieldVisitor fv) {
+                super(api, fv);
+                this.translator = translator;
+                this.fieldEntry = fieldEntry;
+        }
+
+        @Override
+        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+                TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc));
+                AnnotationVisitor av = super.visitAnnotation(typeDesc.toString(), visible);
+                return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av);
+        }
+
+        @Override
+        public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) {
+                TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc));
+                AnnotationVisitor av = super.visitAnnotation(typeDesc.toString(), visible);
+                return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationMethodVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationMethodVisitor.java
new file mode 100644
index 0000000..a82df1b
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationMethodVisitor.java
@@ -0,0 +1,145 @@
+package cuchaz.enigma.bytecode.translators;
+
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.Signature;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.*;
+import org.objectweb.asm.*;
+
+public class TranslationMethodVisitor extends MethodVisitor {
+        private final MethodDefEntry methodEntry;
+        private final Translator translator;
+
+        private int parameterIndex = 0;
+        private int parameterLvIndex;
+
+        public TranslationMethodVisitor(Translator translator, ClassDefEntry ownerEntry, MethodDefEntry methodEntry, int api, MethodVisitor mv) {
+                super(api, mv);
+                this.translator = translator;
+                this.methodEntry = methodEntry;
+
+                parameterLvIndex = methodEntry.getAccess().isStatic() ? 0 : 1;
+        }
+
+        @Override
+        public void visitParameter(String name, int access) {
+                name = translateVariableName(parameterLvIndex, name);
+                parameterLvIndex += methodEntry.getDesc().getArgumentDescs().get(parameterIndex++).getSize();
+
+                super.visitParameter(name, access);
+        }
+
+        @Override
+        public void visitFieldInsn(int opcode, String owner, String name, String desc) {
+                FieldEntry entry = new FieldEntry(new ClassEntry(owner), name, new TypeDescriptor(desc));
+                FieldEntry translatedEntry = translator.translate(entry);
+                super.visitFieldInsn(opcode, translatedEntry.getParent().getFullName(), translatedEntry.getName(), translatedEntry.getDesc().toString());
+        }
+
+        @Override
+        public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+                MethodEntry entry = new MethodEntry(new ClassEntry(owner), name, new MethodDescriptor(desc));
+                MethodEntry translatedEntry = translator.translate(entry);
+                super.visitMethodInsn(opcode, translatedEntry.getParent().getFullName(), translatedEntry.getName(), translatedEntry.getDesc().toString(), itf);
+        }
+
+        @Override
+        public void visitFrame(int type, int localCount, Object[] locals, int stackCount, Object[] stack) {
+                Object[] translatedLocals = this.getTranslatedFrame(locals, localCount);
+                Object[] translatedStack = this.getTranslatedFrame(stack, stackCount);
+                super.visitFrame(type, localCount, translatedLocals, stackCount, translatedStack);
+        }
+
+        private Object[] getTranslatedFrame(Object[] array, int count) {
+                if (array == null) {
+                        return null;
+                }
+                for (int i = 0; i < count; i++) {
+                        Object object = array[i];
+                        if (object instanceof String) {
+                                String type = (String) object;
+                                array[i] = translator.translate(new ClassEntry(type)).getFullName();
+                        }
+                }
+                return array;
+        }
+
+        @Override
+        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+                TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc));
+                AnnotationVisitor av = super.visitAnnotation(typeDesc.toString(), visible);
+                return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av);
+        }
+
+        @Override
+        public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) {
+                TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc));
+                AnnotationVisitor av = super.visitParameterAnnotation(parameter, typeDesc.toString(), visible);
+                return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av);
+        }
+
+        @Override
+        public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) {
+                TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc));
+                AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, typeDesc.toString(), visible);
+                return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av);
+        }
+
+        @Override
+        public void visitTypeInsn(int opcode, String type) {
+                ClassEntry translatedEntry = translator.translate(new ClassEntry(type));
+                super.visitTypeInsn(opcode, translatedEntry.getFullName());
+        }
+
+        @Override
+        public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) {
+                MethodDescriptor translatedMethodDesc = translator.translate(new MethodDescriptor(desc));
+                Object[] translatedBsmArgs = new Object[bsmArgs.length];
+                for (int i = 0; i < bsmArgs.length; i++) {
+                        translatedBsmArgs[i] = AsmObjectTranslator.translateValue(translator, bsmArgs[i]);
+                }
+                super.visitInvokeDynamicInsn(name, translatedMethodDesc.toString(), AsmObjectTranslator.translateHandle(translator, bsm), translatedBsmArgs);
+        }
+
+        @Override
+        public void visitLdcInsn(Object cst) {
+                super.visitLdcInsn(AsmObjectTranslator.translateValue(translator, cst));
+        }
+
+        @Override
+        public void visitMultiANewArrayInsn(String desc, int dims) {
+                super.visitMultiANewArrayInsn(translator.translate(new TypeDescriptor(desc)).toString(), dims);
+        }
+
+        @Override
+        public void visitTryCatchBlock(Label start, Label end, Label handler, String type) {
+                if (type != null) {
+                        ClassEntry translatedEntry = translator.translate(new ClassEntry(type));
+                        super.visitTryCatchBlock(start, end, handler, translatedEntry.getFullName());
+                } else {
+                        super.visitTryCatchBlock(start, end, handler, type);
+                }
+        }
+
+        @Override
+        public void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index) {
+                signature = translator.translate(Signature.createTypedSignature(signature)).toString();
+                name = translateVariableName(index, name);
+                desc = translator.translate(new TypeDescriptor(desc)).toString();
+
+                super.visitLocalVariable(name, desc, signature, start, end, index);
+        }
+
+        private String translateVariableName(int index, String name) {
+                LocalVariableEntry entry = new LocalVariableEntry(methodEntry, index, "", true,null);
+                LocalVariableEntry translatedEntry = translator.translate(entry);
+                String translatedName = translatedEntry.getName();
+
+                if (!translatedName.isEmpty()) {
+                        return translatedName;
+                }
+
+                return name;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationSignatureVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationSignatureVisitor.java
new file mode 100644
index 0000000..bc4a2f0
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationSignatureVisitor.java
@@ -0,0 +1,129 @@
+package cuchaz.enigma.bytecode.translators;
+
+import cuchaz.enigma.Enigma;
+import org.objectweb.asm.signature.SignatureVisitor;
+
+import java.util.Stack;
+import java.util.function.Function;
+
+public class TranslationSignatureVisitor extends SignatureVisitor {
+        private final Function<String, String> remapper;
+
+        private final SignatureVisitor sv;
+        private final Stack<String> classStack = new Stack<>();
+
+        public TranslationSignatureVisitor(Function<String, String> remapper, SignatureVisitor sv) {
+                super(Enigma.ASM_VERSION);
+                this.remapper = remapper;
+                this.sv = sv;
+        }
+
+        @Override
+        public void visitClassType(String name) {
+                classStack.push(name);
+                String translatedEntry = this.remapper.apply(name);
+                this.sv.visitClassType(translatedEntry);
+        }
+
+        @Override
+        public void visitInnerClassType(String name) {
+                String lastClass = classStack.pop();
+                if (!name.startsWith(lastClass+"$")){//todo see if there's a way to base this on whether there were type params or not
+                        name = lastClass+"$"+name;
+                }
+                String translatedEntry = this.remapper.apply(name);
+                if (translatedEntry.contains("/")){
+                        translatedEntry = translatedEntry.substring(translatedEntry.lastIndexOf("/")+1);
+                }
+                if (translatedEntry.contains("$")){
+                        translatedEntry = translatedEntry.substring(translatedEntry.lastIndexOf("$")+1);
+                }
+                this.sv.visitInnerClassType(translatedEntry);
+        }
+
+        @Override
+        public void visitFormalTypeParameter(String name) {
+                this.sv.visitFormalTypeParameter(name);
+        }
+
+        @Override
+        public void visitTypeVariable(String name) {
+                this.sv.visitTypeVariable(name);
+        }
+
+        @Override
+        public SignatureVisitor visitArrayType() {
+                this.sv.visitArrayType();
+                return this;
+        }
+
+        @Override
+        public void visitBaseType(char descriptor) {
+                this.sv.visitBaseType(descriptor);
+        }
+
+        @Override
+        public SignatureVisitor visitClassBound() {
+                this.sv.visitClassBound();
+                return this;
+        }
+
+        @Override
+        public SignatureVisitor visitExceptionType() {
+                this.sv.visitExceptionType();
+                return this;
+        }
+
+        @Override
+        public SignatureVisitor visitInterface() {
+                this.sv.visitInterface();
+                return this;
+        }
+
+        @Override
+        public SignatureVisitor visitInterfaceBound() {
+                this.sv.visitInterfaceBound();
+                return this;
+        }
+
+        @Override
+        public SignatureVisitor visitParameterType() {
+                this.sv.visitParameterType();
+                return this;
+        }
+
+        @Override
+        public SignatureVisitor visitReturnType() {
+                this.sv.visitReturnType();
+                return this;
+        }
+
+        @Override
+        public SignatureVisitor visitSuperclass() {
+                this.sv.visitSuperclass();
+                return this;
+        }
+
+        @Override
+        public void visitTypeArgument() {
+                this.sv.visitTypeArgument();
+        }
+
+        @Override
+        public SignatureVisitor visitTypeArgument(char wildcard) {
+                this.sv.visitTypeArgument(wildcard);
+                return this;
+        }
+
+        @Override
+        public void visitEnd() {
+                this.sv.visitEnd();
+                if (!classStack.empty())
+                        classStack.pop();
+        }
+
+        @Override
+        public String toString() {
+                return this.sv.toString();
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/Decompiler.java b/enigma/src/main/java/cuchaz/enigma/source/Decompiler.java
new file mode 100644
index 0000000..c9666d5
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/Decompiler.java
@@ -0,0 +1,5 @@
+package cuchaz.enigma.source;
+
+public interface Decompiler {
+    Source getSource(String className);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/DecompilerService.java b/enigma/src/main/java/cuchaz/enigma/source/DecompilerService.java
new file mode 100644
index 0000000..377ccbc
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/DecompilerService.java
@@ -0,0 +1,11 @@
+package cuchaz.enigma.source;
+
+import cuchaz.enigma.ClassProvider;
+import cuchaz.enigma.api.service.EnigmaService;
+import cuchaz.enigma.api.service.EnigmaServiceType;
+
+public interface DecompilerService extends EnigmaService {
+    EnigmaServiceType<DecompilerService> TYPE = EnigmaServiceType.create("decompiler");
+
+    Decompiler create(ClassProvider classProvider, SourceSettings settings);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/Decompilers.java b/enigma/src/main/java/cuchaz/enigma/source/Decompilers.java
new file mode 100644
index 0000000..7d154a6
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/Decompilers.java
@@ -0,0 +1,9 @@
+package cuchaz.enigma.source;
+
+import cuchaz.enigma.source.cfr.CfrDecompiler;
+import cuchaz.enigma.source.procyon.ProcyonDecompiler;
+
+public class Decompilers {
+    public static final DecompilerService PROCYON = ProcyonDecompiler::new;
+    public static final DecompilerService CFR = CfrDecompiler::new;
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/Source.java b/enigma/src/main/java/cuchaz/enigma/source/Source.java
new file mode 100644
index 0000000..43c4de0
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/Source.java
@@ -0,0 +1,11 @@
+package cuchaz.enigma.source;
+
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+
+public interface Source {
+    String asString();
+
+    Source addJavadocs(EntryRemapper remapper);
+
+    SourceIndex index();
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/SourceIndex.java b/enigma/src/main/java/cuchaz/enigma/source/SourceIndex.java
new file mode 100644
index 0000000..178ce20
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/SourceIndex.java
@@ -0,0 +1,172 @@
+package cuchaz.enigma.source;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.ResolutionStrategy;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+
+public class SourceIndex {
+    private String source;
+    private List<Integer> lineOffsets;
+    private final TreeMap<Token, EntryReference<Entry<?>, Entry<?>>> tokenToReference;
+    private final Multimap<EntryReference<Entry<?>, Entry<?>>, Token> referenceToTokens;
+    private final Map<Entry<?>, Token> declarationToToken;
+
+    public SourceIndex() {
+        tokenToReference = new TreeMap<>();
+        referenceToTokens = HashMultimap.create();
+        declarationToToken = Maps.newHashMap();
+    }
+
+    public SourceIndex(String source) {
+        this();
+        setSource(source);
+    }
+
+    public void setSource(String source) {
+        this.source = source;
+        lineOffsets = Lists.newArrayList();
+        lineOffsets.add(0);
+
+        for (int i = 0; i < this.source.length(); i++) {
+            if (this.source.charAt(i) == '\n') {
+                lineOffsets.add(i + 1);
+            }
+        }
+    }
+
+    public String getSource() {
+        return source;
+    }
+
+    public int getLineNumber(int position) {
+        int line = 0;
+
+        for (int offset : lineOffsets) {
+            if (offset > position) {
+                break;
+            }
+
+            line++;
+        }
+
+        return line;
+    }
+
+    public int getColumnNumber(int position) {
+        return position - lineOffsets.get(getLineNumber(position) - 1) + 1;
+    }
+
+    public int getPosition(int line, int column) {
+        return lineOffsets.get(line - 1) + column - 1;
+    }
+
+    public Iterable<Entry<?>> declarations() {
+        return declarationToToken.keySet();
+    }
+
+    public Iterable<Token> declarationTokens() {
+        return declarationToToken.values();
+    }
+
+    public Token getDeclarationToken(Entry<?> entry) {
+        return declarationToToken.get(entry);
+    }
+
+    public void addDeclaration(Token token, Entry<?> deobfEntry) {
+        if (token != null) {
+            EntryReference<Entry<?>, Entry<?>> reference = new EntryReference<>(deobfEntry, token.text);
+            tokenToReference.put(token, reference);
+            referenceToTokens.put(reference, token);
+            declarationToToken.put(deobfEntry, token);
+        }
+    }
+
+    public Iterable<EntryReference<Entry<?>, Entry<?>>> references() {
+        return referenceToTokens.keySet();
+    }
+
+    public EntryReference<Entry<?>, Entry<?>> getReference(Token token) {
+        if (token == null) {
+            return null;
+        }
+
+        return tokenToReference.get(token);
+    }
+
+    public Iterable<Token> referenceTokens() {
+        return tokenToReference.keySet();
+    }
+
+    public Token getReferenceToken(int pos) {
+        Token token = tokenToReference.floorKey(new Token(pos, pos, null));
+
+        if (token != null && token.contains(pos)) {
+            return token;
+        }
+
+        return null;
+    }
+
+    public Collection<Token> getReferenceTokens(EntryReference<Entry<?>, Entry<?>> deobfReference) {
+        return referenceToTokens.get(deobfReference);
+    }
+
+    public void addReference(Token token, Entry<?> deobfEntry, Entry<?> deobfContext) {
+        if (token != null) {
+            EntryReference<Entry<?>, Entry<?>> deobfReference = new EntryReference<>(deobfEntry, token.text, deobfContext);
+            tokenToReference.put(token, deobfReference);
+            referenceToTokens.put(deobfReference, token);
+        }
+    }
+
+    public void resolveReferences(EntryResolver resolver) {
+        // resolve all the classes in the source references
+        for (Token token : Lists.newArrayList(referenceToTokens.values())) {
+            EntryReference<Entry<?>, Entry<?>> reference = tokenToReference.get(token);
+            EntryReference<Entry<?>, Entry<?>> resolvedReference = resolver.resolveFirstReference(reference, ResolutionStrategy.RESOLVE_CLOSEST);
+
+            // replace the reference
+            tokenToReference.replace(token, resolvedReference);
+
+            Collection<Token> tokens = referenceToTokens.removeAll(reference);
+            referenceToTokens.putAll(resolvedReference, tokens);
+        }
+    }
+
+    public SourceIndex remapTo(SourceRemapper.Result result) {
+        SourceIndex remapped = new SourceIndex(result.getSource());
+
+        for (Map.Entry<Entry<?>, Token> entry : declarationToToken.entrySet()) {
+            remapped.declarationToToken.put(entry.getKey(), result.getRemappedToken(entry.getValue()));
+        }
+
+        for (Map.Entry<EntryReference<Entry<?>, Entry<?>>, Collection<Token>> entry : referenceToTokens.asMap().entrySet()) {
+            EntryReference<Entry<?>, Entry<?>> reference = entry.getKey();
+            Collection<Token> oldTokens = entry.getValue();
+
+            Collection<Token> newTokens = oldTokens
+                    .stream()
+                    .map(result::getRemappedToken)
+                    .collect(Collectors.toList());
+
+            remapped.referenceToTokens.putAll(reference, newTokens);
+        }
+
+        for (Map.Entry<Token, EntryReference<Entry<?>, Entry<?>>> entry : tokenToReference.entrySet()) {
+            remapped.tokenToReference.put(result.getRemappedToken(entry.getKey()), entry.getValue());
+        }
+
+        return remapped;
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/SourceRemapper.java b/enigma/src/main/java/cuchaz/enigma/source/SourceRemapper.java
new file mode 100644
index 0000000..b5f8006
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/SourceRemapper.java
@@ -0,0 +1,62 @@
+package cuchaz.enigma.source;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SourceRemapper {
+        private final String source;
+        private final Iterable<Token> tokens;
+
+        public SourceRemapper(String source, Iterable<Token> tokens) {
+                this.source = source;
+                this.tokens = tokens;
+        }
+
+        public Result remap(Remapper remapper) {
+                StringBuffer remappedSource = new StringBuffer(source);
+                Map<Token, Token> remappedTokens = new HashMap<>();
+
+                int accumulatedOffset = 0;
+                for (Token token : tokens) {
+                        Token movedToken = token.move(accumulatedOffset);
+
+                        String remappedName = remapper.remap(token, movedToken);
+                        if (remappedName != null) {
+                                accumulatedOffset += movedToken.getRenameOffset(remappedName);
+                                movedToken.rename(remappedSource, remappedName);
+                        }
+
+                        if (!token.equals(movedToken)) {
+                                remappedTokens.put(token, movedToken);
+                        }
+                }
+
+                return new Result(remappedSource.toString(), remappedTokens);
+        }
+
+        public static class Result {
+                private final String remappedSource;
+                private final Map<Token, Token> remappedTokens;
+
+                Result(String remappedSource, Map<Token, Token> remappedTokens) {
+                        this.remappedSource = remappedSource;
+                        this.remappedTokens = remappedTokens;
+                }
+
+                public String getSource() {
+                        return remappedSource;
+                }
+
+                public Token getRemappedToken(Token token) {
+                        return remappedTokens.getOrDefault(token, token);
+                }
+
+                public boolean isEmpty() {
+                        return remappedTokens.isEmpty();
+                }
+        }
+
+        public interface Remapper {
+                String remap(Token token, Token movedToken);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/SourceSettings.java b/enigma/src/main/java/cuchaz/enigma/source/SourceSettings.java
new file mode 100644
index 0000000..f6c68e9
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/SourceSettings.java
@@ -0,0 +1,11 @@
+package cuchaz.enigma.source;
+
+public class SourceSettings {
+    public final boolean removeImports;
+    public final boolean removeVariableFinal;
+
+    public SourceSettings(boolean removeImports, boolean removeVariableFinal) {
+        this.removeImports = removeImports;
+        this.removeVariableFinal = removeVariableFinal;
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/Token.java b/enigma/src/main/java/cuchaz/enigma/source/Token.java
new file mode 100644
index 0000000..fad733f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/Token.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * 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.source;
+
+public class Token implements Comparable<Token> {
+
+        public int start;
+        public int end;
+        public String text;
+
+        public Token(int start, int end, String text) {
+                this.start = start;
+                this.end = end;
+                this.text = text;
+        }
+
+        public int getRenameOffset(String to) {
+                int length = this.end - this.start;
+                return to.length() - length;
+        }
+
+        public void rename(StringBuffer source, String to) {
+                int oldEnd = this.end;
+                this.text = to;
+                this.end = this.start + to.length();
+
+                source.replace(start, oldEnd, to);
+        }
+
+        public Token move(int offset) {
+                Token token = new Token(this.start + offset, this.end + offset, null);
+                token.text = text;
+                return token;
+        }
+
+        public boolean contains(int pos) {
+                return pos >= start && pos <= end;
+        }
+
+        @Override
+        public int compareTo(Token other) {
+                return start - other.start;
+        }
+
+        @Override
+        public boolean equals(Object other) {
+                return other instanceof Token && equals((Token) other);
+        }
+
+        @Override
+        public int hashCode() {
+                return start * 37 + end;
+        }
+
+        public boolean equals(Token other) {
+                return start == other.start && end == other.end && text.equals(other.text);
+        }
+
+        @Override
+        public String toString() {
+                return String.format("[%d,%d]", start, end);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/cfr/CfrDecompiler.java b/enigma/src/main/java/cuchaz/enigma/source/cfr/CfrDecompiler.java
new file mode 100644
index 0000000..9e37f16
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/cfr/CfrDecompiler.java
@@ -0,0 +1,108 @@
+package cuchaz.enigma.source.cfr;
+
+import com.google.common.io.ByteStreams;
+import cuchaz.enigma.ClassProvider;
+import cuchaz.enigma.source.Decompiler;
+import cuchaz.enigma.source.Source;
+import cuchaz.enigma.source.SourceSettings;
+import org.benf.cfr.reader.apiunreleased.ClassFileSource2;
+import org.benf.cfr.reader.apiunreleased.JarContent;
+import org.benf.cfr.reader.bytecode.analysis.parse.utils.Pair;
+import org.benf.cfr.reader.entities.ClassFile;
+import org.benf.cfr.reader.mapping.MappingFactory;
+import org.benf.cfr.reader.mapping.ObfuscationMapping;
+import org.benf.cfr.reader.relationship.MemberNameResolver;
+import org.benf.cfr.reader.state.DCCommonState;
+import org.benf.cfr.reader.state.TypeUsageCollectingDumper;
+import org.benf.cfr.reader.util.AnalysisType;
+import org.benf.cfr.reader.util.CannotLoadClassException;
+import org.benf.cfr.reader.util.collections.ListFactory;
+import org.benf.cfr.reader.util.getopt.Options;
+import org.benf.cfr.reader.util.getopt.OptionsImpl;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class CfrDecompiler implements Decompiler {
+    private final DCCommonState state;
+
+    public CfrDecompiler(ClassProvider classProvider, SourceSettings sourceSettings) {
+        Map<String, String> options = new HashMap<>();
+
+        state = new DCCommonState(OptionsImpl.getFactory().create(options), new ClassFileSource2() {
+            @Override
+            public JarContent addJarContent(String s, AnalysisType analysisType) {
+                return null;
+            }
+
+            @Override
+            public void informAnalysisRelativePathDetail(String usePath, String classFilePath) {
+
+            }
+
+            @Override
+            public Collection<String> addJar(String jarPath) {
+                return null;
+            }
+
+            @Override
+            public String getPossiblyRenamedPath(String path) {
+                return path;
+            }
+
+            @Override
+            public Pair<byte[], String> getClassFileContent(String path) {
+                ClassNode node = classProvider.getClassNode(path.substring(0, path.lastIndexOf('.')));
+
+                if (node == null) {
+                    try (InputStream classResource = CfrDecompiler.class.getClassLoader().getResourceAsStream(path)) {
+                        if (classResource != null) {
+                            return new Pair<>(ByteStreams.toByteArray(classResource), path);
+                        }
+                    } catch (IOException ignored) {}
+
+                    return null;
+                }
+
+                ClassWriter cw = new ClassWriter(0);
+                node.accept(cw);
+                return new Pair<>(cw.toByteArray(), path);
+            }
+        });
+    }
+
+    @Override
+    public Source getSource(String className) {
+        DCCommonState state = this.state;
+        Options options = state.getOptions();
+
+        ObfuscationMapping mapping = MappingFactory.get(options, state);
+        state = new DCCommonState(state, mapping);
+        ClassFile tree = state.getClassFileMaybePath(className);
+
+        state.configureWith(tree);
+
+        // To make sure we're analysing the cached version
+        try {
+            tree = state.getClassFile(tree.getClassType());
+        } catch (CannotLoadClassException ignored) {}
+
+        if (options.getOption(OptionsImpl.DECOMPILE_INNER_CLASSES)) {
+            tree.loadInnerClasses(state);
+        }
+
+        if (options.getOption(OptionsImpl.RENAME_DUP_MEMBERS)) {
+            MemberNameResolver.resolveNames(state, ListFactory.newList(state.getClassCache().getLoadedTypes()));
+        }
+
+        TypeUsageCollectingDumper typeUsageCollector = new TypeUsageCollectingDumper(options, tree);
+        tree.analyseTop(state, typeUsageCollector);
+        return new CfrSource(tree, state, typeUsageCollector.getRealTypeUsageInformation());
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/cfr/CfrSource.java b/enigma/src/main/java/cuchaz/enigma/source/cfr/CfrSource.java
new file mode 100644
index 0000000..d4f2da6
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/cfr/CfrSource.java
@@ -0,0 +1,38 @@
+package cuchaz.enigma.source.cfr;
+
+import cuchaz.enigma.source.Source;
+import cuchaz.enigma.source.SourceIndex;
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+import org.benf.cfr.reader.entities.ClassFile;
+import org.benf.cfr.reader.state.DCCommonState;
+import org.benf.cfr.reader.state.TypeUsageInformation;
+
+public class CfrSource implements Source {
+    private final ClassFile tree;
+    private final SourceIndex index;
+    private final String string;
+
+    public CfrSource(ClassFile tree, DCCommonState state, TypeUsageInformation typeUsages) {
+        this.tree = tree;
+
+        EnigmaDumper dumper = new EnigmaDumper(typeUsages);
+        tree.dump(state.getObfuscationMapping().wrap(dumper));
+        index = dumper.getIndex();
+        string = dumper.getString();
+    }
+
+    @Override
+    public String asString() {
+        return string;
+    }
+
+    @Override
+    public Source addJavadocs(EntryRemapper remapper) {
+        return this; // TODO
+    }
+
+    @Override
+    public SourceIndex index() {
+        return index;
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/cfr/EnigmaDumper.java b/enigma/src/main/java/cuchaz/enigma/source/cfr/EnigmaDumper.java
new file mode 100644
index 0000000..e05a6ff
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/cfr/EnigmaDumper.java
@@ -0,0 +1,433 @@
+package cuchaz.enigma.source.cfr;
+
+import cuchaz.enigma.source.Token;
+import cuchaz.enigma.source.SourceIndex;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.*;
+import org.benf.cfr.reader.bytecode.analysis.types.*;
+import org.benf.cfr.reader.bytecode.analysis.variables.NamedVariable;
+import org.benf.cfr.reader.entities.Field;
+import org.benf.cfr.reader.entities.Method;
+import org.benf.cfr.reader.mapping.NullMapping;
+import org.benf.cfr.reader.mapping.ObfuscationMapping;
+import org.benf.cfr.reader.state.TypeUsageInformation;
+import org.benf.cfr.reader.util.collections.SetFactory;
+import org.benf.cfr.reader.util.output.DelegatingDumper;
+import org.benf.cfr.reader.util.output.Dumpable;
+import org.benf.cfr.reader.util.output.Dumper;
+import org.benf.cfr.reader.util.output.TypeContext;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class EnigmaDumper implements Dumper {
+    private int outputCount = 0;
+    private int indent;
+    private boolean atStart = true;
+    private boolean pendingCR = false;
+    private final StringBuilder sb = new StringBuilder();
+    private final TypeUsageInformation typeUsageInformation;
+    private final Set<JavaTypeInstance> emitted = SetFactory.newSet();
+    private final SourceIndex index = new SourceIndex();
+    private int position;
+
+
+    public EnigmaDumper(TypeUsageInformation typeUsageInformation) {
+        this.typeUsageInformation = typeUsageInformation;
+    }
+
+    private void append(String s) {
+        sb.append(s);
+        position += s.length();
+    }
+
+    private String getDesc(JavaTypeInstance type) {
+        if (!type.isUsableType() && type != RawJavaType.VOID) {
+            throw new IllegalArgumentException(type.toString());
+        }
+
+        if (type instanceof JavaGenericBaseInstance) {
+            return getDesc(type.getDeGenerifiedType());
+        }
+
+        if (type instanceof JavaRefTypeInstance) {
+            return "L" + type.getRawName().replace('.', '/') + ";";
+        }
+
+        if (type instanceof JavaArrayTypeInstance) {
+            return "[" + getDesc(((JavaArrayTypeInstance) type).removeAnArrayIndirection());
+        }
+
+        if (type instanceof RawJavaType) {
+            switch ((RawJavaType) type) {
+                case BOOLEAN:
+                    return "Z";
+                case BYTE:
+                    return "B";
+                case CHAR:
+                    return "C";
+                case SHORT:
+                    return "S";
+                case INT:
+                    return "I";
+                case LONG:
+                    return "J";
+                case FLOAT:
+                    return "F";
+                case DOUBLE:
+                    return "D";
+                case VOID:
+                    return "V";
+                default:
+                    throw new AssertionError();
+            }
+        }
+
+        throw new AssertionError();
+    }
+
+    private MethodEntry getMethodEntry(MethodPrototype method) {
+        if (method == null || method.getClassType() == null) {
+            return null;
+        }
+
+        MethodDescriptor desc = new MethodDescriptor(
+                method.getArgs().stream().map(type -> new TypeDescriptor(getDesc(type))).collect(Collectors.toList()),
+                new TypeDescriptor(method.getName().equals("<init>") || method.getName().equals("<clinit>") ? "V" : getDesc(method.getReturnType()))
+        );
+
+        return new MethodEntry(getClassEntry(method.getClassType()), method.getName(), desc);
+    }
+
+    private LocalVariableEntry getParameterEntry(MethodPrototype method, int parameterIndex, String name) {
+        int variableIndex = method.isInstanceMethod() ? 1 : 0;
+        for (int i = 0; i < parameterIndex; i++) {
+            variableIndex += method.getArgs().get(i).getStackType().getComputationCategory();
+        }
+
+        return new LocalVariableEntry(getMethodEntry(method), variableIndex, name, true, null);
+    }
+
+    private FieldEntry getFieldEntry(JavaTypeInstance owner, String name, JavaTypeInstance type) {
+        return new FieldEntry(getClassEntry(owner), name, new TypeDescriptor(getDesc(type)));
+    }
+
+    private ClassEntry getClassEntry(JavaTypeInstance type) {
+        return new ClassEntry(type.getRawName().replace('.', '/'));
+    }
+
+    @Override
+    public Dumper beginBlockComment(boolean inline) {
+        print("/*").newln();
+        return this;
+    }
+
+    @Override
+    public Dumper endBlockComment() {
+        print(" */").newln();
+        return this;
+    }
+
+    @Override
+    public Dumper label(String s, boolean inline) {
+        processPendingCR();
+        append(s);
+        append(":");
+        return this;
+    }
+
+    @Override
+    public Dumper comment(String s) {
+        append("// ");
+        append(s);
+        append("\n");
+        return this;
+    }
+
+    @Override
+    public void enqueuePendingCarriageReturn() {
+        pendingCR = true;
+    }
+
+    @Override
+    public Dumper removePendingCarriageReturn() {
+        pendingCR = false;
+        return this;
+    }
+
+    private void processPendingCR() {
+        if (pendingCR) {
+            append("\n");
+            atStart = true;
+            pendingCR = false;
+        }
+    }
+
+    @Override
+    public Dumper identifier(String s, Object ref, boolean defines) {
+        return print(s);
+    }
+
+    @Override
+    public Dumper methodName(String name, MethodPrototype method, boolean special, boolean defines) {
+        doIndent();
+        Token token = new Token(position, position + name.length(), name);
+        Entry<?> entry = getMethodEntry(method);
+
+        if (entry != null) {
+            if (defines) {
+                index.addDeclaration(token, entry);
+            } else {
+                index.addReference(token, entry, null);
+            }
+        }
+
+        return identifier(name, null, defines);
+    }
+
+    @Override
+    public Dumper parameterName(String name, MethodPrototype method, int index, boolean defines) {
+        doIndent();
+        Token token = new Token(position, position + name.length(), name);
+        Entry<?> entry = getParameterEntry(method, index, name);
+
+        if (entry != null) {
+            if (defines) {
+                this.index.addDeclaration(token, entry);
+            } else {
+                this.index.addReference(token, entry, null);
+            }
+        }
+
+        return identifier(name, null, defines);
+    }
+
+    @Override
+    public Dumper variableName(String name, NamedVariable variable, boolean defines) {
+        return identifier(name, null, defines);
+    }
+
+    @Override
+    public Dumper packageName(JavaRefTypeInstance t) {
+        String s = t.getPackageName();
+
+        if (!s.isEmpty()) {
+            keyword("package ").print(s).endCodeln().newln();
+        }
+
+        return this;
+    }
+
+    @Override
+    public Dumper fieldName(String name, Field field, JavaTypeInstance owner, boolean hiddenDeclaration, boolean defines) {
+        doIndent();
+        Token token = new Token(position, position + name.length(), name);
+        Entry<?> entry = field == null ? null : getFieldEntry(owner, name, field.getJavaTypeInstance());
+
+        if (entry != null) {
+            if (defines) {
+                index.addDeclaration(token, entry);
+            } else {
+                index.addReference(token, entry, null);
+            }
+        }
+
+        identifier(name, null, defines);
+        return this;
+    }
+
+    @Override
+    public Dumper print(String s) {
+        processPendingCR();
+        doIndent();
+        append(s);
+        atStart = s.endsWith("\n");
+        outputCount++;
+        return this;
+    }
+
+    @Override
+    public Dumper print(char c) {
+        return print(String.valueOf(c));
+    }
+
+    @Override
+    public Dumper newln() {
+        append("\n");
+        atStart = true;
+        outputCount++;
+        return this;
+    }
+
+    @Override
+    public Dumper endCodeln() {
+        append(";\n");
+        atStart = true;
+        outputCount++;
+        return this;
+    }
+
+    @Override
+    public Dumper keyword(String s) {
+        print(s);
+        return this;
+    }
+
+    @Override
+    public Dumper operator(String s) {
+        print(s);
+        return this;
+    }
+
+    @Override
+    public Dumper separator(String s) {
+        print(s);
+        return this;
+    }
+
+    @Override
+    public Dumper literal(String s, Object o) {
+        print(s);
+        return this;
+    }
+
+    private void doIndent() {
+        if (!atStart) return;
+        String indents = "    ";
+
+        for (int x = 0; x < indent; ++x) {
+            append(indents);
+        }
+
+        atStart = false;
+    }
+
+    @Override
+    public void indent(int diff) {
+        indent += diff;
+    }
+
+    @Override
+    public Dumper dump(Dumpable d) {
+        if (d == null) {
+            keyword("null");
+            return this;
+        }
+
+        d.dump(this);
+        return this;
+    }
+
+    @Override
+    public TypeUsageInformation getTypeUsageInformation() {
+        return typeUsageInformation;
+    }
+
+    @Override
+    public ObfuscationMapping getObfuscationMapping() {
+        return NullMapping.INSTANCE;
+    }
+
+    @Override
+    public String toString() {
+        return sb.toString();
+    }
+
+    @Override
+    public void addSummaryError(Method method, String s) {}
+
+    @Override
+    public void close() {
+    }
+
+    @Override
+    public boolean canEmitClass(JavaTypeInstance type) {
+        return emitted.add(type);
+    }
+
+    @Override
+    public int getOutputCount() {
+        return outputCount;
+    }
+
+    @Override
+    public Dumper dump(JavaTypeInstance type) {
+        return dump(type, TypeContext.None, false);
+    }
+
+    @Override
+    public Dumper dump(JavaTypeInstance type, boolean defines) {
+        return dump(type, TypeContext.None, false);
+    }
+
+    @Override
+    public Dumper dump(JavaTypeInstance type, TypeContext context) {
+        return dump(type, context, false);
+    }
+
+    private Dumper dump(JavaTypeInstance type, TypeContext context, boolean defines) {
+        doIndent();
+        if (type instanceof JavaRefTypeInstance) {
+            int start = position;
+            type.dumpInto(this, typeUsageInformation, TypeContext.None);
+            int end = position;
+            Token token = new Token(start, end, sb.toString().substring(start, end));
+
+            if (defines) {
+                index.addDeclaration(token, getClassEntry(type));
+            } else {
+                index.addReference(token, getClassEntry(type), null);
+            }
+
+            return this;
+        }
+
+        type.dumpInto(this, typeUsageInformation, context);
+        return this;
+    }
+
+    @Override
+    public Dumper withTypeUsageInformation(TypeUsageInformation innerclassTypeUsageInformation) {
+        return new WithTypeUsageInformationDumper(this, innerclassTypeUsageInformation);
+    }
+
+    public SourceIndex getIndex() {
+        index.setSource(getString());
+        return index;
+    }
+
+    public String getString() {
+        return sb.toString();
+    }
+
+    public static class WithTypeUsageInformationDumper extends DelegatingDumper {
+        private final TypeUsageInformation typeUsageInformation;
+
+        WithTypeUsageInformationDumper(Dumper delegate, TypeUsageInformation typeUsageInformation) {
+            super(delegate);
+            this.typeUsageInformation = typeUsageInformation;
+        }
+
+        @Override
+        public TypeUsageInformation getTypeUsageInformation() {
+            return typeUsageInformation;
+        }
+
+        @Override
+        public Dumper dump(JavaTypeInstance javaTypeInstance) {
+            return dump(javaTypeInstance, TypeContext.None);
+        }
+
+        @Override
+        public Dumper dump(JavaTypeInstance javaTypeInstance, TypeContext typeContext) {
+            javaTypeInstance.dumpInto(this, typeUsageInformation, typeContext);
+            return this;
+        }
+
+        @Override
+        public Dumper withTypeUsageInformation(TypeUsageInformation innerclassTypeUsageInformation) {
+            return new WithTypeUsageInformationDumper(delegate, innerclassTypeUsageInformation);
+        }
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/EntryParser.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/EntryParser.java
new file mode 100644
index 0000000..2fae61a
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/EntryParser.java
@@ -0,0 +1,49 @@
+package cuchaz.enigma.source.procyon;
+
+import com.strobel.assembler.metadata.FieldDefinition;
+import com.strobel.assembler.metadata.MethodDefinition;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.Signature;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.FieldDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+
+public class EntryParser {
+    public static FieldDefEntry parse(FieldDefinition definition) {
+        ClassEntry owner = parse(definition.getDeclaringType());
+        TypeDescriptor descriptor = new TypeDescriptor(definition.getErasedSignature());
+        Signature signature = Signature.createTypedSignature(definition.getSignature());
+        AccessFlags access = new AccessFlags(definition.getModifiers());
+        return new FieldDefEntry(owner, definition.getName(), descriptor, signature, access, null);
+    }
+
+    public static ClassDefEntry parse(TypeDefinition def) {
+        String name = def.getInternalName();
+        Signature signature = Signature.createSignature(def.getSignature());
+        AccessFlags access = new AccessFlags(def.getModifiers());
+        ClassEntry superClass = def.getBaseType() != null ? parse(def.getBaseType()) : null;
+        ClassEntry[] interfaces = def.getExplicitInterfaces().stream().map(EntryParser::parse).toArray(ClassEntry[]::new);
+        return new ClassDefEntry(name, signature, access, superClass, interfaces);
+    }
+
+    public static ClassEntry parse(TypeReference typeReference) {
+        return new ClassEntry(typeReference.getInternalName());
+    }
+
+    public static MethodDefEntry parse(MethodDefinition definition) {
+        ClassEntry classEntry = parse(definition.getDeclaringType());
+        MethodDescriptor descriptor = new MethodDescriptor(definition.getErasedSignature());
+        Signature signature = Signature.createSignature(definition.getSignature());
+        AccessFlags access = new AccessFlags(definition.getModifiers());
+        return new MethodDefEntry(classEntry, definition.getName(), descriptor, signature, access, null);
+    }
+
+    public static TypeDescriptor parseTypeDescriptor(TypeReference type) {
+        return new TypeDescriptor(type.getErasedSignature());
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/ProcyonDecompiler.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/ProcyonDecompiler.java
new file mode 100644
index 0000000..3cbd680
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/ProcyonDecompiler.java
@@ -0,0 +1,84 @@
+package cuchaz.enigma.source.procyon;
+
+import com.strobel.assembler.metadata.ITypeLoader;
+import com.strobel.assembler.metadata.MetadataSystem;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+import com.strobel.decompiler.DecompilerContext;
+import com.strobel.decompiler.DecompilerSettings;
+import com.strobel.decompiler.languages.java.BraceStyle;
+import com.strobel.decompiler.languages.java.JavaFormattingOptions;
+import com.strobel.decompiler.languages.java.ast.AstBuilder;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+import com.strobel.decompiler.languages.java.ast.InsertParenthesesVisitor;
+import cuchaz.enigma.ClassProvider;
+import cuchaz.enigma.source.Source;
+import cuchaz.enigma.source.Decompiler;
+import cuchaz.enigma.source.SourceSettings;
+import cuchaz.enigma.source.procyon.transformers.*;
+import cuchaz.enigma.source.procyon.typeloader.CompiledSourceTypeLoader;
+import cuchaz.enigma.source.procyon.typeloader.NoRetryMetadataSystem;
+import cuchaz.enigma.source.procyon.typeloader.SynchronizedTypeLoader;
+
+public class ProcyonDecompiler implements Decompiler {
+        private final SourceSettings settings;
+        private final DecompilerSettings decompilerSettings;
+        private final MetadataSystem metadataSystem;
+
+        public ProcyonDecompiler(ClassProvider classProvider, SourceSettings settings) {
+                ITypeLoader typeLoader = new SynchronizedTypeLoader(new CompiledSourceTypeLoader(classProvider));
+
+                metadataSystem = new NoRetryMetadataSystem(typeLoader);
+                metadataSystem.setEagerMethodLoadingEnabled(true);
+
+                decompilerSettings = DecompilerSettings.javaDefaults();
+                decompilerSettings.setMergeVariables(getSystemPropertyAsBoolean("enigma.mergeVariables", true));
+                decompilerSettings.setForceExplicitImports(getSystemPropertyAsBoolean("enigma.forceExplicitImports", true));
+                decompilerSettings.setForceExplicitTypeArguments(getSystemPropertyAsBoolean("enigma.forceExplicitTypeArguments", true));
+                decompilerSettings.setShowDebugLineNumbers(getSystemPropertyAsBoolean("enigma.showDebugLineNumbers", false));
+                decompilerSettings.setShowSyntheticMembers(getSystemPropertyAsBoolean("enigma.showSyntheticMembers", false));
+                decompilerSettings.setTypeLoader(typeLoader);
+
+                JavaFormattingOptions formattingOptions = decompilerSettings.getJavaFormattingOptions();
+                formattingOptions.ClassBraceStyle = BraceStyle.EndOfLine;
+                formattingOptions.InterfaceBraceStyle = BraceStyle.EndOfLine;
+                formattingOptions.EnumBraceStyle = BraceStyle.EndOfLine;
+
+                this.settings = settings;
+        }
+
+        @Override
+        public Source getSource(String className) {
+                TypeReference type = metadataSystem.lookupType(className);
+                if (type == null) {
+                        throw new Error(String.format("Unable to find desc: %s", className));
+                }
+
+                TypeDefinition resolvedType = type.resolve();
+
+                DecompilerContext context = new DecompilerContext();
+                context.setCurrentType(resolvedType);
+                context.setSettings(decompilerSettings);
+
+                AstBuilder builder = new AstBuilder(context);
+                builder.addType(resolvedType);
+                builder.runTransformations(null);
+                CompilationUnit source = builder.getCompilationUnit();
+
+                new ObfuscatedEnumSwitchRewriterTransform(context).run(source);
+                new VarargsFixer(context).run(source);
+                new RemoveObjectCasts(context).run(source);
+                new Java8Generics().run(source);
+                new InvalidIdentifierFix().run(source);
+                if (settings.removeImports) DropImportAstTransform.INSTANCE.run(source);
+                if (settings.removeVariableFinal) DropVarModifiersAstTransform.INSTANCE.run(source);
+                source.acceptVisitor(new InsertParenthesesVisitor(), null);
+
+                return new ProcyonSource(source, decompilerSettings);
+        }
+
+        private static boolean getSystemPropertyAsBoolean(String property, boolean defValue) {
+                String value = System.getProperty(property);
+                return value == null ? defValue : Boolean.parseBoolean(value);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/ProcyonSource.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/ProcyonSource.java
new file mode 100644
index 0000000..53c8c70
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/ProcyonSource.java
@@ -0,0 +1,49 @@
+package cuchaz.enigma.source.procyon;
+
+import com.strobel.decompiler.DecompilerSettings;
+import com.strobel.decompiler.PlainTextOutput;
+import com.strobel.decompiler.languages.java.JavaOutputVisitor;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+import cuchaz.enigma.source.Source;
+import cuchaz.enigma.source.SourceIndex;
+import cuchaz.enigma.source.procyon.index.SourceIndexVisitor;
+import cuchaz.enigma.source.procyon.transformers.AddJavadocsAstTransform;
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+
+import java.io.StringWriter;
+
+public class ProcyonSource implements Source {
+    private final DecompilerSettings settings;
+    private final CompilationUnit tree;
+    private String string;
+
+    public ProcyonSource(CompilationUnit tree, DecompilerSettings settings) {
+        this.settings = settings;
+        this.tree = tree;
+    }
+
+    @Override
+    public SourceIndex index() {
+        SourceIndex index = new SourceIndex(asString());
+        tree.acceptVisitor(new SourceIndexVisitor(), index);
+        return index;
+    }
+
+    @Override
+    public String asString() {
+        if (string == null) {
+            StringWriter writer = new StringWriter();
+            tree.acceptVisitor(new JavaOutputVisitor(new PlainTextOutput(writer), settings), null);
+            string = writer.toString();
+        }
+
+        return string;
+    }
+
+    @Override
+    public Source addJavadocs(EntryRemapper remapper) {
+        CompilationUnit remappedTree = (CompilationUnit) tree.clone();
+        new AddJavadocsAstTransform(remapper).run(remappedTree);
+        return new ProcyonSource(remappedTree, settings);
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexClassVisitor.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexClassVisitor.java
new file mode 100644
index 0000000..f6eeb15
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexClassVisitor.java
@@ -0,0 +1,95 @@
+/*******************************************************************************
+ * 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.source.procyon.index;
+
+import com.strobel.assembler.metadata.FieldDefinition;
+import com.strobel.assembler.metadata.MethodDefinition;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+import com.strobel.decompiler.languages.TextLocation;
+import com.strobel.decompiler.languages.java.ast.*;
+import cuchaz.enigma.source.SourceIndex;
+import cuchaz.enigma.source.procyon.EntryParser;
+import cuchaz.enigma.translation.representation.entry.*;
+
+public class SourceIndexClassVisitor extends SourceIndexVisitor {
+        private ClassDefEntry classEntry;
+
+        public SourceIndexClassVisitor(ClassDefEntry classEntry) {
+                this.classEntry = classEntry;
+        }
+
+        @Override
+        public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) {
+                // is this this class, or a subtype?
+                TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
+                ClassDefEntry classEntry = EntryParser.parse(def);
+                if (!classEntry.equals(this.classEntry)) {
+                        // it's a subtype, recurse
+                        index.addDeclaration(TokenFactory.createToken(index, node.getNameToken()), classEntry);
+                        return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
+                }
+
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitSimpleType(SimpleType node, SourceIndex index) {
+                TypeReference ref = node.getUserData(Keys.TYPE_REFERENCE);
+                if (node.getIdentifierToken().getStartLocation() != TextLocation.EMPTY) {
+                        ClassEntry classEntry = new ClassEntry(ref.getInternalName());
+                        index.addReference(TokenFactory.createToken(index, node.getIdentifierToken()), classEntry, this.classEntry);
+                }
+
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
+                MethodDefinition def = node.getUserData(Keys.METHOD_DEFINITION);
+                MethodDefEntry methodEntry = EntryParser.parse(def);
+                AstNode tokenNode = node.getNameToken();
+                if (methodEntry.isConstructor() && methodEntry.getName().equals("<clinit>")) {
+                        // for static initializers, check elsewhere for the token node
+                        tokenNode = node.getModifiers().firstOrNullObject();
+                }
+                index.addDeclaration(TokenFactory.createToken(index, tokenNode), methodEntry);
+                return node.acceptVisitor(new SourceIndexMethodVisitor(methodEntry), index);
+        }
+
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
+                MethodDefinition def = node.getUserData(Keys.METHOD_DEFINITION);
+                MethodDefEntry methodEntry = EntryParser.parse(def);
+                index.addDeclaration(TokenFactory.createToken(index, node.getNameToken()), methodEntry);
+                return node.acceptVisitor(new SourceIndexMethodVisitor(methodEntry), index);
+        }
+
+        @Override
+        public Void visitFieldDeclaration(FieldDeclaration node, SourceIndex index) {
+                FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
+                FieldDefEntry fieldEntry = EntryParser.parse(def);
+                assert (node.getVariables().size() == 1);
+                VariableInitializer variable = node.getVariables().firstOrNullObject();
+                index.addDeclaration(TokenFactory.createToken(index, variable.getNameToken()), fieldEntry);
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitEnumValueDeclaration(EnumValueDeclaration node, SourceIndex index) {
+                // treat enum declarations as field declarations
+                FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
+                FieldDefEntry fieldEntry = EntryParser.parse(def);
+                index.addDeclaration(TokenFactory.createToken(index, node.getNameToken()), fieldEntry);
+                return visitChildren(node, index);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexMethodVisitor.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexMethodVisitor.java
new file mode 100644
index 0000000..0e8bc51
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexMethodVisitor.java
@@ -0,0 +1,218 @@
+/*******************************************************************************
+ * 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.source.procyon.index;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import com.strobel.assembler.metadata.*;
+import com.strobel.decompiler.ast.Variable;
+import com.strobel.decompiler.languages.TextLocation;
+import com.strobel.decompiler.languages.java.ast.*;
+import cuchaz.enigma.source.SourceIndex;
+import cuchaz.enigma.source.procyon.EntryParser;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.*;
+
+import java.lang.Error;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SourceIndexMethodVisitor extends SourceIndexVisitor {
+        private final MethodDefEntry methodEntry;
+
+        private Multimap<String, Identifier> unmatchedIdentifier = HashMultimap.create();
+        private Map<String, Entry<?>> identifierEntryCache = new HashMap<>();
+
+        public SourceIndexMethodVisitor(MethodDefEntry methodEntry) {
+                this.methodEntry = methodEntry;
+        }
+
+        @Override
+        public Void visitInvocationExpression(InvocationExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+
+                // get the behavior entry
+                ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                MethodEntry methodEntry = null;
+                if (ref instanceof MethodReference) {
+                        methodEntry = new MethodEntry(classEntry, ref.getName(), new MethodDescriptor(ref.getErasedSignature()));
+                }
+                if (methodEntry != null) {
+                        // get the node for the token
+                        AstNode tokenNode = null;
+                        if (node.getTarget() instanceof MemberReferenceExpression) {
+                                tokenNode = ((MemberReferenceExpression) node.getTarget()).getMemberNameToken();
+                        } else if (node.getTarget() instanceof SuperReferenceExpression) {
+                                tokenNode = node.getTarget();
+                        } else if (node.getTarget() instanceof ThisReferenceExpression) {
+                                tokenNode = node.getTarget();
+                        }
+                        if (tokenNode != null) {
+                                index.addReference(TokenFactory.createToken(index, tokenNode), methodEntry, this.methodEntry);
+                        }
+                }
+
+                // Check for identifier
+                node.getArguments().stream().filter(expression -> expression instanceof IdentifierExpression)
+                                .forEach(expression -> this.checkIdentifier((IdentifierExpression) expression, index));
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitMemberReferenceExpression(MemberReferenceExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                if (ref instanceof FieldReference) {
+                        // make sure this is actually a field
+                        String erasedSignature = ref.getErasedSignature();
+                        if (erasedSignature.indexOf('(') >= 0) {
+                                throw new Error("Expected a field here! got " + ref);
+                        }
+
+                        ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new TypeDescriptor(erasedSignature));
+                        index.addReference(TokenFactory.createToken(index, node.getMemberNameToken()), fieldEntry, this.methodEntry);
+                }
+
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitSimpleType(SimpleType node, SourceIndex index) {
+                TypeReference ref = node.getUserData(Keys.TYPE_REFERENCE);
+                if (node.getIdentifierToken().getStartLocation() != TextLocation.EMPTY) {
+                        ClassEntry classEntry = new ClassEntry(ref.getInternalName());
+                        index.addReference(TokenFactory.createToken(index, node.getIdentifierToken()), classEntry, this.methodEntry);
+                }
+
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitParameterDeclaration(ParameterDeclaration node, SourceIndex index) {
+                ParameterDefinition def = node.getUserData(Keys.PARAMETER_DEFINITION);
+                int parameterIndex = def.getSlot();
+
+                if (parameterIndex >= 0) {
+                        MethodDefEntry ownerMethod = methodEntry;
+                        if (def.getMethod() instanceof MethodDefinition) {
+                                ownerMethod = EntryParser.parse((MethodDefinition) def.getMethod());
+                        }
+
+                        TypeDescriptor parameterType = EntryParser.parseTypeDescriptor(def.getParameterType());
+                        LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, parameterIndex, node.getName(), true, parameterType, null);
+                        Identifier identifier = node.getNameToken();
+                        // cache the argument entry and the identifier
+                        identifierEntryCache.put(identifier.getName(), localVariableEntry);
+                        index.addDeclaration(TokenFactory.createToken(index, identifier), localVariableEntry);
+                }
+
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitIdentifierExpression(IdentifierExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                if (ref != null) {
+                        ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new TypeDescriptor(ref.getErasedSignature()));
+                        index.addReference(TokenFactory.createToken(index, node.getIdentifierToken()), fieldEntry, this.methodEntry);
+                } else
+                        this.checkIdentifier(node, index);
+                return visitChildren(node, index);
+        }
+
+        private void checkIdentifier(IdentifierExpression node, SourceIndex index) {
+                if (identifierEntryCache.containsKey(node.getIdentifier())) // If it's in the argument cache, create a token!
+                        index.addDeclaration(TokenFactory.createToken(index, node.getIdentifierToken()), identifierEntryCache.get(node.getIdentifier()));
+                else
+                        unmatchedIdentifier.put(node.getIdentifier(), node.getIdentifierToken()); // Not matched actually, put it!
+        }
+
+        private void addDeclarationToUnmatched(String key, SourceIndex index) {
+                Entry<?> entry = identifierEntryCache.get(key);
+
+                // This cannot happened in theory
+                if (entry == null)
+                        return;
+                for (Identifier identifier : unmatchedIdentifier.get(key))
+                        index.addDeclaration(TokenFactory.createToken(index, identifier), entry);
+                unmatchedIdentifier.removeAll(key);
+        }
+
+        @Override
+        public Void visitObjectCreationExpression(ObjectCreationExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                if (ref != null && node.getType() instanceof SimpleType) {
+                        SimpleType simpleTypeNode = (SimpleType) node.getType();
+                        ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                        MethodEntry constructorEntry = new MethodEntry(classEntry, "<init>", new MethodDescriptor(ref.getErasedSignature()));
+                        index.addReference(TokenFactory.createToken(index, simpleTypeNode.getIdentifierToken()), constructorEntry, this.methodEntry);
+                }
+
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitVariableDeclaration(VariableDeclarationStatement node, SourceIndex index) {
+                AstNodeCollection<VariableInitializer> variables = node.getVariables();
+
+                // Single assignation
+                if (variables.size() == 1) {
+                        VariableInitializer initializer = variables.firstOrNullObject();
+                        if (initializer != null && node.getType() instanceof SimpleType) {
+                                Identifier identifier = initializer.getNameToken();
+                                Variable variable = initializer.getUserData(Keys.VARIABLE);
+                                if (variable != null) {
+                                        VariableDefinition originalVariable = variable.getOriginalVariable();
+                                        if (originalVariable != null) {
+                                                int variableIndex = originalVariable.getSlot();
+                                                if (variableIndex >= 0) {
+                                                        MethodDefEntry ownerMethod = EntryParser.parse(originalVariable.getDeclaringMethod());
+                                                        TypeDescriptor variableType = EntryParser.parseTypeDescriptor(originalVariable.getVariableType());
+                                                        LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, variableIndex, initializer.getName(), false, variableType, null);
+                                                        identifierEntryCache.put(identifier.getName(), localVariableEntry);
+                                                        addDeclarationToUnmatched(identifier.getName(), index);
+                                                        index.addDeclaration(TokenFactory.createToken(index, identifier), localVariableEntry);
+                                                }
+                                        }
+                                }
+                        }
+                }
+                return visitChildren(node, index);
+        }
+
+        @Override
+        public Void visitMethodGroupExpression(MethodGroupExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+
+                if (ref instanceof MethodReference) {
+                        // get the behavior entry
+                        ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                        MethodEntry methodEntry = new MethodEntry(classEntry, ref.getName(), new MethodDescriptor(ref.getErasedSignature()));
+
+                        // get the node for the token
+                        AstNode methodNameToken = node.getMethodNameToken();
+                        AstNode targetToken = node.getTarget();
+
+                        if (methodNameToken != null) {
+                                index.addReference(TokenFactory.createToken(index, methodNameToken), methodEntry, this.methodEntry);
+                        }
+
+                        if (targetToken != null && !(targetToken instanceof ThisReferenceExpression)) {
+                                index.addReference(TokenFactory.createToken(index, targetToken), methodEntry.getParent(), this.methodEntry);
+                        }
+                }
+
+                return visitChildren(node, index);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexVisitor.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexVisitor.java
new file mode 100644
index 0000000..dad505f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/index/SourceIndexVisitor.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * 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.source.procyon.index;
+
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.DepthFirstAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import cuchaz.enigma.source.SourceIndex;
+import cuchaz.enigma.source.procyon.EntryParser;
+import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
+
+public class SourceIndexVisitor extends DepthFirstAstVisitor<SourceIndex, Void> {
+        @Override
+        public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) {
+                TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
+                ClassDefEntry classEntry = EntryParser.parse(def);
+                index.addDeclaration(TokenFactory.createToken(index, node.getNameToken()), classEntry);
+
+                return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
+        }
+
+        @Override
+        protected Void visitChildren(AstNode node, SourceIndex index) {
+                for (final AstNode child : node.getChildren()) {
+                        child.acceptVisitor(this, index);
+                }
+                return null;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/index/TokenFactory.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/index/TokenFactory.java
new file mode 100644
index 0000000..dc36865
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/index/TokenFactory.java
@@ -0,0 +1,46 @@
+package cuchaz.enigma.source.procyon.index;
+
+import com.strobel.decompiler.languages.Region;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import cuchaz.enigma.source.Token;
+import cuchaz.enigma.source.SourceIndex;
+
+import java.util.regex.Pattern;
+
+public class TokenFactory {
+    private static final Pattern ANONYMOUS_INNER = Pattern.compile("\\$\\d+$");
+
+    public static Token createToken(SourceIndex index, AstNode node) {
+        String name = node instanceof Identifier ? ((Identifier) node).getName() : "";
+        Region region = node.getRegion();
+
+        if (region.getBeginLine() == 0) {
+            System.err.println("Got bad region from Procyon for node " + node);
+            return null;
+        }
+
+        int start = index.getPosition(region.getBeginLine(), region.getBeginColumn());
+        int end = index.getPosition(region.getEndLine(), region.getEndColumn());
+        String text = index.getSource().substring(start, end);
+        Token token = new Token(start, end, text);
+
+        boolean isAnonymousInner =
+                node instanceof Identifier &&
+                name.indexOf('$') >= 0 && node.getParent() instanceof ConstructorDeclaration &&
+                name.lastIndexOf('$') >= 0 &&
+                !ANONYMOUS_INNER.matcher(name).matches();
+
+        if (isAnonymousInner) {
+            TypeDeclaration type = node.getParent().getParent() instanceof TypeDeclaration ? (TypeDeclaration) node.getParent().getParent() : null;
+            if (type != null) {
+                name = type.getName();
+                token.end = token.start + name.length();
+            }
+        }
+
+        return token;
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/AddJavadocsAstTransform.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/AddJavadocsAstTransform.java
new file mode 100644
index 0000000..70fc8c6
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/AddJavadocsAstTransform.java
@@ -0,0 +1,134 @@
+package cuchaz.enigma.source.procyon.transformers;
+
+import com.google.common.base.Function;
+import com.google.common.base.Strings;
+import com.strobel.assembler.metadata.ParameterDefinition;
+import com.strobel.decompiler.languages.java.ast.*;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+import cuchaz.enigma.source.procyon.EntryParser;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+import cuchaz.enigma.translation.mapping.ResolutionStrategy;
+import cuchaz.enigma.translation.representation.entry.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+public final class AddJavadocsAstTransform implements IAstTransform {
+
+        private final EntryRemapper remapper;
+
+        public AddJavadocsAstTransform(EntryRemapper remapper) {
+                this.remapper = remapper;
+        }
+
+        @Override
+        public void run(AstNode compilationUnit) {
+                compilationUnit.acceptVisitor(new Visitor(remapper), null);
+        }
+
+        static class Visitor extends DepthFirstAstVisitor<Void, Void> {
+
+                private final EntryRemapper remapper;
+
+                Visitor(EntryRemapper remapper) {
+                        this.remapper = remapper;
+                }
+
+                private <T extends AstNode> void addDoc(T node, Function<T, Entry<?>> retriever) {
+                        final Comment[] comments = getComments(node, retriever);
+                        if (comments != null) {
+                                node.insertChildrenBefore(node.getFirstChild(), Roles.COMMENT, comments);
+                        }
+                }
+
+                private <T extends AstNode> Comment[] getComments(T node, Function<T, Entry<?>> retriever) {
+                        final EntryMapping mapping = remapper.getDeobfMapping(retriever.apply(node));
+                        final String docs = mapping == null ? null : Strings.emptyToNull(mapping.getJavadoc());
+                        return docs == null ? null : Stream.of(docs.split("\\R")).map(st -> new Comment(st,
+                                        CommentType.Documentation)).toArray(Comment[]::new);
+                }
+
+                private Comment[] getParameterComments(ParameterDeclaration node, Function<ParameterDeclaration, Entry<?>> retriever) {
+                        final EntryMapping mapping = remapper.getDeobfMapping(retriever.apply(node));
+                        final Comment[] ret = getComments(node, retriever);
+                        if (ret != null) {
+                                final String paramPrefix = "@param " + mapping.getTargetName() + " ";
+                                final String indent = Strings.repeat(" ", paramPrefix.length());
+                                ret[0].setContent(paramPrefix + ret[0].getContent());
+                                for (int i = 1; i < ret.length; i++) {
+                                        ret[i].setContent(indent + ret[i].getContent());
+                                }
+                        }
+                        return ret;
+                }
+
+                private void visitMethod(AstNode node) {
+                        final MethodDefEntry methodDefEntry = EntryParser.parse(node.getUserData(Keys.METHOD_DEFINITION));
+                        final Comment[] baseComments = getComments(node, $ -> methodDefEntry);
+                        List<Comment> comments = new ArrayList<>();
+                        if (baseComments != null)
+                                Collections.addAll(comments, baseComments);
+
+                        for (ParameterDeclaration dec : node.getChildrenByRole(Roles.PARAMETER)) {
+                                ParameterDefinition def = dec.getUserData(Keys.PARAMETER_DEFINITION);
+                                final Comment[] paramComments = getParameterComments(dec, $ -> new LocalVariableDefEntry(methodDefEntry, def.getSlot(), def.getName(),
+                                                true,
+                                                EntryParser.parseTypeDescriptor(def.getParameterType()), null));
+                                if (paramComments != null)
+                                        Collections.addAll(comments, paramComments);
+                        }
+
+                        if (!comments.isEmpty()) {
+                                if (remapper.getObfResolver().resolveEntry(methodDefEntry, ResolutionStrategy.RESOLVE_ROOT).stream().noneMatch(e -> Objects.equals(e, methodDefEntry))) {
+                                        comments.add(0, new Comment("{@inheritDoc}", CommentType.Documentation));
+                                }
+                                final AstNode oldFirst = node.getFirstChild();
+                                for (Comment comment : comments) {
+                                        node.insertChildBefore(oldFirst, comment, Roles.COMMENT);
+                                }
+                        }
+                }
+
+                @Override
+                protected Void visitChildren(AstNode node, Void data) {
+                        for (final AstNode child : node.getChildren()) {
+                                child.acceptVisitor(this, data);
+                        }
+                        return null;
+                }
+
+                @Override
+                public Void visitMethodDeclaration(MethodDeclaration node, Void data) {
+                        visitMethod(node);
+                        return super.visitMethodDeclaration(node, data);
+                }
+
+                @Override
+                public Void visitConstructorDeclaration(ConstructorDeclaration node, Void data) {
+                        visitMethod(node);
+                        return super.visitConstructorDeclaration(node, data);
+                }
+
+                @Override
+                public Void visitFieldDeclaration(FieldDeclaration node, Void data) {
+                        addDoc(node, dec -> EntryParser.parse(dec.getUserData(Keys.FIELD_DEFINITION)));
+                        return super.visitFieldDeclaration(node, data);
+                }
+
+                @Override
+                public Void visitTypeDeclaration(TypeDeclaration node, Void data) {
+                        addDoc(node, dec -> EntryParser.parse(dec.getUserData(Keys.TYPE_DEFINITION)));
+                        return super.visitTypeDeclaration(node, data);
+                }
+
+                @Override
+                public Void visitEnumValueDeclaration(EnumValueDeclaration node, Void data) {
+                        addDoc(node, dec -> EntryParser.parse(dec.getUserData(Keys.FIELD_DEFINITION)));
+                        return super.visitEnumValueDeclaration(node, data);
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/DropImportAstTransform.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/DropImportAstTransform.java
new file mode 100644
index 0000000..39e599d
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/DropImportAstTransform.java
@@ -0,0 +1,33 @@
+package cuchaz.enigma.source.procyon.transformers;
+
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.DepthFirstAstVisitor;
+import com.strobel.decompiler.languages.java.ast.ImportDeclaration;
+import com.strobel.decompiler.languages.java.ast.PackageDeclaration;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+
+public final class DropImportAstTransform implements IAstTransform {
+        public static final DropImportAstTransform INSTANCE = new DropImportAstTransform();
+
+        private DropImportAstTransform() {
+        }
+
+        @Override
+        public void run(AstNode compilationUnit) {
+                compilationUnit.acceptVisitor(new Visitor(), null);
+        }
+
+        static class Visitor extends DepthFirstAstVisitor<Void, Void> {
+                @Override
+                public Void visitPackageDeclaration(PackageDeclaration node, Void data) {
+                        node.remove();
+                        return null;
+                }
+
+                @Override
+                public Void visitImportDeclaration(ImportDeclaration node, Void data) {
+                        node.remove();
+                        return null;
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/DropVarModifiersAstTransform.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/DropVarModifiersAstTransform.java
new file mode 100644
index 0000000..b8c087b
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/DropVarModifiersAstTransform.java
@@ -0,0 +1,37 @@
+package cuchaz.enigma.source.procyon.transformers;
+
+import com.strobel.decompiler.languages.java.ast.*;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+
+import javax.lang.model.element.Modifier;
+
+public final class DropVarModifiersAstTransform implements IAstTransform {
+        public static final DropVarModifiersAstTransform INSTANCE = new DropVarModifiersAstTransform();
+
+        private DropVarModifiersAstTransform() {
+        }
+
+        @Override
+        public void run(AstNode compilationUnit) {
+                compilationUnit.acceptVisitor(new Visitor(), null);
+        }
+
+        static class Visitor extends DepthFirstAstVisitor<Void, Void> {
+                @Override
+                public Void visitParameterDeclaration(ParameterDeclaration node, Void data) {
+                        for (JavaModifierToken modifierToken : node.getChildrenByRole(EntityDeclaration.MODIFIER_ROLE)) {
+                                if (modifierToken.getModifier() == Modifier.FINAL) {
+                                        modifierToken.remove();
+                                }
+                        }
+
+                        return null;
+                }
+
+                @Override
+                public Void visitVariableDeclaration(VariableDeclarationStatement node, Void data) {
+                        node.removeModifier(Modifier.FINAL);
+                        return null;
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/InvalidIdentifierFix.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/InvalidIdentifierFix.java
new file mode 100644
index 0000000..34d95fa
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/InvalidIdentifierFix.java
@@ -0,0 +1,29 @@
+package cuchaz.enigma.source.procyon.transformers;
+
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.DepthFirstAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+
+/**
+ * Created by Thiakil on 13/07/2018.
+ */
+public class InvalidIdentifierFix implements IAstTransform {
+        @Override
+        public void run(AstNode compilationUnit) {
+                compilationUnit.acceptVisitor(new Visitor(), null);
+        }
+
+        class Visitor extends DepthFirstAstVisitor<Void,Void>{
+                @Override
+                public Void visitIdentifier(Identifier node, Void data) {
+                        super.visitIdentifier(node, data);
+                        if (node.getName().equals("do") || node.getName().equals("if")){
+                                Identifier newIdentifier = Identifier.create(node.getName() + "_", node.getStartLocation());
+                                newIdentifier.copyUserDataFrom(node);
+                                node.replaceWith(newIdentifier);
+                        }
+                        return null;
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/Java8Generics.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/Java8Generics.java
new file mode 100644
index 0000000..8accfc7
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/Java8Generics.java
@@ -0,0 +1,107 @@
+package cuchaz.enigma.source.procyon.transformers;
+
+import com.strobel.assembler.metadata.BuiltinTypes;
+import com.strobel.assembler.metadata.CommonTypeReferences;
+import com.strobel.assembler.metadata.Flags;
+import com.strobel.assembler.metadata.IGenericInstance;
+import com.strobel.assembler.metadata.IMemberDefinition;
+import com.strobel.assembler.metadata.JvmType;
+import com.strobel.assembler.metadata.MemberReference;
+import com.strobel.assembler.metadata.MethodDefinition;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+import com.strobel.decompiler.languages.java.ast.ArrayCreationExpression;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.AstNodeCollection;
+import com.strobel.decompiler.languages.java.ast.AstType;
+import com.strobel.decompiler.languages.java.ast.CastExpression;
+import com.strobel.decompiler.languages.java.ast.ComposedType;
+import com.strobel.decompiler.languages.java.ast.DepthFirstAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Expression;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.Roles;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.WildcardType;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+
+/**
+ * Created by Thiakil on 12/07/2018.
+ */
+public class Java8Generics implements IAstTransform {
+
+        @Override
+        public void run(AstNode compilationUnit) {
+                compilationUnit.acceptVisitor(new Visitor(), null);
+        }
+
+        static class Visitor extends DepthFirstAstVisitor<Void,Void>{
+
+                @Override
+                public Void visitInvocationExpression(InvocationExpression node, Void data) {
+                        super.visitInvocationExpression(node, data);
+                        if (node.getTarget() instanceof MemberReferenceExpression){
+                                MemberReferenceExpression referenceExpression = (MemberReferenceExpression) node.getTarget();
+                                if (referenceExpression.getTypeArguments().stream().map(t->{
+                                        TypeReference tr = t.toTypeReference();
+                                        if (tr.getDeclaringType() != null){//ensure that inner types are resolved so we can get the TypeDefinition below
+                                                TypeReference resolved = tr.resolve();
+                                                if (resolved != null)
+                                                        return resolved;
+                                        }
+                                        return tr;
+                                }).anyMatch(t -> t.isWildcardType() || (t instanceof TypeDefinition && ((TypeDefinition) t).isAnonymous()))) {
+                                        //these are invalid for invocations, let the compiler work it out
+                                        referenceExpression.getTypeArguments().clear();
+                                } else if (referenceExpression.getTypeArguments().stream().allMatch(t->t.toTypeReference().equals(CommonTypeReferences.Object))){
+                                        //all are <Object>, thereby redundant and/or bad
+                                        referenceExpression.getTypeArguments().clear();
+                                }
+                        }
+                        return null;
+                }
+
+                @Override
+                public Void visitObjectCreationExpression(ObjectCreationExpression node, Void data) {
+                        super.visitObjectCreationExpression(node, data);
+                        AstType type = node.getType();
+                        if (type instanceof SimpleType && !((SimpleType) type).getTypeArguments().isEmpty()){
+                                SimpleType simpleType = (SimpleType) type;
+                                AstNodeCollection<AstType> typeArguments = simpleType.getTypeArguments();
+                                if (typeArguments.size() == 1 && typeArguments.firstOrNullObject().toTypeReference().equals(CommonTypeReferences.Object)){
+                                        //all are <Object>, thereby redundant and/or bad
+                                        typeArguments.firstOrNullObject().getChildByRole(Roles.IDENTIFIER).replaceWith(Identifier.create(""));
+                                }
+                        }
+                        return null;
+                }
+
+                @Override
+                public Void visitCastExpression(CastExpression node, Void data) {
+                        boolean doReplace = false;
+                        TypeReference typeReference = node.getType().toTypeReference();
+                        if (typeReference.isArray() && typeReference.getElementType().isGenericType()){
+                                doReplace = true;
+                        } else if (typeReference.isGenericType()) {
+                                Expression target = node.getExpression();
+                                if (typeReference instanceof IGenericInstance && ((IGenericInstance)typeReference).getTypeArguments().stream().anyMatch(t->t.isWildcardType())){
+                                        doReplace = true;
+                                } else if (target instanceof InvocationExpression) {
+                                        InvocationExpression invocationExpression = (InvocationExpression)target;
+                                        if (invocationExpression.getTarget() instanceof MemberReferenceExpression && !((MemberReferenceExpression) invocationExpression.getTarget()).getTypeArguments().isEmpty()) {
+                                                ((MemberReferenceExpression) invocationExpression.getTarget()).getTypeArguments().clear();
+                                                doReplace = true;
+                                        }
+                                }
+                        }
+                        super.visitCastExpression(node, data);
+                        if (doReplace){
+                                node.replaceWith(node.getExpression());
+                        }
+                        return null;
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/ObfuscatedEnumSwitchRewriterTransform.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/ObfuscatedEnumSwitchRewriterTransform.java
new file mode 100644
index 0000000..32bb72f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/ObfuscatedEnumSwitchRewriterTransform.java
@@ -0,0 +1,414 @@
+/*
+ * Originally:
+ * EnumSwitchRewriterTransform.java
+ *
+ * Copyright (c) 2013 Mike Strobel
+ *
+ * This source code is based on Mono.Cecil from Jb Evain, Copyright (c) Jb Evain;
+ * and ILSpy/ICSharpCode from SharpDevelop, Copyright (c) AlphaSierraPapa.
+ *
+ * This source code is subject to terms and conditions of the Apache License, Version 2.0.
+ * A copy of the license can be found in the License.html file at the root of this distribution.
+ * By using this source code in any fashion, you are agreeing to be bound by the terms of the
+ * Apache License, Version 2.0.
+ *
+ * You must not remove this notice, or any other, from this software.
+ */
+
+package cuchaz.enigma.source.procyon.transformers;
+
+import com.strobel.assembler.metadata.BuiltinTypes;
+import com.strobel.assembler.metadata.FieldDefinition;
+import com.strobel.assembler.metadata.MethodDefinition;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+import com.strobel.core.SafeCloseable;
+import com.strobel.core.VerifyArgument;
+import com.strobel.decompiler.DecompilerContext;
+import com.strobel.decompiler.languages.java.ast.AssignmentExpression;
+import com.strobel.decompiler.languages.java.ast.AstBuilder;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.CaseLabel;
+import com.strobel.decompiler.languages.java.ast.ContextTrackingVisitor;
+import com.strobel.decompiler.languages.java.ast.Expression;
+import com.strobel.decompiler.languages.java.ast.IdentifierExpression;
+import com.strobel.decompiler.languages.java.ast.IndexerExpression;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.PrimitiveExpression;
+import com.strobel.decompiler.languages.java.ast.SwitchSection;
+import com.strobel.decompiler.languages.java.ast.SwitchStatement;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Copy of {@link com.strobel.decompiler.languages.java.ast.transforms.EnumSwitchRewriterTransform} modified to:
+ * - Not rely on a field containing "$SwitchMap$" (Proguard strips it)
+ * - Ignore classes *with* SwitchMap$ names (so the original can handle it)
+ * - Ignores inner synthetics that are not package private
+ */
+@SuppressWarnings("Duplicates")
+public class ObfuscatedEnumSwitchRewriterTransform implements IAstTransform {
+    private final DecompilerContext _context;
+
+    public ObfuscatedEnumSwitchRewriterTransform(final DecompilerContext context) {
+        _context = VerifyArgument.notNull(context, "context");
+    }
+
+    @Override
+    public void run(final AstNode compilationUnit) {
+        compilationUnit.acceptVisitor(new Visitor(_context), null);
+    }
+
+    private final static class Visitor extends ContextTrackingVisitor<Void> {
+        private final static class SwitchMapInfo {
+            final String enclosingType;
+            final Map<String, List<SwitchStatement>> switches = new LinkedHashMap<>();
+            final Map<String, Map<Integer, Expression>> mappings = new LinkedHashMap<>();
+
+            TypeDeclaration enclosingTypeDeclaration;
+
+            SwitchMapInfo(final String enclosingType) {
+                this.enclosingType = enclosingType;
+            }
+        }
+
+        private final Map<String, SwitchMapInfo> _switchMaps = new LinkedHashMap<>();
+        private boolean _isSwitchMapWrapper;
+
+        protected Visitor(final DecompilerContext context) {
+            super(context);
+        }
+
+        @Override
+        public Void visitTypeDeclaration(final TypeDeclaration typeDeclaration, final Void p) {
+            final boolean oldIsSwitchMapWrapper = _isSwitchMapWrapper;
+            final TypeDefinition typeDefinition = typeDeclaration.getUserData(Keys.TYPE_DEFINITION);
+            final boolean isSwitchMapWrapper = isSwitchMapWrapper(typeDefinition);
+
+            if (isSwitchMapWrapper) {
+                final String internalName = typeDefinition.getInternalName();
+
+                SwitchMapInfo info = _switchMaps.get(internalName);
+
+                if (info == null) {
+                    _switchMaps.put(internalName, info = new SwitchMapInfo(internalName));
+                }
+
+                info.enclosingTypeDeclaration = typeDeclaration;
+            }
+
+            _isSwitchMapWrapper = isSwitchMapWrapper;
+
+            try {
+                super.visitTypeDeclaration(typeDeclaration, p);
+            }
+            finally {
+                _isSwitchMapWrapper = oldIsSwitchMapWrapper;
+            }
+
+            rewrite();
+
+            return null;
+        }
+
+        @Override
+        public Void visitSwitchStatement(final SwitchStatement node, final Void data) {
+            final Expression test = node.getExpression();
+
+            if (test instanceof IndexerExpression) {
+                final IndexerExpression indexer = (IndexerExpression) test;
+                final Expression array = indexer.getTarget();
+                final Expression argument = indexer.getArgument();
+
+                if (!(array instanceof MemberReferenceExpression)) {
+                    return super.visitSwitchStatement(node, data);
+                }
+
+                final MemberReferenceExpression arrayAccess = (MemberReferenceExpression) array;
+                final Expression arrayOwner = arrayAccess.getTarget();
+                final String mapName = arrayAccess.getMemberName();
+
+                if (mapName == null || mapName.startsWith("$SwitchMap$") || !(arrayOwner instanceof TypeReferenceExpression)) {
+                    return super.visitSwitchStatement(node, data);
+                }
+
+                final TypeReferenceExpression enclosingTypeExpression = (TypeReferenceExpression) arrayOwner;
+                final TypeReference enclosingType = enclosingTypeExpression.getType().getUserData(Keys.TYPE_REFERENCE);
+
+                if (!isSwitchMapWrapper(enclosingType) || !(argument instanceof InvocationExpression)) {
+                    return super.visitSwitchStatement(node, data);
+                }
+
+                final InvocationExpression invocation = (InvocationExpression) argument;
+                final Expression invocationTarget = invocation.getTarget();
+
+                if (!(invocationTarget instanceof MemberReferenceExpression)) {
+                    return super.visitSwitchStatement(node, data);
+                }
+
+                final MemberReferenceExpression memberReference = (MemberReferenceExpression) invocationTarget;
+
+                if (!"ordinal".equals(memberReference.getMemberName())) {
+                    return super.visitSwitchStatement(node, data);
+                }
+
+                final String enclosingTypeName = enclosingType.getInternalName();
+
+                SwitchMapInfo info = _switchMaps.get(enclosingTypeName);
+
+                if (info == null) {
+                    _switchMaps.put(enclosingTypeName, info = new SwitchMapInfo(enclosingTypeName));
+
+                    final TypeDefinition resolvedType = enclosingType.resolve();
+
+                    if (resolvedType != null) {
+                        AstBuilder astBuilder = context.getUserData(Keys.AST_BUILDER);
+
+                        if (astBuilder == null) {
+                            astBuilder = new AstBuilder(context);
+                        }
+
+                        try (final SafeCloseable importSuppression = astBuilder.suppressImports()) {
+                            final TypeDeclaration declaration = astBuilder.createType(resolvedType);
+
+                            declaration.acceptVisitor(this, data);
+                        }
+                    }
+                }
+
+                List<SwitchStatement> switches = info.switches.get(mapName);
+
+                if (switches == null) {
+                    info.switches.put(mapName, switches = new ArrayList<>());
+                }
+
+                switches.add(node);
+            }
+
+            return super.visitSwitchStatement(node, data);
+        }
+
+        @Override
+        public Void visitAssignmentExpression(final AssignmentExpression node, final Void data) {
+            final TypeDefinition currentType = context.getCurrentType();
+            final MethodDefinition currentMethod = context.getCurrentMethod();
+
+            if (_isSwitchMapWrapper &&
+                currentType != null &&
+                currentMethod != null &&
+                currentMethod.isTypeInitializer()) {
+
+                final Expression left = node.getLeft();
+                final Expression right = node.getRight();
+
+                if (left instanceof IndexerExpression &&
+                    right instanceof PrimitiveExpression) {
+
+                    String mapName = null;
+
+                    final Expression array = ((IndexerExpression) left).getTarget();
+                    final Expression argument = ((IndexerExpression) left).getArgument();
+
+                    if (array instanceof MemberReferenceExpression) {
+                        mapName = ((MemberReferenceExpression) array).getMemberName();
+                    }
+                    else if (array instanceof IdentifierExpression) {
+                        mapName = ((IdentifierExpression) array).getIdentifier();
+                    }
+
+                    if (mapName == null || mapName.startsWith("$SwitchMap$")) {
+                        return super.visitAssignmentExpression(node, data);
+                    }
+
+                    if (!(argument instanceof InvocationExpression)) {
+                        return super.visitAssignmentExpression(node, data);
+                    }
+
+                    final InvocationExpression invocation = (InvocationExpression) argument;
+                    final Expression invocationTarget = invocation.getTarget();
+
+                    if (!(invocationTarget instanceof MemberReferenceExpression)) {
+                        return super.visitAssignmentExpression(node, data);
+                    }
+
+                    final MemberReferenceExpression memberReference = (MemberReferenceExpression) invocationTarget;
+                    final Expression memberTarget = memberReference.getTarget();
+
+                    if (!(memberTarget instanceof MemberReferenceExpression) || !"ordinal".equals(memberReference.getMemberName())) {
+                        return super.visitAssignmentExpression(node, data);
+                    }
+
+                    final MemberReferenceExpression outerMemberReference = (MemberReferenceExpression) memberTarget;
+                    final Expression outerMemberTarget = outerMemberReference.getTarget();
+
+                    if (!(outerMemberTarget instanceof TypeReferenceExpression)) {
+                        return super.visitAssignmentExpression(node, data);
+                    }
+
+                    final String enclosingType = currentType.getInternalName();
+
+                    SwitchMapInfo info = _switchMaps.get(enclosingType);
+
+                    if (info == null) {
+                        _switchMaps.put(enclosingType, info = new SwitchMapInfo(enclosingType));
+
+                        AstBuilder astBuilder = context.getUserData(Keys.AST_BUILDER);
+
+                        if (astBuilder == null) {
+                            astBuilder = new AstBuilder(context);
+                        }
+
+                        info.enclosingTypeDeclaration = astBuilder.createType(currentType);
+                    }
+
+                    final PrimitiveExpression value = (PrimitiveExpression) right;
+
+                    assert value.getValue() instanceof Integer;
+
+                    Map<Integer, Expression> mapping = info.mappings.get(mapName);
+
+                    if (mapping == null) {
+                        info.mappings.put(mapName, mapping = new LinkedHashMap<>());
+                    }
+
+                    final IdentifierExpression enumValue = new IdentifierExpression( Expression.MYSTERY_OFFSET, outerMemberReference.getMemberName());
+
+                    enumValue.putUserData(Keys.MEMBER_REFERENCE, outerMemberReference.getUserData(Keys.MEMBER_REFERENCE));
+
+                    mapping.put(((Number) value.getValue()).intValue(), enumValue);
+                }
+            }
+
+            return super.visitAssignmentExpression(node, data);
+        }
+
+        private void rewrite() {
+            if (_switchMaps.isEmpty()) {
+                return;
+            }
+
+            for (final SwitchMapInfo info : _switchMaps.values()) {
+                rewrite(info);
+            }
+
+            //
+            // Remove switch map type wrappers that are no longer referenced.
+            //
+
+        outer:
+            for (final SwitchMapInfo info : _switchMaps.values()) {
+                for (final String mapName : info.switches.keySet()) {
+                    final List<SwitchStatement> switches = info.switches.get(mapName);
+
+                    if (switches != null && !switches.isEmpty()) {
+                        continue outer;
+                    }
+                }
+
+                final TypeDeclaration enclosingTypeDeclaration = info.enclosingTypeDeclaration;
+
+                if (enclosingTypeDeclaration != null) {
+                    enclosingTypeDeclaration.remove();
+                }
+            }
+        }
+
+        private void rewrite(final SwitchMapInfo info) {
+            if (info.switches.isEmpty()) {
+                return;
+            }
+
+            for (final String mapName : info.switches.keySet()) {
+                final List<SwitchStatement> switches = info.switches.get(mapName);
+                final Map<Integer, Expression> mappings = info.mappings.get(mapName);
+
+                if (switches != null && mappings != null) {
+                    for (int i = 0; i < switches.size(); i++) {
+                        if (rewriteSwitch(switches.get(i), mappings)) {
+                            switches.remove(i--);
+                        }
+                    }
+                }
+            }
+        }
+
+        private boolean rewriteSwitch(final SwitchStatement s, final Map<Integer, Expression> mappings) {
+            final Map<Expression, Expression> replacements = new IdentityHashMap<>();
+
+            for (final SwitchSection section : s.getSwitchSections()) {
+                for (final CaseLabel caseLabel : section.getCaseLabels()) {
+                    final Expression expression = caseLabel.getExpression();
+
+                    if (expression.isNull()) {
+                        continue;
+                    }
+
+                    if (expression instanceof PrimitiveExpression) {
+                        final Object value = ((PrimitiveExpression) expression).getValue();
+
+                        if (value instanceof Integer) {
+                            final Expression replacement = mappings.get(value);
+
+                            if (replacement != null) {
+                                replacements.put(expression, replacement);
+                                continue;
+                            }
+                        }
+                    }
+
+                    //
+                    // If we can't rewrite all cases, we abort.
+                    //
+
+                    return false;
+                }
+            }
+
+            final IndexerExpression indexer = (IndexerExpression) s.getExpression();
+            final InvocationExpression argument = (InvocationExpression) indexer.getArgument();
+            final MemberReferenceExpression memberReference = (MemberReferenceExpression) argument.getTarget();
+            final Expression newTest = memberReference.getTarget();
+
+            newTest.remove();
+            indexer.replaceWith(newTest);
+
+            for (final Map.Entry<Expression, Expression> entry : replacements.entrySet()) {
+                entry.getKey().replaceWith(entry.getValue().clone());
+            }
+
+            return true;
+        }
+
+        private static boolean isSwitchMapWrapper(final TypeReference type) {
+            if (type == null) {
+                return false;
+            }
+
+            final TypeDefinition definition = type instanceof TypeDefinition ? (TypeDefinition) type
+                                                                             : type.resolve();
+
+            if (definition == null || !definition.isSynthetic() || !definition.isInnerClass() || !definition.isPackagePrivate()) {
+                return false;
+            }
+
+            for (final FieldDefinition field : definition.getDeclaredFields()) {
+                if (!field.getName().startsWith("$SwitchMap$") &&
+                    BuiltinTypes.Integer.makeArrayType().equals(field.getFieldType())) {
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/RemoveObjectCasts.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/RemoveObjectCasts.java
new file mode 100644
index 0000000..cf0376f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/RemoveObjectCasts.java
@@ -0,0 +1,39 @@
+package cuchaz.enigma.source.procyon.transformers;
+
+import com.strobel.assembler.metadata.BuiltinTypes;
+import com.strobel.decompiler.DecompilerContext;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.CastExpression;
+import com.strobel.decompiler.languages.java.ast.ContextTrackingVisitor;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+
+/**
+ * Created by Thiakil on 11/07/2018.
+ */
+public class RemoveObjectCasts implements IAstTransform {
+        private final DecompilerContext _context;
+
+        public RemoveObjectCasts(DecompilerContext context) {
+                _context = context;
+        }
+
+        @Override
+        public void run(AstNode compilationUnit) {
+                compilationUnit.acceptVisitor(new Visitor(_context), null);
+        }
+
+        private final static class Visitor extends ContextTrackingVisitor<Void>{
+
+                protected Visitor(DecompilerContext context) {
+                        super(context);
+                }
+
+                @Override
+                public Void visitCastExpression(CastExpression node, Void data) {
+                        if (node.getType().toTypeReference().equals(BuiltinTypes.Object)){
+                                node.replaceWith(node.getExpression());
+                        }
+                        return super.visitCastExpression(node, data);
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/VarargsFixer.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/VarargsFixer.java
new file mode 100644
index 0000000..d3ddaab
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/transformers/VarargsFixer.java
@@ -0,0 +1,197 @@
+package cuchaz.enigma.source.procyon.transformers;
+
+import com.strobel.assembler.metadata.MemberReference;
+import com.strobel.assembler.metadata.MetadataFilters;
+import com.strobel.assembler.metadata.MetadataHelper;
+import com.strobel.assembler.metadata.MethodBinder;
+import com.strobel.assembler.metadata.MethodDefinition;
+import com.strobel.assembler.metadata.MethodReference;
+import com.strobel.assembler.metadata.TypeReference;
+import com.strobel.core.StringUtilities;
+import com.strobel.core.VerifyArgument;
+import com.strobel.decompiler.DecompilerContext;
+import com.strobel.decompiler.languages.java.ast.ArrayCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayInitializerExpression;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.AstNodeCollection;
+import com.strobel.decompiler.languages.java.ast.CastExpression;
+import com.strobel.decompiler.languages.java.ast.ContextTrackingVisitor;
+import com.strobel.decompiler.languages.java.ast.DepthFirstAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Expression;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.JavaResolver;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+import com.strobel.decompiler.semantics.ResolveResult;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Thiakil on 12/07/2018.
+ */
+public class VarargsFixer implements IAstTransform {
+        private final DecompilerContext _context;
+
+        public VarargsFixer(final DecompilerContext context) {
+                _context = VerifyArgument.notNull(context, "context");
+        }
+
+        @Override
+        public void run(AstNode compilationUnit) {
+                compilationUnit.acceptVisitor(new Visitor(_context), null);
+        }
+
+        class Visitor extends ContextTrackingVisitor<Void> {
+                private final JavaResolver _resolver;
+                protected Visitor(DecompilerContext context) {
+                        super(context);
+                        _resolver = new JavaResolver(context);
+                }
+
+                //remove `new Object[0]` on varagrs as the normal tranformer doesnt do them
+                @Override
+                public Void visitInvocationExpression(InvocationExpression node, Void data) {
+                        super.visitInvocationExpression(node, data);
+                        MemberReference definition = node.getUserData(Keys.MEMBER_REFERENCE);
+                        if (definition instanceof MethodDefinition && ((MethodDefinition) definition).isVarArgs()){
+                                AstNodeCollection<Expression> arguments = node.getArguments();
+                                Expression lastParam = arguments.lastOrNullObject();
+                                if (!lastParam.isNull() && lastParam instanceof ArrayCreationExpression){
+                                        ArrayCreationExpression varargArray = (ArrayCreationExpression)lastParam;
+                                        if (varargArray.getInitializer().isNull() || varargArray.getInitializer().getElements().isEmpty()){
+                                                lastParam.remove();
+                                        } else {
+                                                for (Expression e : varargArray.getInitializer().getElements()){
+                                                        arguments.insertBefore(varargArray, e.clone());
+                                                }
+                                                varargArray.remove();
+                                        }
+                                }
+                        }
+                        return null;
+                }
+
+                //applies the vararg transform to object creation
+                @Override
+                public Void visitObjectCreationExpression(ObjectCreationExpression node, Void data) {
+                        super.visitObjectCreationExpression(node, data);
+                        final AstNodeCollection<Expression> arguments = node.getArguments();
+                        final Expression lastArgument = arguments.lastOrNullObject();
+
+                        Expression arrayArg = lastArgument;
+
+                        if (arrayArg instanceof CastExpression)
+                                arrayArg = ((CastExpression) arrayArg).getExpression();
+
+                        if (arrayArg == null ||
+                                        arrayArg.isNull() ||
+                                        !(arrayArg instanceof ArrayCreationExpression &&
+                                                        node.getTarget() instanceof MemberReferenceExpression)) {
+
+                                return null;
+                        }
+
+                        final ArrayCreationExpression newArray = (ArrayCreationExpression) arrayArg;
+                        final MemberReferenceExpression target = (MemberReferenceExpression) node.getTarget();
+
+                        if (!newArray.getAdditionalArraySpecifiers().hasSingleElement()) {
+                                return null;
+                        }
+
+                        final MethodReference method = (MethodReference) node.getUserData(Keys.MEMBER_REFERENCE);
+
+                        if (method == null) {
+                                return null;
+                        }
+
+                        final MethodDefinition resolved = method.resolve();
+
+                        if (resolved == null || !resolved.isVarArgs()) {
+                                return null;
+                        }
+
+                        final List<MethodReference> candidates;
+                        final Expression invocationTarget = target.getTarget();
+
+                        if (invocationTarget == null || invocationTarget.isNull()) {
+                                candidates = MetadataHelper.findMethods(
+                                                context.getCurrentType(),
+                                                MetadataFilters.matchName(resolved.getName())
+                                );
+                        }
+                        else {
+                                final ResolveResult targetResult = _resolver.apply(invocationTarget);
+
+                                if (targetResult == null || targetResult.getType() == null) {
+                                        return null;
+                                }
+
+                                candidates = MetadataHelper.findMethods(
+                                                targetResult.getType(),
+                                                MetadataFilters.matchName(resolved.getName())
+                                );
+                        }
+
+                        final List<TypeReference> argTypes = new ArrayList<>();
+
+                        for (final Expression argument : arguments) {
+                                final ResolveResult argResult = _resolver.apply(argument);
+
+                                if (argResult == null || argResult.getType() == null) {
+                                        return null;
+                                }
+
+                                argTypes.add(argResult.getType());
+                        }
+
+                        final MethodBinder.BindResult c1 = MethodBinder.selectMethod(candidates, argTypes);
+
+                        if (c1.isFailure() || c1.isAmbiguous()) {
+                                return null;
+                        }
+
+                        argTypes.remove(argTypes.size() - 1);
+
+                        final ArrayInitializerExpression initializer = newArray.getInitializer();
+                        final boolean hasElements = !initializer.isNull() && !initializer.getElements().isEmpty();
+
+                        if (hasElements) {
+                                for (final Expression argument : initializer.getElements()) {
+                                        final ResolveResult argResult = _resolver.apply(argument);
+
+                                        if (argResult == null || argResult.getType() == null) {
+                                                return null;
+                                        }
+
+                                        argTypes.add(argResult.getType());
+                                }
+                        }
+
+                        final MethodBinder.BindResult c2 = MethodBinder.selectMethod(candidates, argTypes);
+
+                        if (c2.isFailure() ||
+                                        c2.isAmbiguous() ||
+                                        !StringUtilities.equals(c2.getMethod().getErasedSignature(), c1.getMethod().getErasedSignature())) {
+
+                                return null;
+                        }
+
+                        lastArgument.remove();
+
+                        if (!hasElements) {
+                                lastArgument.remove();
+                                return null;
+                        }
+
+                        for (final Expression newArg : initializer.getElements()) {
+                                newArg.remove();
+                                arguments.add(newArg);
+                        }
+
+                        return null;
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CachingClasspathTypeLoader.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CachingClasspathTypeLoader.java
new file mode 100644
index 0000000..e702956
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CachingClasspathTypeLoader.java
@@ -0,0 +1,33 @@
+package cuchaz.enigma.source.procyon.typeloader;
+
+import com.strobel.assembler.metadata.Buffer;
+import com.strobel.assembler.metadata.ClasspathTypeLoader;
+import com.strobel.assembler.metadata.ITypeLoader;
+
+/**
+ * Caching version of {@link ClasspathTypeLoader}
+ */
+public class CachingClasspathTypeLoader extends CachingTypeLoader {
+        private static ITypeLoader extraClassPathLoader = null;
+
+        public static void setExtraClassPathLoader(ITypeLoader loader){
+                extraClassPathLoader = loader;
+        }
+
+        private final ITypeLoader classpathLoader = new ClasspathTypeLoader();
+
+        @Override
+        protected byte[] doLoad(String className) {
+                Buffer parentBuf = new Buffer();
+                if (classpathLoader.tryLoadType(className, parentBuf)) {
+                        return parentBuf.array();
+                }
+                if (extraClassPathLoader != null){
+                        parentBuf.reset();
+                        if (extraClassPathLoader.tryLoadType(className, parentBuf)){
+                                return parentBuf.array();
+                        }
+                }
+                return EMPTY_ARRAY;//need to return *something* as null means no store
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CachingTypeLoader.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CachingTypeLoader.java
new file mode 100644
index 0000000..5be5ddd
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CachingTypeLoader.java
@@ -0,0 +1,38 @@
+package cuchaz.enigma.source.procyon.typeloader;
+
+import com.google.common.collect.Maps;
+import com.strobel.assembler.metadata.Buffer;
+import com.strobel.assembler.metadata.ITypeLoader;
+
+import java.util.Map;
+
+/**
+ * Common cache functions
+ */
+public abstract class CachingTypeLoader implements ITypeLoader {
+        protected static final byte[] EMPTY_ARRAY = {};
+
+        private final Map<String, byte[]> cache = Maps.newHashMap();
+
+        protected abstract byte[] doLoad(String className);
+
+        @Override
+        public boolean tryLoadType(String className, Buffer out) {
+
+                // check the cache
+                byte[] data = this.cache.computeIfAbsent(className, this::doLoad);
+
+                if (data == EMPTY_ARRAY) {
+                        return false;
+                }
+
+                out.reset(data.length);
+                System.arraycopy(data, 0, out.array(), out.position(), data.length);
+                out.position(0);
+                return true;
+        }
+
+        public void clearCache() {
+                this.cache.clear();
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CompiledSourceTypeLoader.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CompiledSourceTypeLoader.java
new file mode 100644
index 0000000..e703d3b
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/CompiledSourceTypeLoader.java
@@ -0,0 +1,140 @@
+/*******************************************************************************
+ * 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.source.procyon.typeloader;
+
+import com.google.common.collect.Lists;
+import com.strobel.assembler.metadata.Buffer;
+import com.strobel.assembler.metadata.ITypeLoader;
+import cuchaz.enigma.ClassProvider;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.function.Function;
+
+public class CompiledSourceTypeLoader extends CachingTypeLoader {
+        //Store one instance as the classpath shouldn't change during load
+        private static final ITypeLoader CLASSPATH_TYPE_LOADER = new CachingClasspathTypeLoader();
+
+        private final ClassProvider compiledSource;
+        private final LinkedList<Function<ClassVisitor, ClassVisitor>> visitors = new LinkedList<>();
+
+        public CompiledSourceTypeLoader(ClassProvider compiledSource) {
+                this.compiledSource = compiledSource;
+        }
+
+        public void addVisitor(Function<ClassVisitor, ClassVisitor> visitor) {
+                this.visitors.addFirst(visitor);
+        }
+
+        @Override
+        protected byte[] doLoad(String className) {
+                byte[] data = loadType(className);
+                if (data == null) {
+                        return loadClasspath(className);
+                }
+
+                return data;
+        }
+
+        private byte[] loadClasspath(String name) {
+                Buffer parentBuf = new Buffer();
+                if (CLASSPATH_TYPE_LOADER.tryLoadType(name, parentBuf)) {
+                        return parentBuf.array();
+                }
+                return EMPTY_ARRAY;
+        }
+
+        private byte[] loadType(String className) {
+                ClassEntry entry = new ClassEntry(className);
+
+                // find the class in the jar
+                ClassNode node = findClassNode(entry);
+                if (node == null) {
+                        // couldn't find it
+                        return null;
+                }
+
+                removeRedundantClassCalls(node);
+
+                ClassWriter writer = new ClassWriter(0);
+
+                ClassVisitor visitor = writer;
+                for (Function<ClassVisitor, ClassVisitor> visitorFunction : this.visitors) {
+                        visitor = visitorFunction.apply(visitor);
+                }
+
+                node.accept(visitor);
+
+                // we have a transformed class!
+                return writer.toByteArray();
+        }
+
+        private void removeRedundantClassCalls(ClassNode node) {
+                // remove <obj>.getClass() calls that are seemingly injected
+                //      DUP
+                //      INVOKEVIRTUAL java/lang/Object.getClass ()Ljava/lang/Class;
+                //      POP
+                for (MethodNode methodNode : node.methods) {
+                        AbstractInsnNode insnNode = methodNode.instructions.getFirst();
+                        while (insnNode != null) {
+                                if (insnNode instanceof MethodInsnNode && insnNode.getOpcode() == Opcodes.INVOKEVIRTUAL) {
+                                        MethodInsnNode methodInsnNode = (MethodInsnNode) insnNode;
+                                        if (methodInsnNode.name.equals("getClass") && methodInsnNode.owner.equals("java/lang/Object") && methodInsnNode.desc.equals("()Ljava/lang/Class;")) {
+                                                AbstractInsnNode previous = methodInsnNode.getPrevious();
+                                                AbstractInsnNode next = methodInsnNode.getNext();
+                                                if (previous.getOpcode() == Opcodes.DUP && next.getOpcode() == Opcodes.POP) {
+                                                        insnNode = previous.getPrevious();//reset the iterator so it gets the new next instruction
+                                                        methodNode.instructions.remove(previous);
+                                                        methodNode.instructions.remove(methodInsnNode);
+                                                        methodNode.instructions.remove(next);
+                                                }
+                                        }
+                                }
+                                insnNode = insnNode.getNext();
+                        }
+                }
+        }
+
+        private ClassNode findClassNode(ClassEntry entry) {
+                // try to find the class in the jar
+                for (String className : getClassNamesToTry(entry)) {
+                        ClassNode node = compiledSource.getClassNode(className);
+                        if (node != null) {
+                                return node;
+                        }
+                }
+
+                // didn't find it  ;_;
+                return null;
+        }
+
+        private Collection<String> getClassNamesToTry(ClassEntry entry) {
+                List<String> classNamesToTry = Lists.newArrayList();
+                classNamesToTry.add(entry.getFullName());
+
+                ClassEntry outerClass = entry.getOuterClass();
+                if (outerClass != null) {
+                        classNamesToTry.addAll(getClassNamesToTry(outerClass));
+                }
+
+                return classNamesToTry;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/NoRetryMetadataSystem.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/NoRetryMetadataSystem.java
new file mode 100644
index 0000000..c4732b0
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/NoRetryMetadataSystem.java
@@ -0,0 +1,38 @@
+package cuchaz.enigma.source.procyon.typeloader;
+
+import com.strobel.assembler.metadata.ITypeLoader;
+import com.strobel.assembler.metadata.MetadataSystem;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+public final class NoRetryMetadataSystem extends MetadataSystem {
+        private final Set<String> failedTypes = Collections.newSetFromMap(new ConcurrentHashMap<>());
+
+        public NoRetryMetadataSystem(final ITypeLoader typeLoader) {
+                super(typeLoader);
+        }
+
+        @Override
+        protected synchronized TypeDefinition resolveType(final String descriptor, final boolean mightBePrimitive) {
+                if (failedTypes.contains(descriptor)) {
+                        return null;
+                }
+
+                final TypeDefinition result = super.resolveType(descriptor, mightBePrimitive);
+
+                if (result == null) {
+                        failedTypes.add(descriptor);
+                }
+
+                return result;
+        }
+
+        @Override
+        public synchronized TypeDefinition resolve(final TypeReference type) {
+                return super.resolve(type);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/SynchronizedTypeLoader.java b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/SynchronizedTypeLoader.java
new file mode 100644
index 0000000..86c6ecc
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/source/procyon/typeloader/SynchronizedTypeLoader.java
@@ -0,0 +1,20 @@
+package cuchaz.enigma.source.procyon.typeloader;
+
+import com.strobel.assembler.metadata.Buffer;
+import com.strobel.assembler.metadata.ITypeLoader;
+
+/**
+ * Typeloader with synchronized tryLoadType method
+ */
+public class SynchronizedTypeLoader implements ITypeLoader {
+        private final ITypeLoader delegate;
+
+        public SynchronizedTypeLoader(ITypeLoader delegate) {
+                this.delegate = delegate;
+        }
+
+        @Override
+        public synchronized boolean tryLoadType(String internalName, Buffer buffer) {
+                return delegate.tryLoadType(internalName, buffer);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/LocalNameGenerator.java b/enigma/src/main/java/cuchaz/enigma/translation/LocalNameGenerator.java
new file mode 100644
index 0000000..18c966c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/LocalNameGenerator.java
@@ -0,0 +1,44 @@
+package cuchaz.enigma.translation;
+
+import cuchaz.enigma.translation.mapping.NameValidator;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+
+import java.util.Collection;
+import java.util.Locale;
+
+public class LocalNameGenerator {
+        public static String generateArgumentName(int index, TypeDescriptor desc, Collection<TypeDescriptor> arguments) {
+                boolean uniqueType = arguments.stream().filter(desc::equals).count() <= 1;
+                String translatedName;
+                int nameIndex = index + 1;
+                StringBuilder nameBuilder = new StringBuilder(getTypeName(desc));
+                if (!uniqueType || NameValidator.isReserved(nameBuilder.toString())) {
+                        nameBuilder.append(nameIndex);
+                }
+                translatedName = nameBuilder.toString();
+                return translatedName;
+        }
+
+        public static String generateLocalVariableName(int index, TypeDescriptor desc) {
+                int nameIndex = index + 1;
+                return getTypeName(desc) + nameIndex;
+        }
+
+        private static String getTypeName(TypeDescriptor desc) {
+                // Unfortunately each of these have different name getters, so they have different code paths
+                if (desc.isPrimitive()) {
+                        TypeDescriptor.Primitive argCls = desc.getPrimitive();
+                        return argCls.name().toLowerCase(Locale.ROOT);
+                } else if (desc.isArray()) {
+                        // List types would require this whole block again, so just go with aListx
+                        return "arr";
+                } else if (desc.isType()) {
+                        String typeName = desc.getTypeEntry().getSimpleName().replace("$", "");
+                        typeName = typeName.substring(0, 1).toLowerCase(Locale.ROOT) + typeName.substring(1);
+                        return typeName;
+                } else {
+                        System.err.println("Encountered invalid argument type descriptor " + desc.toString());
+                        return "var";
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/MappingTranslator.java b/enigma/src/main/java/cuchaz/enigma/translation/MappingTranslator.java
new file mode 100644
index 0000000..529d0ed
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/MappingTranslator.java
@@ -0,0 +1,24 @@
+package cuchaz.enigma.translation;
+
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.EntryMap;
+
+public class MappingTranslator implements Translator {
+        private final EntryMap<EntryMapping> mappings;
+        private final EntryResolver resolver;
+
+        public MappingTranslator(EntryMap<EntryMapping> mappings, EntryResolver resolver) {
+                this.mappings = mappings;
+                this.resolver = resolver;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public <T extends Translatable> T translate(T translatable) {
+                if (translatable == null) {
+                        return null;
+                }
+                return (T) translatable.translate(this, resolver, mappings);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/ProposingTranslator.java b/enigma/src/main/java/cuchaz/enigma/translation/ProposingTranslator.java
new file mode 100644
index 0000000..97866e9
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/ProposingTranslator.java
@@ -0,0 +1,51 @@
+package cuchaz.enigma.translation;
+
+import cuchaz.enigma.api.service.NameProposalService;
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+import cuchaz.enigma.translation.mapping.ResolutionStrategy;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+public class ProposingTranslator implements Translator {
+        private final EntryRemapper mapper;
+        private final NameProposalService[] nameProposalServices;
+
+        public ProposingTranslator(EntryRemapper mapper, NameProposalService[] nameProposalServices) {
+                this.mapper = mapper;
+                this.nameProposalServices = nameProposalServices;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public <T extends Translatable> T translate(T translatable) {
+                if (translatable == null) {
+                        return null;
+                }
+
+                T deobfuscated = mapper.deobfuscate(translatable);
+
+                if (translatable instanceof Entry && ((Entry) deobfuscated).getName().equals(((Entry<?>) translatable).getName())) {
+                        return mapper.getObfResolver()
+                                        .resolveEntry((Entry<?>) translatable, ResolutionStrategy.RESOLVE_ROOT)
+                                        .stream()
+                                        .map(this::proposeName)
+                                        .filter(Optional::isPresent)
+                                        .map(Optional::get)
+                                        .findFirst()
+                                        .map(newName -> (T) ((Entry) deobfuscated).withName(newName))
+                                        .orElse(deobfuscated);
+                }
+
+                return deobfuscated;
+        }
+
+        private Optional<String> proposeName(Entry<?> entry) {
+                return Arrays.stream(nameProposalServices)
+                                .map(service -> service.proposeName(entry, mapper))
+                                .filter(Optional::isPresent)
+                                .map(Optional::get)
+                                .findFirst();
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/SignatureUpdater.java b/enigma/src/main/java/cuchaz/enigma/translation/SignatureUpdater.java
new file mode 100644
index 0000000..3783053
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/SignatureUpdater.java
@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * 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;
+
+import com.google.common.collect.Lists;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.List;
+
+public class SignatureUpdater {
+
+        public static String update(String signature, ClassNameUpdater updater) {
+                try {
+                        StringBuilder buf = new StringBuilder();
+
+                        // read the signature character-by-character
+                        StringReader reader = new StringReader(signature);
+                        int i;
+                        while ((i = reader.read()) != -1) {
+                                char c = (char) i;
+
+                                // does this character start a class name?
+                                if (c == 'L') {
+                                        // update the class name and add it to the buffer
+                                        buf.append('L');
+                                        String className = readClass(reader);
+                                        if (className == null) {
+                                                throw new IllegalArgumentException("Malformed signature: " + signature);
+                                        }
+                                        buf.append(updater.update(className));
+                                        buf.append(';');
+                                } else {
+                                        // copy the character into the buffer
+                                        buf.append(c);
+                                }
+                        }
+
+                        return buf.toString();
+                } catch (IOException ex) {
+                        // I'm pretty sure a StringReader will never throw one of these
+                        throw new Error(ex);
+                }
+        }
+
+        private static String readClass(StringReader reader) throws IOException {
+                // read all the characters in the buffer until we hit a ';'
+                // remember to treat generics correctly
+                StringBuilder buf = new StringBuilder();
+                int depth = 0;
+                int i;
+                while ((i = reader.read()) != -1) {
+                        char c = (char) i;
+
+                        if (c == '<') {
+                                depth++;
+                        } else if (c == '>') {
+                                depth--;
+                        } else if (depth == 0) {
+                                if (c == ';') {
+                                        return buf.toString();
+                                } else {
+                                        buf.append(c);
+                                }
+                        }
+                }
+
+                return null;
+        }
+
+        public static List<String> getClasses(String signature) {
+                final List<String> classNames = Lists.newArrayList();
+                update(signature, className -> {
+                        classNames.add(className);
+                        return className;
+                });
+                return classNames;
+        }
+
+        public interface ClassNameUpdater {
+                String update(String className);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/Translatable.java b/enigma/src/main/java/cuchaz/enigma/translation/Translatable.java
new file mode 100644
index 0000000..0370ef1
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/Translatable.java
@@ -0,0 +1,9 @@
+package cuchaz.enigma.translation;
+
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.EntryMap;
+
+public interface Translatable {
+        Translatable translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/TranslationDirection.java b/enigma/src/main/java/cuchaz/enigma/translation/TranslationDirection.java
new file mode 100644
index 0000000..2ecb30b
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/TranslationDirection.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * 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;
+
+public enum TranslationDirection {
+
+        DEOBFUSCATING {
+                @Override
+                public <T> T choose(T deobfChoice, T obfChoice) {
+                        if (deobfChoice == null) {
+                                return obfChoice;
+                        }
+                        return deobfChoice;
+                }
+        },
+        OBFUSCATING {
+                @Override
+                public <T> T choose(T deobfChoice, T obfChoice) {
+                        if (obfChoice == null) {
+                                return deobfChoice;
+                        }
+                        return obfChoice;
+                }
+        };
+
+        public abstract <T> T choose(T deobfChoice, T obfChoice);
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/Translator.java b/enigma/src/main/java/cuchaz/enigma/translation/Translator.java
new file mode 100644
index 0000000..c70141f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/Translator.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * 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;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public interface Translator {
+        <T extends Translatable> T translate(T translatable);
+
+        default <T extends Translatable> Collection<T> translate(Collection<T> translatable) {
+                return translatable.stream()
+                                .map(this::translate)
+                                .collect(Collectors.toList());
+        }
+
+        default <T extends Translatable> Set<T> translate(Set<T> translatable) {
+                return translatable.stream()
+                                .map(this::translate)
+                                .collect(Collectors.toSet());
+        }
+
+        default <T extends Translatable, V> Map<T, V> translateKeys(Map<T, V> translatable) {
+                Map<T, V> result = new HashMap<>(translatable.size());
+                for (Map.Entry<T, V> entry : translatable.entrySet()) {
+                        result.put(translate(entry.getKey()), entry.getValue());
+                }
+                return result;
+        }
+
+        default <K extends Translatable, V extends Translatable> Map<K, V> translate(Map<K, V> translatable) {
+                Map<K, V> result = new HashMap<>(translatable.size());
+                for (Map.Entry<K, V> entry : translatable.entrySet()) {
+                        result.put(translate(entry.getKey()), translate(entry.getValue()));
+                }
+                return result;
+        }
+
+        default <K extends Translatable, V extends Translatable> Multimap<K, V> translate(Multimap<K, V> translatable) {
+                Multimap<K, V> result = HashMultimap.create(translatable.size(), 1);
+                for (Map.Entry<K, Collection<V>> entry : translatable.asMap().entrySet()) {
+                        result.putAll(translate(entry.getKey()), translate(entry.getValue()));
+                }
+                return result;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/VoidTranslator.java b/enigma/src/main/java/cuchaz/enigma/translation/VoidTranslator.java
new file mode 100644
index 0000000..c010833
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/VoidTranslator.java
@@ -0,0 +1,10 @@
+package cuchaz.enigma.translation;
+
+public enum VoidTranslator implements Translator {
+        INSTANCE;
+
+        @Override
+        public <T extends Translatable> T translate(T translatable) {
+                return translatable;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/AccessModifier.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/AccessModifier.java
new file mode 100644
index 0000000..5b79b79
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/AccessModifier.java
@@ -0,0 +1,25 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryMap.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryMap.java
new file mode 100644
index 0000000..e1a3253
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryMap.java
@@ -0,0 +1,24 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java
new file mode 100644
index 0000000..c607817
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java
@@ -0,0 +1,75 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java
new file mode 100644
index 0000000..1dd7eac
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java
@@ -0,0 +1,104 @@
+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.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/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryResolver.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryResolver.java
new file mode 100644
index 0000000..521f72d
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryResolver.java
@@ -0,0 +1,41 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/IllegalNameException.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/IllegalNameException.java
new file mode 100644
index 0000000..a7f83cd
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/IllegalNameException.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * 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;
+
+public class IllegalNameException extends RuntimeException {
+
+        private String name;
+        private String reason;
+
+        public IllegalNameException(String name, String reason) {
+                this.name = name;
+                this.reason = reason;
+        }
+
+        public String getReason() {
+                return this.reason;
+        }
+
+        @Override
+        public String getMessage() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("Illegal name: ");
+                buf.append(this.name);
+                if (this.reason != null) {
+                        buf.append(" because ");
+                        buf.append(this.reason);
+                }
+                return buf.toString();
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java
new file mode 100644
index 0000000..78231dd
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java
@@ -0,0 +1,227 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingDelta.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingDelta.java
new file mode 100644
index 0000000..1407bb6
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingDelta.java
@@ -0,0 +1,54 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingOperations.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingOperations.java
new file mode 100644
index 0000000..2c03748
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingOperations.java
@@ -0,0 +1,71 @@
+package cuchaz.enigma.translation.mapping;
+
+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.MappingTranslator;
+import cuchaz.enigma.translation.Translator;
+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.util.HashSet;
+import java.util.Set;
+
+public class MappingOperations {
+    public static EntryTree<EntryMapping> invert(EntryTree<EntryMapping> mappings) {
+        Translator translator = new MappingTranslator(mappings, VoidEntryResolver.INSTANCE);
+        EntryTree<EntryMapping> result = new HashEntryTree<>();
+
+        for (EntryTreeNode<EntryMapping> node : mappings) {
+            Entry<?> leftEntry = node.getEntry();
+            EntryMapping leftMapping = node.getValue();
+
+            if (!(leftEntry instanceof ClassEntry || leftEntry instanceof MethodEntry || leftEntry instanceof FieldEntry)) {
+                result.insert(translator.translate(leftEntry), leftMapping);
+                continue;
+            }
+
+            Entry<?> rightEntry = translator.translate(leftEntry);
+
+            result.insert(rightEntry, leftMapping == null ? null : leftMapping.withName(leftEntry.getName()));
+        }
+
+        return result;
+    }
+
+    public static EntryTree<EntryMapping> compose(EntryTree<EntryMapping> left, EntryTree<EntryMapping> right, boolean keepLeftOnly, boolean keepRightOnly) {
+        Translator leftTranslator = new MappingTranslator(left, VoidEntryResolver.INSTANCE);
+        EntryTree<EntryMapping> result = new HashEntryTree<>();
+        Set<Entry<?>> addedMappings = new HashSet<>();
+
+        for (EntryTreeNode<EntryMapping> node : left) {
+            Entry<?> leftEntry = node.getEntry();
+            EntryMapping leftMapping = node.getValue();
+
+            Entry<?> rightEntry = leftTranslator.translate(leftEntry);
+
+            EntryMapping rightMapping = right.get(rightEntry);
+            if (rightMapping != null) {
+                result.insert(leftEntry, rightMapping);
+                addedMappings.add(rightEntry);
+            } else if (keepLeftOnly) {
+                result.insert(leftEntry, leftMapping);
+            }
+        }
+
+        if (keepRightOnly) {
+            Translator leftInverseTranslator = new MappingTranslator(invert(left), VoidEntryResolver.INSTANCE);
+            for (EntryTreeNode<EntryMapping> node : right) {
+                Entry<?> rightEntry = node.getEntry();
+                EntryMapping rightMapping = node.getValue();
+
+                if (!addedMappings.contains(rightEntry)) {
+                    result.insert(leftInverseTranslator.translate(rightEntry), rightMapping);
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingPair.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingPair.java
new file mode 100644
index 0000000..5d39e3d
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingPair.java
@@ -0,0 +1,32 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingValidator.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingValidator.java
new file mode 100644
index 0000000..ae615da
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingValidator.java
@@ -0,0 +1,75 @@
+package cuchaz.enigma.translation.mapping;
+
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.analysis.index.JarIndex;
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java
new file mode 100644
index 0000000..5d9794f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java
@@ -0,0 +1,99 @@
+/*******************************************************************************
+ * 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/enigma/src/main/java/cuchaz/enigma/translation/mapping/NameValidator.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/NameValidator.java
new file mode 100644
index 0000000..74ba633
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/NameValidator.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * 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 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/enigma/src/main/java/cuchaz/enigma/translation/mapping/ResolutionStrategy.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/ResolutionStrategy.java
new file mode 100644
index 0000000..1c28e02
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/ResolutionStrategy.java
@@ -0,0 +1,6 @@
+package cuchaz.enigma.translation.mapping;
+
+public enum ResolutionStrategy {
+        RESOLVE_ROOT,
+        RESOLVE_CLOSEST
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/VoidEntryResolver.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/VoidEntryResolver.java
new file mode 100644
index 0000000..2eab55f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/VoidEntryResolver.java
@@ -0,0 +1,27 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/LfPrintWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/LfPrintWriter.java
new file mode 100644
index 0000000..441949c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/LfPrintWriter.java
@@ -0,0 +1,16 @@
+package cuchaz.enigma.translation.mapping.serde;
+
+import java.io.PrintWriter;
+import java.io.Writer;
+
+public class LfPrintWriter extends PrintWriter {
+    public LfPrintWriter(Writer out) {
+        super(out);
+    }
+
+    @Override
+    public void println() {
+        // https://stackoverflow.com/a/14749004
+        write('\n');
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFileNameFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFileNameFormat.java
new file mode 100644
index 0000000..9bc013c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFileNameFormat.java
@@ -0,0 +1,10 @@
+package cuchaz.enigma.translation.mapping.serde;
+
+import com.google.gson.annotations.SerializedName;
+
+public enum MappingFileNameFormat {
+        @SerializedName("by_obf")
+        BY_OBF,
+        @SerializedName("by_deobf")
+        BY_DEOBF
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
new file mode 100644
index 0000000..ca275eb
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
@@ -0,0 +1,65 @@
+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.serde.enigma.EnigmaMappingsReader;
+import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsWriter;
+import cuchaz.enigma.translation.mapping.serde.proguard.ProguardMappingsReader;
+import cuchaz.enigma.translation.mapping.serde.srg.SrgMappingsWriter;
+import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsReader;
+import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsWriter;
+import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Reader;
+import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer;
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java
new file mode 100644
index 0000000..7c8f6cc
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java
@@ -0,0 +1,51 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingParseException.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingParseException.java
new file mode 100644
index 0000000..9d04b97
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingParseException.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * 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.serde;
+
+import java.io.File;
+import java.util.function.Supplier;
+
+public class MappingParseException extends Exception {
+
+        private int line;
+        private String message;
+        private String filePath;
+
+        public MappingParseException(File file, int line, String message) {
+                this.line = line;
+                this.message = message;
+                filePath = file.getAbsolutePath();
+        }
+
+        public MappingParseException(Supplier<String> filenameProvider, int line, String message) {
+                this.line = line;
+                this.message = message;
+                filePath = filenameProvider.get();
+        }
+
+        @Override
+        public String getMessage() {
+                return "Line " + line + ": " + message + " in file " + filePath;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingSaveParameters.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingSaveParameters.java
new file mode 100644
index 0000000..e78fd95
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingSaveParameters.java
@@ -0,0 +1,16 @@
+package cuchaz.enigma.translation.mapping.serde;
+
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsReader.java
new file mode 100644
index 0000000..2f01375
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsReader.java
@@ -0,0 +1,12 @@
+package cuchaz.enigma.translation.mapping.serde;
+
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsWriter.java
new file mode 100644
index 0000000..68a8dbb
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsWriter.java
@@ -0,0 +1,16 @@
+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.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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java
new file mode 100644
index 0000000..79587a0
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java
@@ -0,0 +1,30 @@
+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;
+
+public final class RawEntryMapping {
+        private final String targetName;
+        private final AccessModifier access;
+        private List<String> javadocs = new ArrayList<>();
+
+        public RawEntryMapping(String targetName) {
+                this(targetName, null);
+        }
+
+        public RawEntryMapping(String targetName, AccessModifier access) {
+                this.access = access;
+                this.targetName = targetName;
+        }
+
+        public void addJavadocLine(String line) {
+                javadocs.add(line);
+        }
+
+        public EntryMapping bake() {
+                return new EntryMapping(targetName, access, javadocs.isEmpty() ? null : String.join("\n", javadocs));
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaFormat.java
new file mode 100644
index 0000000..210d328
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaFormat.java
@@ -0,0 +1,9 @@
+package cuchaz.enigma.translation.mapping.serde.enigma;
+
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java
new file mode 100644
index 0000000..30de85f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java
@@ -0,0 +1,322 @@
+package cuchaz.enigma.translation.mapping.serde.enigma;
+
+import com.google.common.base.Charsets;
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import cuchaz.enigma.translation.mapping.AccessModifier;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.MappingPair;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.serde.MappingHelper;
+import cuchaz.enigma.translation.mapping.serde.MappingsReader;
+import cuchaz.enigma.translation.mapping.serde.RawEntryMapping;
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java
new file mode 100644
index 0000000..7570d4b
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java
@@ -0,0 +1,318 @@
+/*******************************************************************************
+ * 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.enigma;
+
+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.serde.MappingFileNameFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.VoidEntryResolver;
+import cuchaz.enigma.translation.mapping.serde.LfPrintWriter;
+import cuchaz.enigma.translation.mapping.serde.MappingHelper;
+import cuchaz.enigma.translation.mapping.serde.MappingsWriter;
+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;
+
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/proguard/ProguardMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/proguard/ProguardMappingsReader.java
new file mode 100644
index 0000000..034fb41
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/proguard/ProguardMappingsReader.java
@@ -0,0 +1,135 @@
+package cuchaz.enigma.translation.mapping.serde.proguard;
+
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.mapping.MappingOperations;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.serde.MappingsReader;
+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 MappingOperations.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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java
new file mode 100644
index 0000000..9c9f103
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java
@@ -0,0 +1,119 @@
+package cuchaz.enigma.translation.mapping.serde.srg;
+
+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.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.VoidEntryResolver;
+import cuchaz.enigma.translation.mapping.serde.LfPrintWriter;
+import cuchaz.enigma.translation.mapping.serde.MappingsWriter;
+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 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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java
new file mode 100644
index 0000000..f3c66df
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java
@@ -0,0 +1,116 @@
+package cuchaz.enigma.translation.mapping.serde.tiny;
+
+import com.google.common.base.Charsets;
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.MappingPair;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.serde.MappingsReader;
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsWriter.java
new file mode 100644
index 0000000..4f78e6f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsWriter.java
@@ -0,0 +1,149 @@
+package cuchaz.enigma.translation.mapping.serde.tiny;
+
+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.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.VoidEntryResolver;
+import cuchaz.enigma.translation.mapping.serde.MappingsWriter;
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java
new file mode 100644
index 0000000..dc25569
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java
@@ -0,0 +1,296 @@
+package cuchaz.enigma.translation.mapping.serde.tinyv2;
+
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.MappingPair;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.serde.MappingsReader;
+import cuchaz.enigma.translation.mapping.serde.RawEntryMapping;
+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 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;
+
+public 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(), "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/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Writer.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Writer.java
new file mode 100644
index 0000000..5546b2f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Writer.java
@@ -0,0 +1,172 @@
+package cuchaz.enigma.translation.mapping.serde.tinyv2;
+
+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.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.serde.LfPrintWriter;
+import cuchaz.enigma.translation.mapping.serde.MappingHelper;
+import cuchaz.enigma.translation.mapping.serde.MappingsWriter;
+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.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/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/DeltaTrackingTree.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/DeltaTrackingTree.java
new file mode 100644
index 0000000..255fa5f
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/DeltaTrackingTree.java
@@ -0,0 +1,110 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTree.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTree.java
new file mode 100644
index 0000000..daaefcc
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTree.java
@@ -0,0 +1,26 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTreeNode.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTreeNode.java
new file mode 100644
index 0000000..affcd50
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTreeNode.java
@@ -0,0 +1,40 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/HashEntryTree.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/HashEntryTree.java
new file mode 100644
index 0000000..570941c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/HashEntryTree.java
@@ -0,0 +1,188 @@
+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/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/HashTreeNode.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/HashTreeNode.java
new file mode 100644
index 0000000..0a990bd
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/tree/HashTreeNode.java
@@ -0,0 +1,75 @@
+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();
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/AccessFlags.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/AccessFlags.java
new file mode 100644
index 0000000..b280eef
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/AccessFlags.java
@@ -0,0 +1,116 @@
+package cuchaz.enigma.translation.representation;
+
+import cuchaz.enigma.analysis.Access;
+import org.objectweb.asm.Opcodes;
+
+import java.lang.reflect.Modifier;
+
+public class AccessFlags {
+        public static final AccessFlags PRIVATE = new AccessFlags(Opcodes.ACC_PRIVATE);
+        public static final AccessFlags PUBLIC = new AccessFlags(Opcodes.ACC_PUBLIC);
+
+        private int flags;
+
+        public AccessFlags(int flags) {
+                this.flags = flags;
+        }
+
+        public boolean isPrivate() {
+                return Modifier.isPrivate(this.flags);
+        }
+
+        public boolean isProtected() {
+                return Modifier.isProtected(this.flags);
+        }
+
+        public boolean isPublic() {
+                return Modifier.isPublic(this.flags);
+        }
+
+        public boolean isSynthetic() {
+                return (this.flags & Opcodes.ACC_SYNTHETIC) != 0;
+        }
+
+        public boolean isStatic() {
+                return Modifier.isStatic(this.flags);
+        }
+
+        public boolean isEnum() {
+                return (flags & Opcodes.ACC_ENUM) != 0;
+        }
+
+        public boolean isBridge() {
+                return (flags & Opcodes.ACC_BRIDGE) != 0;
+        }
+
+        public boolean isFinal() {
+                return (flags & Opcodes.ACC_FINAL) != 0;
+        }
+
+        public boolean isInterface() {
+                return (flags & Opcodes.ACC_INTERFACE) != 0;
+        }
+
+        public AccessFlags setPrivate() {
+                this.setVisibility(Opcodes.ACC_PRIVATE);
+                return this;
+        }
+
+        public AccessFlags setProtected() {
+                this.setVisibility(Opcodes.ACC_PROTECTED);
+                return this;
+        }
+
+        public AccessFlags setPublic() {
+                this.setVisibility(Opcodes.ACC_PUBLIC);
+                return this;
+        }
+
+        public AccessFlags setBridge() {
+                flags |= Opcodes.ACC_BRIDGE;
+                return this;
+        }
+
+        @Deprecated
+        public AccessFlags setBridged() {
+                return setBridge();
+        }
+
+        public void setVisibility(int visibility) {
+                this.resetVisibility();
+                this.flags |= visibility;
+        }
+
+        private void resetVisibility() {
+                this.flags &= ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_PUBLIC);
+        }
+
+        public int getFlags() {
+                return this.flags;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                return obj instanceof AccessFlags && ((AccessFlags) obj).flags == flags;
+        }
+
+        @Override
+        public int hashCode() {
+                return flags;
+        }
+
+        @Override
+        public String toString() {
+                StringBuilder builder = new StringBuilder(Access.get(this).toString().toLowerCase());
+                if (isStatic()) {
+                        builder.append(" static");
+                }
+                if (isSynthetic()) {
+                        builder.append(" synthetic");
+                }
+                if (isBridge()) {
+                        builder.append(" bridge");
+                }
+                return builder.toString();
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/Lambda.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/Lambda.java
new file mode 100644
index 0000000..ad9389c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/Lambda.java
@@ -0,0 +1,105 @@
+package cuchaz.enigma.translation.representation;
+
+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.mapping.ResolutionStrategy;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import cuchaz.enigma.translation.representation.entry.ParentedEntry;
+
+import java.util.Objects;
+
+public class Lambda implements Translatable {
+        private final String invokedName;
+        private final MethodDescriptor invokedType;
+        private final MethodDescriptor samMethodType;
+        private final ParentedEntry<?> implMethod;
+        private final MethodDescriptor instantiatedMethodType;
+
+        public Lambda(String invokedName, MethodDescriptor invokedType, MethodDescriptor samMethodType, ParentedEntry<?> implMethod, MethodDescriptor instantiatedMethodType) {
+                this.invokedName = invokedName;
+                this.invokedType = invokedType;
+                this.samMethodType = samMethodType;
+                this.implMethod = implMethod;
+                this.instantiatedMethodType = instantiatedMethodType;
+        }
+
+        @Override
+        public Lambda translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+                MethodEntry samMethod = new MethodEntry(getInterface(), invokedName, samMethodType);
+                EntryMapping samMethodMapping = resolveMapping(resolver, mappings, samMethod);
+
+                return new Lambda(
+                        samMethodMapping != null ? samMethodMapping.getTargetName() : invokedName,
+                        invokedType.translate(translator, resolver, mappings),
+                        samMethodType.translate(translator, resolver, mappings),
+                        implMethod.translate(translator, resolver, mappings),
+                        instantiatedMethodType.translate(translator, resolver, mappings)
+                );
+        }
+
+        private EntryMapping resolveMapping(EntryResolver resolver, EntryMap<EntryMapping> mappings, MethodEntry methodEntry) {
+                for (MethodEntry entry : resolver.resolveEntry(methodEntry, ResolutionStrategy.RESOLVE_ROOT)) {
+                        EntryMapping mapping = mappings.get(entry);
+                        if (mapping != null) {
+                                return mapping;
+                        }
+                }
+                return null;
+        }
+
+        public ClassEntry getInterface() {
+                return invokedType.getReturnDesc().getTypeEntry();
+        }
+
+        public String getInvokedName() {
+                return invokedName;
+        }
+
+        public MethodDescriptor getInvokedType() {
+                return invokedType;
+        }
+
+        public MethodDescriptor getSamMethodType() {
+                return samMethodType;
+        }
+
+        public ParentedEntry<?> getImplMethod() {
+                return implMethod;
+        }
+
+        public MethodDescriptor getInstantiatedMethodType() {
+                return instantiatedMethodType;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                Lambda lambda = (Lambda) o;
+                return Objects.equals(invokedName, lambda.invokedName) &&
+                        Objects.equals(invokedType, lambda.invokedType) &&
+                        Objects.equals(samMethodType, lambda.samMethodType) &&
+                        Objects.equals(implMethod, lambda.implMethod) &&
+                        Objects.equals(instantiatedMethodType, lambda.instantiatedMethodType);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(invokedName, invokedType, samMethodType, implMethod, instantiatedMethodType);
+        }
+
+        @Override
+        public String toString() {
+                return "Lambda{" +
+                        "invokedName='" + invokedName + '\'' +
+                        ", invokedType=" + invokedType +
+                        ", samMethodType=" + samMethodType +
+                        ", implMethod=" + implMethod +
+                        ", instantiatedMethodType=" + instantiatedMethodType +
+                        '}';
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/MethodDescriptor.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/MethodDescriptor.java
new file mode 100644
index 0000000..03c8686
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/MethodDescriptor.java
@@ -0,0 +1,132 @@
+/*******************************************************************************
+ * 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.representation;
+
+import com.google.common.collect.Lists;
+import cuchaz.enigma.translation.Translatable;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.EntryMap;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+
+public class MethodDescriptor implements Translatable {
+
+        private List<TypeDescriptor> argumentDescs;
+        private TypeDescriptor returnDesc;
+
+        public MethodDescriptor(String desc) {
+                try {
+                        this.argumentDescs = Lists.newArrayList();
+                        int i = 0;
+                        while (i < desc.length()) {
+                                char c = desc.charAt(i);
+                                if (c == '(') {
+                                        assert (this.argumentDescs.isEmpty());
+                                        assert (this.returnDesc == null);
+                                        i++;
+                                } else if (c == ')') {
+                                        i++;
+                                        break;
+                                } else {
+                                        String type = TypeDescriptor.parseFirst(desc.substring(i));
+                                        this.argumentDescs.add(new TypeDescriptor(type));
+                                        i += type.length();
+                                }
+                        }
+                        this.returnDesc = new TypeDescriptor(TypeDescriptor.parseFirst(desc.substring(i)));
+                } catch (Exception ex) {
+                        throw new IllegalArgumentException("Unable to parse method descriptor: " + desc, ex);
+                }
+        }
+
+        public MethodDescriptor(List<TypeDescriptor> argumentDescs, TypeDescriptor returnDesc) {
+                this.argumentDescs = argumentDescs;
+                this.returnDesc = returnDesc;
+        }
+
+        public List<TypeDescriptor> getArgumentDescs() {
+                return this.argumentDescs;
+        }
+
+        public TypeDescriptor getReturnDesc() {
+                return this.returnDesc;
+        }
+
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("(");
+                for (TypeDescriptor desc : this.argumentDescs) {
+                        buf.append(desc);
+                }
+                buf.append(")");
+                buf.append(this.returnDesc);
+                return buf.toString();
+        }
+
+        public Iterable<TypeDescriptor> types() {
+                List<TypeDescriptor> descs = Lists.newArrayList();
+                descs.addAll(this.argumentDescs);
+                descs.add(this.returnDesc);
+                return descs;
+        }
+
+        @Override
+        public boolean equals(Object other) {
+                return other instanceof MethodDescriptor && equals((MethodDescriptor) other);
+        }
+
+        public boolean equals(MethodDescriptor other) {
+                return this.argumentDescs.equals(other.argumentDescs) && this.returnDesc.equals(other.returnDesc);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(this.argumentDescs.hashCode(), this.returnDesc.hashCode());
+        }
+
+        public boolean hasClass(ClassEntry classEntry) {
+                for (TypeDescriptor desc : types()) {
+                        if (desc.containsType() && desc.getTypeEntry().equals(classEntry)) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+        public MethodDescriptor remap(Function<String, String> remapper) {
+                List<TypeDescriptor> argumentDescs = new ArrayList<>(this.argumentDescs.size());
+                for (TypeDescriptor desc : this.argumentDescs) {
+                        argumentDescs.add(desc.remap(remapper));
+                }
+                return new MethodDescriptor(argumentDescs, returnDesc.remap(remapper));
+        }
+
+        @Override
+        public MethodDescriptor translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+                List<TypeDescriptor> translatedArguments = new ArrayList<>(argumentDescs.size());
+                for (TypeDescriptor argument : argumentDescs) {
+                        translatedArguments.add(translator.translate(argument));
+                }
+                return new MethodDescriptor(translatedArguments, translator.translate(returnDesc));
+        }
+
+        public boolean canConflictWith(MethodDescriptor descriptor) {
+                return descriptor.argumentDescs.equals(argumentDescs);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/Signature.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/Signature.java
new file mode 100644
index 0000000..424088a
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/Signature.java
@@ -0,0 +1,98 @@
+package cuchaz.enigma.translation.representation;
+
+import cuchaz.enigma.bytecode.translators.TranslationSignatureVisitor;
+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.ClassEntry;
+import org.objectweb.asm.signature.SignatureReader;
+import org.objectweb.asm.signature.SignatureVisitor;
+import org.objectweb.asm.signature.SignatureWriter;
+
+import java.util.function.Function;
+import java.util.regex.Pattern;
+
+public class Signature implements Translatable {
+        private static final Pattern OBJECT_PATTERN = Pattern.compile(".*:Ljava/lang/Object;:.*");
+
+        private final String signature;
+        private final boolean isType;
+
+        private Signature(String signature, boolean isType) {
+                if (signature != null && OBJECT_PATTERN.matcher(signature).matches()) {
+                        signature = signature.replaceAll(":Ljava/lang/Object;:", "::");
+                }
+
+                this.signature = signature;
+                this.isType = isType;
+        }
+
+        public static Signature createTypedSignature(String signature) {
+                if (signature != null && !signature.isEmpty()) {
+                        return new Signature(signature, true);
+                }
+                return new Signature(null, true);
+        }
+
+        public static Signature createSignature(String signature) {
+                if (signature != null && !signature.isEmpty()) {
+                        return new Signature(signature, false);
+                }
+                return new Signature(null, false);
+        }
+
+        public String getSignature() {
+                return signature;
+        }
+
+        public boolean isType() {
+                return isType;
+        }
+
+        public Signature remap(Function<String, String> remapper) {
+                if (signature == null) {
+                        return this;
+                }
+                SignatureWriter writer = new SignatureWriter();
+                SignatureVisitor visitor = new TranslationSignatureVisitor(remapper, writer);
+                if (isType) {
+                        new SignatureReader(signature).acceptType(visitor);
+                } else {
+                        new SignatureReader(signature).accept(visitor);
+                }
+                return new Signature(writer.toString(), isType);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj instanceof Signature) {
+                        Signature other = (Signature) obj;
+                        return (other.signature == null && signature == null || other.signature != null
+                                        && signature != null && other.signature.equals(signature))
+                                        && other.isType == this.isType;
+                }
+                return false;
+        }
+
+        @Override
+        public int hashCode() {
+                int hash = (isType ? 1 : 0) << 16;
+                if (signature != null) {
+                        hash |= signature.hashCode();
+                }
+
+                return hash;
+        }
+
+        @Override
+        public String toString() {
+                return signature;
+        }
+
+        @Override
+        public Translatable translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+                return remap(name -> translator.translate(new ClassEntry(name)).getFullName());
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/TypeDescriptor.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/TypeDescriptor.java
new file mode 100644
index 0000000..f7ba849
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/TypeDescriptor.java
@@ -0,0 +1,268 @@
+/*******************************************************************************
+ * 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.representation;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import cuchaz.enigma.translation.Translatable;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.EntryMap;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+
+import java.util.Map;
+import java.util.function.Function;
+
+public class TypeDescriptor implements Translatable {
+
+        protected final String desc;
+
+        public TypeDescriptor(String desc) {
+                Preconditions.checkNotNull(desc, "Desc cannot be null");
+
+                // don't deal with generics
+                // this is just for raw jvm types
+                if (desc.charAt(0) == 'T' || desc.indexOf('<') >= 0 || desc.indexOf('>') >= 0) {
+                        throw new IllegalArgumentException("don't use with generic types or templates: " + desc);
+                }
+
+                this.desc = desc;
+        }
+
+        public static String parseFirst(String in) {
+
+                if (in == null || in.length() <= 0) {
+                        throw new IllegalArgumentException("No desc to parse, input is empty!");
+                }
+
+                // read one desc from the input
+
+                char c = in.charAt(0);
+
+                // first check for void
+                if (c == 'V') {
+                        return "V";
+                }
+
+                // then check for primitives
+                Primitive primitive = Primitive.get(c);
+                if (primitive != null) {
+                        return in.substring(0, 1);
+                }
+
+                // then check for classes
+                if (c == 'L') {
+                        return readClass(in);
+                }
+
+                // then check for templates
+                if (c == 'T') {
+                        return readClass(in);
+                }
+
+                // then check for arrays
+                int dim = countArrayDimension(in);
+                if (dim > 0) {
+                        String arrayType = TypeDescriptor.parseFirst(in.substring(dim));
+                        return in.substring(0, dim + arrayType.length());
+                }
+
+                throw new IllegalArgumentException("don't know how to parse: " + in);
+        }
+
+        private static int countArrayDimension(String in) {
+                int i = 0;
+                while (i < in.length() && in.charAt(i) == '[')
+                        i++;
+                return i;
+        }
+
+        private static String readClass(String in) {
+                // read all the characters in the buffer until we hit a ';'
+                // include the parameters too
+                StringBuilder buf = new StringBuilder();
+                int depth = 0;
+                for (int i = 0; i < in.length(); i++) {
+                        char c = in.charAt(i);
+                        buf.append(c);
+
+                        if (c == '<') {
+                                depth++;
+                        } else if (c == '>') {
+                                depth--;
+                        } else if (depth == 0 && c == ';') {
+                                return buf.toString();
+                        }
+                }
+                return null;
+        }
+
+        public static TypeDescriptor of(String name) {
+                return new TypeDescriptor("L" + name + ";");
+        }
+
+        @Override
+        public String toString() {
+                return this.desc;
+        }
+
+        public boolean isVoid() {
+                return this.desc.length() == 1 && this.desc.charAt(0) == 'V';
+        }
+
+        public boolean isPrimitive() {
+                return this.desc.length() == 1 && Primitive.get(this.desc.charAt(0)) != null;
+        }
+
+        public Primitive getPrimitive() {
+                if (!isPrimitive()) {
+                        throw new IllegalStateException("not a primitive");
+                }
+                return Primitive.get(this.desc.charAt(0));
+        }
+
+        public boolean isType() {
+                return this.desc.charAt(0) == 'L' && this.desc.charAt(this.desc.length() - 1) == ';';
+        }
+
+        public ClassEntry getTypeEntry() {
+                if (isType()) {
+                        String name = this.desc.substring(1, this.desc.length() - 1);
+
+                        int pos = name.indexOf('<');
+                        if (pos >= 0) {
+                                // remove the parameters from the class name
+                                name = name.substring(0, pos);
+                        }
+
+                        return new ClassEntry(name);
+
+                } else if (isArray() && getArrayType().isType()) {
+                        return getArrayType().getTypeEntry();
+                } else {
+                        throw new IllegalStateException("desc doesn't have a class");
+                }
+        }
+
+        public boolean isArray() {
+                return this.desc.charAt(0) == '[';
+        }
+
+        public int getArrayDimension() {
+                if (!isArray()) {
+                        throw new IllegalStateException("not an array");
+                }
+                return countArrayDimension(this.desc);
+        }
+
+        public TypeDescriptor getArrayType() {
+                if (!isArray()) {
+                        throw new IllegalStateException("not an array");
+                }
+                return new TypeDescriptor(this.desc.substring(getArrayDimension()));
+        }
+
+        public boolean containsType() {
+                return isType() || (isArray() && getArrayType().containsType());
+        }
+
+        @Override
+        public boolean equals(Object other) {
+                return other instanceof TypeDescriptor && equals((TypeDescriptor) other);
+        }
+
+        public boolean equals(TypeDescriptor other) {
+                return this.desc.equals(other.desc);
+        }
+
+        @Override
+        public int hashCode() {
+                return this.desc.hashCode();
+        }
+
+        public TypeDescriptor remap(Function<String, String> remapper) {
+                String desc = this.desc;
+                if (isType() || (isArray() && containsType())) {
+                        String replacedName = remapper.apply(this.getTypeEntry().getFullName());
+                        if (replacedName != null) {
+                                if (this.isType()) {
+                                        desc = "L" + replacedName + ";";
+                                } else {
+                                        desc = getArrayPrefix(this.getArrayDimension()) + "L" + replacedName + ";";
+                                }
+                        }
+                }
+                return new TypeDescriptor(desc);
+        }
+
+        private static String getArrayPrefix(int dimension) {
+                StringBuilder buf = new StringBuilder();
+                for (int i = 0; i < dimension; i++) {
+                        buf.append("[");
+                }
+                return buf.toString();
+        }
+
+        public int getSize() {
+                switch (desc.charAt(0)) {
+                        case 'J':
+                        case 'D':
+                                if (desc.length() == 1) {
+                                        return 2;
+                                } else {
+                                        return 1;
+                                }
+                        default:
+                                return 1;
+                }
+        }
+
+        @Override
+        public Translatable translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+                return remap(name -> translator.translate(new ClassEntry(name)).getFullName());
+        }
+
+        public enum Primitive {
+                BYTE('B'),
+                CHARACTER('C'),
+                SHORT('S'),
+                INTEGER('I'),
+                LONG('J'),
+                FLOAT('F'),
+                DOUBLE('D'),
+                BOOLEAN('Z');
+
+                private static final Map<Character, Primitive> lookup;
+
+                static {
+                        lookup = Maps.newTreeMap();
+                        for (Primitive val : values()) {
+                                lookup.put(val.getCode(), val);
+                        }
+                }
+
+                private char code;
+
+                Primitive(char code) {
+                        this.code = code;
+                }
+
+                public static Primitive get(char code) {
+                        return lookup.get(code);
+                }
+
+                public char getCode() {
+                        return this.code;
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassDefEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassDefEntry.java
new file mode 100644
index 0000000..6930765
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassDefEntry.java
@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * 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.representation.entry;
+
+import com.google.common.base.Preconditions;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.Signature;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+
+public class ClassDefEntry extends ClassEntry implements DefEntry<ClassEntry> {
+        private final AccessFlags access;
+        private final Signature signature;
+        private final ClassEntry superClass;
+        private final ClassEntry[] interfaces;
+
+        public ClassDefEntry(String className, Signature signature, AccessFlags access, @Nullable ClassEntry superClass, ClassEntry[] interfaces) {
+                this(getOuterClass(className), getInnerName(className), signature, access, superClass, interfaces, null);
+        }
+
+        public ClassDefEntry(ClassEntry parent, String className, Signature signature, AccessFlags access, @Nullable ClassEntry superClass, ClassEntry[] interfaces) {
+                this(parent, className, signature, access, superClass, interfaces, null);
+        }
+
+        public ClassDefEntry(ClassEntry parent, String className, Signature signature, AccessFlags access, @Nullable ClassEntry superClass,
+                                                 ClassEntry[] interfaces, String javadocs) {
+                super(parent, className, javadocs);
+                Preconditions.checkNotNull(signature, "Class signature cannot be null");
+                Preconditions.checkNotNull(access, "Class access cannot be null");
+
+                this.signature = signature;
+                this.access = access;
+                this.superClass = superClass;
+                this.interfaces = interfaces != null ? interfaces : new ClassEntry[0];
+        }
+
+        public static ClassDefEntry parse(int access, String name, String signature, String superName, String[] interfaces) {
+                ClassEntry superClass = superName != null ? new ClassEntry(superName) : null;
+                ClassEntry[] interfaceClasses = Arrays.stream(interfaces).map(ClassEntry::new).toArray(ClassEntry[]::new);
+                return new ClassDefEntry(name, Signature.createSignature(signature), new AccessFlags(access), superClass, interfaceClasses);
+        }
+
+        public Signature getSignature() {
+                return signature;
+        }
+
+        @Override
+        public AccessFlags getAccess() {
+                return access;
+        }
+
+        @Nullable
+        public ClassEntry getSuperClass() {
+                return superClass;
+        }
+
+        public ClassEntry[] getInterfaces() {
+                return interfaces;
+        }
+
+        @Override
+        public ClassDefEntry translate(Translator translator, @Nullable EntryMapping mapping) {
+                Signature translatedSignature = translator.translate(signature);
+                String translatedName = mapping != null ? mapping.getTargetName() : name;
+                AccessFlags translatedAccess = mapping != null ? mapping.getAccessModifier().transform(access) : access;
+                ClassEntry translatedSuper = translator.translate(superClass);
+                ClassEntry[] translatedInterfaces = Arrays.stream(interfaces).map(translator::translate).toArray(ClassEntry[]::new);
+                String docs = mapping != null ? mapping.getJavadoc() : null;
+                return new ClassDefEntry(parent, translatedName, translatedSignature, translatedAccess, translatedSuper, translatedInterfaces, docs);
+        }
+
+        @Override
+        public ClassDefEntry withName(String name) {
+                return new ClassDefEntry(parent, name, signature, access, superClass, interfaces, javadocs);
+        }
+
+        @Override
+        public ClassDefEntry withParent(ClassEntry parent) {
+                return new ClassDefEntry(parent, name, signature, access, superClass, interfaces, javadocs);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassEntry.java
new file mode 100644
index 0000000..7d4b2ba
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassEntry.java
@@ -0,0 +1,214 @@
+/*******************************************************************************
+ * 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.representation.entry;
+
+import cuchaz.enigma.translation.mapping.IllegalNameException;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.NameValidator;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Objects;
+
+public class ClassEntry extends ParentedEntry<ClassEntry> implements Comparable<ClassEntry> {
+        private final String fullName;
+
+        public ClassEntry(String className) {
+                this(getOuterClass(className), getInnerName(className), null);
+        }
+
+        public ClassEntry(@Nullable ClassEntry parent, String className) {
+                this(parent, className, null);
+        }
+
+        public ClassEntry(@Nullable ClassEntry parent, String className, @Nullable String javadocs) {
+                super(parent, className, javadocs);
+                if (parent != null) {
+                        fullName = parent.getFullName() + "$" + name;
+                } else {
+                        fullName = name;
+                }
+
+                if (parent == null && className.indexOf('.') >= 0) {
+                        throw new IllegalArgumentException("Class name must be in JVM format. ie, path/to/package/class$inner : " + className);
+                }
+        }
+
+        @Override
+        public Class<ClassEntry> getParentType() {
+                return ClassEntry.class;
+        }
+
+        @Override
+        public String getName() {
+                return this.name;
+        }
+
+        public String getFullName() {
+                return fullName;
+        }
+
+        @Override
+        public ClassEntry translate(Translator translator, @Nullable EntryMapping mapping) {
+                if (name.charAt(0) == '[') {
+                        String translatedName = translator.translate(new TypeDescriptor(name)).toString();
+                        return new ClassEntry(parent, translatedName);
+                }
+
+                String translatedName = mapping != null ? mapping.getTargetName() : name;
+                String docs = mapping != null ? mapping.getJavadoc() : null;
+                return new ClassEntry(parent, translatedName, docs);
+        }
+
+        @Override
+        public ClassEntry getContainingClass() {
+                return this;
+        }
+
+        @Override
+        public int hashCode() {
+                return fullName.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object other) {
+                return other instanceof ClassEntry && equals((ClassEntry) other);
+        }
+
+        public boolean equals(ClassEntry other) {
+                return other != null && Objects.equals(parent, other.parent) && this.name.equals(other.name);
+        }
+
+        @Override
+        public boolean canConflictWith(Entry<?> entry) {
+                return true;
+        }
+
+        @Override
+        public void validateName(String name) throws IllegalNameException {
+                NameValidator.validateClassName(name);
+        }
+
+        @Override
+        public ClassEntry withName(String name) {
+                return new ClassEntry(parent, name, javadocs);
+        }
+
+        @Override
+        public ClassEntry withParent(ClassEntry parent) {
+                return new ClassEntry(parent, name, javadocs);
+        }
+
+        @Override
+        public String toString() {
+                return getFullName();
+        }
+
+        public String getPackageName() {
+                return getPackageName(fullName);
+        }
+
+        public String getSimpleName() {
+                int packagePos = name.lastIndexOf('/');
+                if (packagePos > 0) {
+                        return name.substring(packagePos + 1);
+                }
+                return name;
+        }
+
+        public boolean isInnerClass() {
+                return parent != null;
+        }
+
+        @Nullable
+        public ClassEntry getOuterClass() {
+                return parent;
+        }
+
+        @Nonnull
+        public ClassEntry getOutermostClass() {
+                if (parent == null) {
+                        return this;
+                }
+                return parent.getOutermostClass();
+        }
+
+        public ClassEntry buildClassEntry(List<ClassEntry> classChain) {
+                assert (classChain.contains(this));
+                StringBuilder buf = new StringBuilder();
+                for (ClassEntry chainEntry : classChain) {
+                        if (buf.length() == 0) {
+                                buf.append(chainEntry.getFullName());
+                        } else {
+                                buf.append("$");
+                                buf.append(chainEntry.getSimpleName());
+                        }
+
+                        if (chainEntry == this) {
+                                break;
+                        }
+                }
+                return new ClassEntry(buf.toString());
+        }
+
+        public boolean isJre() {
+                String packageName = getPackageName();
+                return packageName != null && (packageName.startsWith("java") || packageName.startsWith("javax"));
+        }
+
+        public static String getPackageName(String name) {
+                int pos = name.lastIndexOf('/');
+                if (pos > 0) {
+                        return name.substring(0, pos);
+                }
+                return null;
+        }
+
+        @Nullable
+        public static ClassEntry getOuterClass(String name) {
+                int index = name.lastIndexOf('$');
+                if (index >= 0) {
+                        return new ClassEntry(name.substring(0, index));
+                }
+                return null;
+        }
+
+        public static String getInnerName(String name) {
+                int innerClassPos = name.lastIndexOf('$');
+                if (innerClassPos > 0) {
+                        return name.substring(innerClassPos + 1);
+                }
+                return name;
+        }
+
+        @Override
+        public String getSourceRemapName() {
+                ClassEntry outerClass = getOuterClass();
+                if (outerClass != null) {
+                        return outerClass.getSourceRemapName() + "." + name;
+                }
+                return getSimpleName();
+        }
+
+        @Override
+        public int compareTo(ClassEntry entry) {
+                String fullName = getFullName();
+                String otherFullName = entry.getFullName();
+                if (fullName.length() != otherFullName.length()) {
+                        return fullName.length() - otherFullName.length();
+                }
+                return fullName.compareTo(otherFullName);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/DefEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/DefEntry.java
new file mode 100644
index 0000000..82536c7
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/DefEntry.java
@@ -0,0 +1,7 @@
+package cuchaz.enigma.translation.representation.entry;
+
+import cuchaz.enigma.translation.representation.AccessFlags;
+
+public interface DefEntry<P extends Entry<?>> extends Entry<P> {
+        AccessFlags getAccess();
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/Entry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/Entry.java
new file mode 100644
index 0000000..40bff31
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/Entry.java
@@ -0,0 +1,107 @@
+/*******************************************************************************
+ * 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.representation.entry;
+
+import cuchaz.enigma.translation.mapping.IllegalNameException;
+import cuchaz.enigma.translation.Translatable;
+import cuchaz.enigma.translation.mapping.NameValidator;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+
+public interface Entry<P extends Entry<?>> extends Translatable {
+        String getName();
+
+        String getJavadocs();
+
+        default String getSourceRemapName() {
+                return getName();
+        }
+
+        @Nullable
+        P getParent();
+
+        Class<P> getParentType();
+
+        Entry<P> withName(String name);
+
+        Entry<P> withParent(P parent);
+
+        boolean canConflictWith(Entry<?> entry);
+
+        @Nullable
+        default ClassEntry getContainingClass() {
+                P parent = getParent();
+                if (parent == null) {
+                        return null;
+                }
+                if (parent instanceof ClassEntry) {
+                        return (ClassEntry) parent;
+                }
+                return parent.getContainingClass();
+        }
+
+        default List<Entry<?>> getAncestry() {
+                P parent = getParent();
+                List<Entry<?>> entries = new ArrayList<>();
+                if (parent != null) {
+                        entries.addAll(parent.getAncestry());
+                }
+                entries.add(this);
+                return entries;
+        }
+
+        @Nullable
+        @SuppressWarnings("unchecked")
+        default <E extends Entry<?>> E findAncestor(Class<E> type) {
+                List<Entry<?>> ancestry = getAncestry();
+                for (int i = ancestry.size() - 1; i >= 0; i--) {
+                        Entry<?> ancestor = ancestry.get(i);
+                        if (type.isAssignableFrom(ancestor.getClass())) {
+                                return (E) ancestor;
+                        }
+                }
+                return null;
+        }
+
+        @SuppressWarnings("unchecked")
+        default <E extends Entry<?>> Entry<P> replaceAncestor(E target, E replacement) {
+                if (replacement.equals(target)) {
+                        return this;
+                }
+
+                if (equals(target)) {
+                        return (Entry<P>) replacement;
+                }
+
+                P parent = getParent();
+                if (parent == null) {
+                        return this;
+                }
+
+                return withParent((P) parent.replaceAncestor(target, replacement));
+        }
+
+        default void validateName(String name) throws IllegalNameException {
+                NameValidator.validateIdentifier(name);
+        }
+
+        @SuppressWarnings("unchecked")
+        @Nullable
+        default <C extends Entry<?>> Entry<C> castParent(Class<C> parentType) {
+                if (parentType.equals(getParentType())) {
+                        return (Entry<C>) this;
+                }
+                return null;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/FieldDefEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/FieldDefEntry.java
new file mode 100644
index 0000000..f9282b2
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/FieldDefEntry.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * 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.representation.entry;
+
+import com.google.common.base.Preconditions;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.Signature;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+
+import javax.annotation.Nullable;
+
+public class FieldDefEntry extends FieldEntry implements DefEntry<ClassEntry> {
+        private final AccessFlags access;
+        private final Signature signature;
+
+        public FieldDefEntry(ClassEntry owner, String name, TypeDescriptor desc, Signature signature, AccessFlags access) {
+                this(owner, name, desc, signature, access, null);
+        }
+
+        public FieldDefEntry(ClassEntry owner, String name, TypeDescriptor desc, Signature signature, AccessFlags access, String javadocs) {
+                super(owner, name, desc, javadocs);
+                Preconditions.checkNotNull(access, "Field access cannot be null");
+                Preconditions.checkNotNull(signature, "Field signature cannot be null");
+                this.access = access;
+                this.signature = signature;
+        }
+
+        public static FieldDefEntry parse(ClassEntry owner, int access, String name, String desc, String signature) {
+                return new FieldDefEntry(owner, name, new TypeDescriptor(desc), Signature.createTypedSignature(signature), new AccessFlags(access), null);
+        }
+
+        @Override
+        public AccessFlags getAccess() {
+                return access;
+        }
+
+        public Signature getSignature() {
+                return signature;
+        }
+
+        @Override
+        public FieldDefEntry translate(Translator translator, @Nullable EntryMapping mapping) {
+                TypeDescriptor translatedDesc = translator.translate(desc);
+                Signature translatedSignature = translator.translate(signature);
+                String translatedName = mapping != null ? mapping.getTargetName() : name;
+                AccessFlags translatedAccess = mapping != null ? mapping.getAccessModifier().transform(access) : access;
+                String docs = mapping != null ? mapping.getJavadoc() : null;
+                return new FieldDefEntry(parent, translatedName, translatedDesc, translatedSignature, translatedAccess, docs);
+        }
+
+        @Override
+        public FieldDefEntry withName(String name) {
+                return new FieldDefEntry(parent, name, desc, signature, access, javadocs);
+        }
+
+        @Override
+        public FieldDefEntry withParent(ClassEntry owner) {
+                return new FieldDefEntry(owner, this.name, this.desc, signature, access, javadocs);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/FieldEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/FieldEntry.java
new file mode 100644
index 0000000..0e47878
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/FieldEntry.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.representation.entry;
+
+import com.google.common.base.Preconditions;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+
+import javax.annotation.Nullable;
+import java.util.Objects;
+
+public class FieldEntry extends ParentedEntry<ClassEntry> implements Comparable<FieldEntry> {
+        protected final TypeDescriptor desc;
+
+        public FieldEntry(ClassEntry parent, String name, TypeDescriptor desc) {
+                this(parent, name, desc, null);
+        }
+
+        public FieldEntry(ClassEntry parent, String name, TypeDescriptor desc, String javadocs) {
+                super(parent, name, javadocs);
+
+                Preconditions.checkNotNull(parent, "Owner cannot be null");
+                Preconditions.checkNotNull(desc, "Field descriptor cannot be null");
+
+                this.desc = desc;
+        }
+
+        public static FieldEntry parse(String owner, String name, String desc) {
+                return new FieldEntry(new ClassEntry(owner), name, new TypeDescriptor(desc), null);
+        }
+
+        @Override
+        public Class<ClassEntry> getParentType() {
+                return ClassEntry.class;
+        }
+
+        public TypeDescriptor getDesc() {
+                return this.desc;
+        }
+
+        @Override
+        public FieldEntry withName(String name) {
+                return new FieldEntry(parent, name, desc, null);
+        }
+
+        @Override
+        public FieldEntry withParent(ClassEntry parent) {
+                return new FieldEntry(parent, this.name, this.desc, null);
+        }
+
+        @Override
+        protected FieldEntry translate(Translator translator, @Nullable EntryMapping mapping) {
+                String translatedName = mapping != null ? mapping.getTargetName() : name;
+                String docs = mapping != null ? mapping.getJavadoc() : null;
+                return new FieldEntry(parent, translatedName, translator.translate(desc), docs);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(this.parent, this.name, this.desc);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+                return other instanceof FieldEntry && equals((FieldEntry) other);
+        }
+
+        public boolean equals(FieldEntry other) {
+                return this.parent.equals(other.parent) && name.equals(other.name) && desc.equals(other.desc);
+        }
+
+        @Override
+        public boolean canConflictWith(Entry<?> entry) {
+                return entry instanceof FieldEntry && ((FieldEntry) entry).parent.equals(parent);
+        }
+
+        @Override
+        public String toString() {
+                return this.parent.getFullName() + "." + this.name + ":" + this.desc;
+        }
+
+        @Override
+        public int compareTo(FieldEntry entry) {
+                return (name + desc.toString()).compareTo(entry.name + entry.desc.toString());
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/LocalVariableDefEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/LocalVariableDefEntry.java
new file mode 100644
index 0000000..aad4236
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/LocalVariableDefEntry.java
@@ -0,0 +1,51 @@
+package cuchaz.enigma.translation.representation.entry;
+
+import com.google.common.base.Preconditions;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+
+import javax.annotation.Nullable;
+
+/**
+ * TypeDescriptor...
+ * Created by Thog
+ * 19/10/2016
+ */
+public class LocalVariableDefEntry extends LocalVariableEntry {
+        protected final TypeDescriptor desc;
+
+        public LocalVariableDefEntry(MethodEntry ownerEntry, int index, String name, boolean parameter, TypeDescriptor desc, String javadoc) {
+                super(ownerEntry, index, name, parameter, javadoc);
+                Preconditions.checkNotNull(desc, "Variable desc cannot be null");
+
+                this.desc = desc;
+        }
+
+        public TypeDescriptor getDesc() {
+                return desc;
+        }
+
+        @Override
+        public LocalVariableDefEntry translate(Translator translator, @Nullable EntryMapping mapping) {
+                TypeDescriptor translatedDesc = translator.translate(desc);
+                String translatedName = mapping != null ? mapping.getTargetName() : name;
+                String javadoc = mapping != null ? mapping.getJavadoc() : javadocs;
+                return new LocalVariableDefEntry(parent, index, translatedName, parameter, translatedDesc, javadoc);
+        }
+
+        @Override
+        public LocalVariableDefEntry withName(String name) {
+                return new LocalVariableDefEntry(parent, index, name, parameter, desc, javadocs);
+        }
+
+        @Override
+        public LocalVariableDefEntry withParent(MethodEntry entry) {
+                return new LocalVariableDefEntry(entry, index, name, parameter, desc, javadocs);
+        }
+
+        @Override
+        public String toString() {
+                return this.parent + "(" + this.index + ":" + this.name + ":" + this.desc + ")";
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/LocalVariableEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/LocalVariableEntry.java
new file mode 100644
index 0000000..3f98f03
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/LocalVariableEntry.java
@@ -0,0 +1,93 @@
+package cuchaz.enigma.translation.representation.entry;
+
+import com.google.common.base.Preconditions;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+
+import javax.annotation.Nullable;
+import java.util.Objects;
+
+/**
+ * TypeDescriptor...
+ * Created by Thog
+ * 19/10/2016
+ */
+public class LocalVariableEntry extends ParentedEntry<MethodEntry> implements Comparable<LocalVariableEntry> {
+
+        protected final int index;
+        protected final boolean parameter;
+
+        public LocalVariableEntry(MethodEntry parent, int index, String name, boolean parameter, String javadoc) {
+                super(parent, name, javadoc);
+
+                Preconditions.checkNotNull(parent, "Variable owner cannot be null");
+                Preconditions.checkArgument(index >= 0, "Index must be positive");
+
+                this.index = index;
+                this.parameter = parameter;
+        }
+
+        @Override
+        public Class<MethodEntry> getParentType() {
+                return MethodEntry.class;
+        }
+
+        public boolean isArgument() {
+                return this.parameter;
+        }
+
+        public int getIndex() {
+                return index;
+        }
+
+        @Override
+        public String getName() {
+                return this.name;
+        }
+
+        @Override
+        public LocalVariableEntry translate(Translator translator, @Nullable EntryMapping mapping) {
+                String translatedName = mapping != null ? mapping.getTargetName() : name;
+                String javadoc = mapping != null ? mapping.getJavadoc() : null;
+                return new LocalVariableEntry(parent, index, translatedName, parameter, javadoc);
+        }
+
+        @Override
+        public LocalVariableEntry withName(String name) {
+                return new LocalVariableEntry(parent, index, name, parameter, javadocs);
+        }
+
+        @Override
+        public LocalVariableEntry withParent(MethodEntry parent) {
+                return new LocalVariableEntry(parent, index, name, parameter, javadocs);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(this.parent, this.index);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+                return other instanceof LocalVariableEntry && equals((LocalVariableEntry) other);
+        }
+
+        public boolean equals(LocalVariableEntry other) {
+                return this.parent.equals(other.parent) && this.index == other.index;
+        }
+
+        @Override
+        public boolean canConflictWith(Entry<?> entry) {
+                return entry instanceof LocalVariableEntry && ((LocalVariableEntry) entry).parent.equals(parent);
+        }
+
+        @Override
+        public String toString() {
+                return this.parent + "(" + this.index + ":" + this.name + ")";
+        }
+
+        @Override
+        public int compareTo(LocalVariableEntry entry) {
+                return Integer.compare(index, entry.index);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/MethodDefEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/MethodDefEntry.java
new file mode 100644
index 0000000..4e75a5c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/MethodDefEntry.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * 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.representation.entry;
+
+import com.google.common.base.Preconditions;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.Signature;
+
+import javax.annotation.Nullable;
+
+public class MethodDefEntry extends MethodEntry implements DefEntry<ClassEntry> {
+        private final AccessFlags access;
+        private final Signature signature;
+
+        public MethodDefEntry(ClassEntry owner, String name, MethodDescriptor descriptor, Signature signature, AccessFlags access) {
+                this(owner, name, descriptor, signature, access, null);
+        }
+
+        public MethodDefEntry(ClassEntry owner, String name, MethodDescriptor descriptor, Signature signature, AccessFlags access, String docs) {
+                super(owner, name, descriptor, docs);
+                Preconditions.checkNotNull(access, "Method access cannot be null");
+                Preconditions.checkNotNull(signature, "Method signature cannot be null");
+                this.access = access;
+                this.signature = signature;
+        }
+
+        public static MethodDefEntry parse(ClassEntry owner, int access, String name, String desc, String signature) {
+                return new MethodDefEntry(owner, name, new MethodDescriptor(desc), Signature.createSignature(signature), new AccessFlags(access), null);
+        }
+
+        @Override
+        public AccessFlags getAccess() {
+                return access;
+        }
+
+        public Signature getSignature() {
+                return signature;
+        }
+
+        @Override
+        public MethodDefEntry translate(Translator translator, @Nullable EntryMapping mapping) {
+                MethodDescriptor translatedDesc = translator.translate(descriptor);
+                Signature translatedSignature = translator.translate(signature);
+                String translatedName = mapping != null ? mapping.getTargetName() : name;
+                AccessFlags translatedAccess = mapping != null ? mapping.getAccessModifier().transform(access) : access;
+                String docs = mapping != null ? mapping.getJavadoc() : null;
+                return new MethodDefEntry(parent, translatedName, translatedDesc, translatedSignature, translatedAccess, docs);
+        }
+
+        @Override
+        public MethodDefEntry withName(String name) {
+                return new MethodDefEntry(parent, name, descriptor, signature, access, javadocs);
+        }
+
+        @Override
+        public MethodDefEntry withParent(ClassEntry parent) {
+                return new MethodDefEntry(new ClassEntry(parent.getFullName()), name, descriptor, signature, access, javadocs);
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/MethodEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/MethodEntry.java
new file mode 100644
index 0000000..086a5c1
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/MethodEntry.java
@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * 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.representation.entry;
+
+import com.google.common.base.Preconditions;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+
+import javax.annotation.Nullable;
+import java.util.Objects;
+
+public class MethodEntry extends ParentedEntry<ClassEntry> implements Comparable<MethodEntry> {
+
+        protected final MethodDescriptor descriptor;
+
+        public MethodEntry(ClassEntry parent, String name, MethodDescriptor descriptor) {
+                this(parent, name, descriptor, null);
+        }
+
+        public MethodEntry(ClassEntry parent, String name, MethodDescriptor descriptor, String javadocs) {
+                super(parent, name, javadocs);
+
+                Preconditions.checkNotNull(parent, "Parent cannot be null");
+                Preconditions.checkNotNull(descriptor, "Method descriptor cannot be null");
+
+                this.descriptor = descriptor;
+        }
+
+        public static MethodEntry parse(String owner, String name, String desc) {
+                return new MethodEntry(new ClassEntry(owner), name, new MethodDescriptor(desc), null);
+        }
+
+        @Override
+        public Class<ClassEntry> getParentType() {
+                return ClassEntry.class;
+        }
+
+        public MethodDescriptor getDesc() {
+                return this.descriptor;
+        }
+
+        public boolean isConstructor() {
+                return name.equals("<init>") || name.equals("<clinit>");
+        }
+
+        @Override
+        public MethodEntry translate(Translator translator, @Nullable EntryMapping mapping) {
+                String translatedName = mapping != null ? mapping.getTargetName() : name;
+                String docs = mapping != null ? mapping.getJavadoc() : null;
+                return new MethodEntry(parent, translatedName, translator.translate(descriptor), docs);
+        }
+
+        @Override
+        public MethodEntry withName(String name) {
+                return new MethodEntry(parent, name, descriptor, javadocs);
+        }
+
+        @Override
+        public MethodEntry withParent(ClassEntry parent) {
+                return new MethodEntry(new ClassEntry(parent.getFullName()), name, descriptor, javadocs);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(this.parent, this.name, this.descriptor);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+                return other instanceof MethodEntry && equals((MethodEntry) other);
+        }
+
+        public boolean equals(MethodEntry other) {
+                return this.parent.equals(other.getParent()) && this.name.equals(other.getName()) && this.descriptor.equals(other.getDesc());
+        }
+
+        @Override
+        public boolean canConflictWith(Entry<?> entry) {
+                if (entry instanceof MethodEntry) {
+                        MethodEntry methodEntry = (MethodEntry) entry;
+                        return methodEntry.parent.equals(parent) && methodEntry.descriptor.canConflictWith(descriptor);
+                }
+                return false;
+        }
+
+        @Override
+        public String toString() {
+                return this.parent.getFullName() + "." + this.name + this.descriptor;
+        }
+
+        @Override
+        public int compareTo(MethodEntry entry) {
+                return (name + descriptor.toString()).compareTo(entry.name + entry.descriptor.toString());
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ParentedEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ParentedEntry.java
new file mode 100644
index 0000000..95be22c
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ParentedEntry.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * 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.representation.entry;
+
+import com.google.common.base.Preconditions;
+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.ResolutionStrategy;
+
+import javax.annotation.Nullable;
+
+public abstract class ParentedEntry<P extends Entry<?>> implements Entry<P> {
+        protected final P parent;
+        protected final String name;
+        protected final @Nullable String javadocs;
+
+        protected ParentedEntry(P parent, String name, String javadocs) {
+                this.parent = parent;
+                this.name = name;
+                this.javadocs = javadocs;
+
+                Preconditions.checkNotNull(name, "Name cannot be null");
+        }
+
+        @Override
+        public abstract ParentedEntry<P> withParent(P parent);
+
+        @Override
+        public abstract ParentedEntry<P> withName(String name);
+
+        protected abstract ParentedEntry<P> translate(Translator translator, @Nullable EntryMapping mapping);
+
+        @Override
+        public String getName() {
+                return name;
+        }
+
+        @Override
+        @Nullable
+        public P getParent() {
+                return parent;
+        }
+
+        @Nullable
+        @Override
+        public String getJavadocs() {
+                return javadocs;
+        }
+
+        @Override
+        public ParentedEntry<P> translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+                P parent = getParent();
+                EntryMapping mapping = resolveMapping(resolver, mappings);
+                if (parent == null) {
+                        return translate(translator, mapping);
+                }
+                P translatedParent = translator.translate(parent);
+                return withParent(translatedParent).translate(translator, mapping);
+        }
+
+        private EntryMapping resolveMapping(EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+                for (ParentedEntry<P> entry : resolver.resolveEntry(this, ResolutionStrategy.RESOLVE_ROOT)) {
+                        EntryMapping mapping = mappings.get(entry);
+                        if (mapping != null) {
+                                return mapping;
+                        }
+                }
+                return null;
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/utils/I18n.java b/enigma/src/main/java/cuchaz/enigma/utils/I18n.java
new file mode 100644
index 0000000..e18532b
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/utils/I18n.java
@@ -0,0 +1,95 @@
+package cuchaz.enigma.utils;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Maps;
+import com.google.common.reflect.ClassPath;
+import com.google.common.reflect.ClassPath.ResourceInfo;
+import com.google.gson.Gson;
+
+public class I18n {
+        public static final String DEFAULT_LANGUAGE = "en_us";
+        private static final Gson GSON = new Gson();
+        private static Map<String, String> translations = Maps.newHashMap();
+        private static Map<String, String> defaultTranslations = Maps.newHashMap();
+        private static Map<String, String> languageNames = Maps.newHashMap();
+        
+        static {
+                defaultTranslations = load(DEFAULT_LANGUAGE);
+                translations = defaultTranslations;
+        }
+        
+        @SuppressWarnings("unchecked")
+        public static Map<String, String> load(String language) {
+                try (InputStream inputStream = I18n.class.getResourceAsStream("/lang/" + language + ".json")) {
+                        if (inputStream != null) {
+                                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
+                                        return GSON.fromJson(reader, Map.class);
+                                }
+                        }
+                } catch (IOException e) {
+                        e.printStackTrace();
+                }
+                return Collections.emptyMap();
+        }
+        
+        public static String translate(String key) {
+                String value = translations.get(key);
+                if (value != null) {
+                        return value;
+                }
+                value = defaultTranslations.get(key);
+                if (value != null) {
+                        return value;
+                }
+                return key;
+        }
+        
+        public static String getLanguageName(String language) {
+                return languageNames.get(language);
+        }
+        
+        public static void setLanguage(String language) {
+                translations = load(language);
+        }
+        
+        public static ArrayList<String> getAvailableLanguages() {
+                ArrayList<String> list = new ArrayList<String>();
+                
+                try {
+                        ImmutableList<ResourceInfo> resources = ClassPath.from(Thread.currentThread().getContextClassLoader()).getResources().asList();
+                        Stream<ResourceInfo> dirStream = resources.stream();
+                        dirStream.forEach(context -> {
+                                String file = context.getResourceName();
+                                if (file.startsWith("lang/") && file.endsWith(".json")) {
+                                        String fileName = file.substring(5, file.length() - 5);
+                                        list.add(fileName);
+                                        loadLanguageName(fileName);
+                                }
+                        });
+                } catch (IOException e) {
+                        e.printStackTrace();
+                }
+                return list;
+        }
+        
+        private static void loadLanguageName(String fileName) {
+                try (InputStream stream = Thread.currentThread().getContextClassLoader().getResourceAsStream("lang/" + fileName + ".json")) {
+                        try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
+                                Map<?, ?> map = GSON.fromJson(reader, Map.class);
+                                languageNames.put(fileName, map.get("language").toString());
+                        }
+                } catch (IOException e) {
+                        e.printStackTrace();
+                }
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/utils/Pair.java b/enigma/src/main/java/cuchaz/enigma/utils/Pair.java
new file mode 100644
index 0000000..bf02cef
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/utils/Pair.java
@@ -0,0 +1,26 @@
+package cuchaz.enigma.utils;
+
+import java.util.Objects;
+
+public class Pair<A, B> {
+    public final A a;
+    public final B b;
+
+    public Pair(A a, B b) {
+        this.a = a;
+        this.b = b;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(a) * 31 +
+               Objects.hashCode(b);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof Pair &&
+               Objects.equals(a, ((Pair<?, ?>) o).a) &&
+               Objects.equals(b, ((Pair<?, ?>) o).b);
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/utils/Utils.java b/enigma/src/main/java/cuchaz/enigma/utils/Utils.java
new file mode 100644
index 0000000..2664099
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/utils/Utils.java
@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * 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.utils;
+
+import com.google.common.io.CharStreams;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class Utils {
+    public static String readStreamToString(InputStream in) throws IOException {
+        return CharStreams.toString(new InputStreamReader(in, StandardCharsets.UTF_8));
+    }
+
+    public static String readResourceToString(String path) throws IOException {
+        InputStream in = Utils.class.getResourceAsStream(path);
+        if (in == null) {
+            throw new IllegalArgumentException("Resource not found! " + path);
+        }
+        return readStreamToString(in);
+    }
+
+    public static void delete(Path path) throws IOException {
+        if (Files.exists(path)) {
+            for (Path p : Files.walk(path).sorted(Comparator.reverseOrder()).collect(Collectors.toList())) {
+                Files.delete(p);
+            }
+        }
+    }
+
+    public static byte[] zipSha1(Path path) throws IOException {
+        MessageDigest digest;
+        try {
+            digest = MessageDigest.getInstance("SHA-1");
+        } catch (NoSuchAlgorithmException e) {
+            // Algorithm guaranteed to be supported
+            throw new RuntimeException(e);
+        }
+        try (ZipFile zip = new ZipFile(path.toFile())) {
+            List<? extends ZipEntry> entries = Collections.list(zip.entries());
+            // only compare classes (some implementations may not generate directory entries)
+            entries.removeIf(entry -> !entry.getName().toLowerCase(Locale.ROOT).endsWith(".class"));
+            // different implementations may add zip entries in a different order
+            entries.sort(Comparator.comparing(ZipEntry::getName));
+            byte[] buffer = new byte[8192];
+            for (ZipEntry entry : entries) {
+                digest.update(entry.getName().getBytes(StandardCharsets.UTF_8));
+                try (InputStream in = zip.getInputStream(entry)) {
+                    int n;
+                    while ((n = in.read(buffer)) != -1) {
+                        digest.update(buffer, 0, n);
+                    }
+                }
+            }
+        }
+        return digest.digest();
+    }
+
+    public static boolean isBlank(String input) {
+        if (input == null) {
+            return true;
+        }
+        for (int i = 0; i < input.length(); i++) {
+            if (!Character.isWhitespace(input.charAt(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/enigma/src/main/resources/META-INF/services/cuchaz.enigma.api.EnigmaPlugin b/enigma/src/main/resources/META-INF/services/cuchaz.enigma.api.EnigmaPlugin
new file mode 100644
index 0000000..136a3e7
--- /dev/null
+++ b/enigma/src/main/resources/META-INF/services/cuchaz.enigma.api.EnigmaPlugin
@@ -0,0 +1 @@
+cuchaz.enigma.analysis.BuiltinPlugin
diff --git a/enigma/src/main/resources/lang/en_us.json b/enigma/src/main/resources/lang/en_us.json
new file mode 100644
index 0000000..dbf4b93
--- /dev/null
+++ b/enigma/src/main/resources/lang/en_us.json
@@ -0,0 +1,164 @@
+{
+        "language": "English",
+
+        "mapping_format.enigma_file": "Enigma File",
+        "mapping_format.enigma_directory": "Enigma Directory",
+        "mapping_format.enigma_zip": "Enigma ZIP",
+        "mapping_format.tiny_v2": "Tiny v2",
+        "mapping_format.tiny_file": "Tiny File",
+        "mapping_format.srg_file": "SRG File",
+        "mapping_format.proguard": "Proguard",
+        "type.methods": "Methods",
+        "type.fields": "Fields",
+        "type.parameters": "Parameters",
+        "type.classes": "Classes",
+
+        "menu.file": "File",
+        "menu.file.jar.open": "Open Jar...",
+        "menu.file.jar.close": "Close Jar",
+        "menu.file.mappings.open": "Open Mappings...",
+        "menu.file.mappings.save": "Save Mappings",
+        "menu.file.mappings.save_as": "Save Mappings As...",
+        "menu.file.mappings.close": "Close Mappings",
+        "menu.file.mappings.drop": "Drop Invalid Mappings",
+        "menu.file.export.source": "Export Source...",
+        "menu.file.export.jar": "Export Jar...",
+        "menu.file.stats": "Mapping Stats...",
+        "menu.file.stats.title": "Choose Included Members",
+        "menu.file.stats.generate": "Generate Stats",
+        "menu.file.exit": "Exit",
+        "menu.decompiler": "Decompiler",
+        "menu.view": "View",
+        "menu.view.themes": "Themes",
+        "menu.view.themes.default": "Default",
+        "menu.view.themes.darcula": "Darcula",
+        "menu.view.themes.system": "System",
+        "menu.view.themes.none": "None (JVM Default)",
+        "menu.view.languages": "Languages",
+        "menu.view.scale": "Scale",
+        "menu.view.scale.custom": "Custom...",
+        "menu.view.scale.custom.title": "Custom Scale",
+        "menu.view.change.title": "Changes",
+        "menu.view.change.summary": "Changes will be applied after the next restart.",
+        "menu.view.change.ok": "Ok",
+        "menu.view.search": "Search",
+        "menu.collab": "Collab",
+        "menu.collab.connect": "Connect to server",
+        "menu.collab.connect.error": "Error connecting to server",
+        "menu.collab.disconnect": "Disconnect",
+        "menu.collab.server.start": "Start server",
+        "menu.collab.server.start.error": "Error starting server",
+        "menu.collab.server.stop": "Stop server",
+        "menu.help": "Help",
+        "menu.help.about": "About",
+        "menu.help.about.title": "%s - About",
+        "menu.help.about.ok": "Ok",
+        "menu.help.github": "Github Page",
+
+        "popup_menu.rename": "Rename",
+        "popup_menu.javadoc": "Edit Javadoc",
+        "popup_menu.inheritance": "Show Inheritance",
+        "popup_menu.implementations": "Show Implementations",
+        "popup_menu.calls": "Show Calls (All Implementations)",
+        "popup_menu.calls.specific": "Show Calls (Specific)",
+        "popup_menu.declaration": "Go to Declaration",
+        "popup_menu.back": "Go back",
+        "popup_menu.forward": "Go forward",
+        "popup_menu.mark_deobfuscated": "Mark as deobfuscated",
+        "popup_menu.reset_obfuscated": "Reset to obfuscated",
+        "popup_menu.zoom.in": "Zoom in",
+        "popup_menu.zoom.out": "Zoom out",
+        "popup_menu.zoom.reset": "Reset zoom",
+
+        "info_panel.classes.obfuscated": "Obfuscated Classes",
+        "info_panel.classes.deobfuscated": "De-obfuscated Classes",
+        "info_panel.identifier": "Identifier Info",
+        "info_panel.identifier.none": "No identifier selected",
+        "info_panel.identifier.variable": "Variable",
+        "info_panel.identifier.field": "Field",
+        "info_panel.identifier.method": "Method",
+        "info_panel.identifier.constructor": "Constructor",
+        "info_panel.identifier.class": "Class",
+        "info_panel.identifier.type_descriptor": "TypeDescriptor",
+        "info_panel.identifier.method_descriptor": "MethodDescriptor",
+        "info_panel.identifier.modifier": "Modifier",
+        "info_panel.identifier.index": "Index",
+        "info_panel.editor.class.decompiling": "(decompiling...)",
+        "info_panel.editor.class.not_found": "Unable to find class:",
+        "info_panel.tree.inheritance": "Inheritance",
+        "info_panel.tree.implementations": "Implementations",
+        "info_panel.tree.calls": "Call Graph",
+
+        "log_panel.messages": "Messages",
+        "log_panel.users": "Users",
+
+        "progress.operation": "%s - Operation in progress",
+        "progress.jar.indexing": "Indexing jar",
+        "progress.jar.indexing.entries": "Entries...",
+        "progress.jar.indexing.references": "Entry references...",
+        "progress.jar.indexing.methods": "Bridge methods...",
+        "progress.jar.indexing.process": "Processing...",
+        "progress.jar.writing": "Writing jar...",
+        "progress.sources.writing": "Writing sources...",
+        "progress.classes.deobfuscating": "Deobfuscating classes...",
+        "progress.classes.decompiling": "Decompiling classes...",
+        "progress.mappings.enigma_file.loading": "Loading mapping file",
+        "progress.mappings.enigma_file.done": "Done!",
+        "progress.mappings.enigma_file.writing": "Writing classes",
+        "progress.mappings.enigma_directory.loading": "Loading mapping files",
+        "progress.mappings.enigma_directory.writing": "Writing classes",
+        "progress.mappings.tiny_file.loading": "Loading mapping file",
+        "progress.mappings.tiny_v2.loading": "Loading mapping file",
+        "progress.mappings.srg_file.generating": "Generating mappings",
+        "progress.mappings.srg_file.writing": "Writing mappings",
+        "progress.stats": "Generating stats",
+        "progress.stats.data": "Generating data",
+
+        "javadocs.edit": "Edit Javadocs",
+        "javadocs.instruction": "Edit javadocs here.",
+        "javadocs.cancel": "Cancel",
+        "javadocs.save": "Save",
+
+        "prompt.close.title": "Save your changes?",
+        "prompt.close.summary": "Your mappings have not been saved yet. Do you want to save?",
+        "prompt.close.save": "Save and close",
+        "prompt.close.discard": "Discard changes",
+        "prompt.close.cancel": "Cancel",
+        "prompt.open": "Open",
+        "prompt.cancel": "Cancel",
+        "prompt.connect.title": "Connect to server",
+        "prompt.connect.username": "Username",
+        "prompt.connect.ip": "IP",
+        "prompt.port": "Port",
+        "prompt.port.nan": "Port is not a number",
+        "prompt.port.invalid": "Port is out of range, should be between 0-65535",
+        "prompt.password": "Password",
+        "prompt.password.too_long": "Password is too long, it must be at most 255 characters.",
+        "prompt.create_server.title": "Create server",
+
+        "disconnect.disconnected": "Disconnected",
+        "disconnect.server_closed": "Server closed",
+        "disconnect.wrong_jar": "Jar checksums don't match (you have the wrong jar)!",
+        "disconnect.wrong_password": "Incorrect password",
+        "disconnect.username_taken": "Username is taken",
+
+        "message.chat.text": "%s: %s",
+        "message.connect.text": "[+] %s",
+        "message.disconnect.text": "[-] %s",
+        "message.edit_docs.text": "%s edited docs for %s",
+        "message.mark_deobf.text": "%s marked %s as deobfuscated",
+        "message.remove_mapping.text": "%s removed mappings for %s",
+        "message.rename.text": "%s renamed %s to %s",
+
+        "status.disconnected": "Disconnected.",
+        "status.connected": "Connected.",
+        "status.connected_user_count": "Connected (%d users).",
+        "status.ready": "Ready.",
+
+        "crash.title": "%s - Crash Report",
+        "crash.summary": "%s has crashed! =(",
+        "crash.export": "Export",
+        "crash.ignore": "Ignore",
+        "crash.exit": "Exit",
+        "crash.exit.warning": "If you choose exit, you will lose any unsaved work."
+}
diff --git a/enigma/src/main/resources/lang/fr_fr.json b/enigma/src/main/resources/lang/fr_fr.json
new file mode 100644
index 0000000..d169b9a
--- /dev/null
+++ b/enigma/src/main/resources/lang/fr_fr.json
@@ -0,0 +1,164 @@
+{
+        "language": "Français",
+
+        "mapping_format.enigma_file": "Fichier Enigma",
+        "mapping_format.enigma_directory": "Répertoire Enigma",
+        "mapping_format.enigma_zip": "ZIP Enigma",
+        "mapping_format.tiny_v2": "Tiny v2",
+        "mapping_format.tiny_file": "Fichier Tiny",
+        "mapping_format.srg_file": "Fichier SRG",
+        "mapping_format.proguard": "Proguard",
+        "type.methods": "Méthodes",
+        "type.fields": "Champs",
+        "type.parameters": "Paramètres",
+        "type.classes": "Classes",
+
+        "menu.file": "Fichier",
+        "menu.file.jar.open": "Ouvrir le jar...",
+        "menu.file.jar.close": "Fermer le jar",
+        "menu.file.mappings.open": "Ouvrir les mappings...",
+        "menu.file.mappings.save": "Enregistrer les mappings",
+        "menu.file.mappings.save_as": "Enregistrer les mappings sous...",
+        "menu.file.mappings.close": "Fermer les mappings",
+        "menu.file.mappings.drop": "Supprimer les mappings invalides",
+        "menu.file.export.source": "Exporter la source...",
+        "menu.file.export.jar": "Exporter le jar...",
+        "menu.file.stats": "Statistiques des mappings...",
+        "menu.file.stats.title": "Choisir les membres inclus",
+        "menu.file.stats.generate": "Générer les statistiques",
+        "menu.file.exit": "Quitter",
+        "menu.decompiler": "Décompilateur",
+        "menu.view": "Affichage",
+        "menu.view.themes": "Thèmes",
+        "menu.view.themes.default": "Par défaut",
+        "menu.view.themes.darcula": "Darcula",
+        "menu.view.themes.system": "Système",
+        "menu.view.themes.none": "Aucun (JVM par défaut)",
+        "menu.view.languages": "Langues",
+        "menu.view.scale": "Échelle",
+        "menu.view.scale.custom": "Personnalisée...",
+        "menu.view.scale.custom.title": "Échelle personnalisée",
+        "menu.view.change.title": "Modifications",
+        "menu.view.change.summary": "Les modifications seront appliquées lors du prochain redémarrage.",
+        "menu.view.change.ok": "Ok",
+        "menu.view.search": "Rechercher",
+        "menu.collab": "Collab",
+        "menu.collab.connect": "Se connecter à un serveur",
+        "menu.collab.connect.error": "Erreur lors de la connexion au serveur",
+        "menu.collab.disconnect": "Se déconnecter",
+        "menu.collab.server.start": "Démarrer le serveur",
+        "menu.collab.server.start.error": "Erreur lors du démarrage du serveur",
+        "menu.collab.server.stop": "Arrêter le serveur",
+        "menu.help": "Aide",
+        "menu.help.about": "À propos",
+        "menu.help.about.title": "%s - À propos",
+        "menu.help.about.ok": "Ok",
+        "menu.help.github": "Page Github",
+
+        "popup_menu.rename": "Renommer",
+        "popup_menu.javadoc": "Éditer le Javadoc",
+        "popup_menu.inheritance": "Afficher l'héritage",
+        "popup_menu.implementations": "Afficher les implémentations",
+        "popup_menu.calls": "Afficher les appels (tous)",
+        "popup_menu.calls.specific": "Afficher les appels (spécifiques)",
+        "popup_menu.declaration": "Aller à la déclaration",
+        "popup_menu.back": "Annuler",
+        "popup_menu.forward": "Restaurer",
+        "popup_menu.mark_deobfuscated": "Marquer comme déobfusqué",
+        "popup_menu.reset_obfuscated": "Réinitialiser à obfusqué",
+        "popup_menu.zoom.in": "Zoomer",
+        "popup_menu.zoom.out": "Dézoomer",
+        "popup_menu.zoom.reset": "Réinitialiser le zoom",
+
+        "info_panel.classes.obfuscated": "Classes obfusquées",
+        "info_panel.classes.deobfuscated": "Classes déobfusquées",
+        "info_panel.identifier": "Informations sur l'identifiant",
+        "info_panel.identifier.none": "Aucun identifiant sélectionné",
+        "info_panel.identifier.variable": "Variable",
+        "info_panel.identifier.field": "Champ",
+        "info_panel.identifier.method": "Méthode",
+        "info_panel.identifier.constructor": "Constructeur",
+        "info_panel.identifier.class": "Classe",
+        "info_panel.identifier.type_descriptor": "Descripteur de type",
+        "info_panel.identifier.method_descriptor": "Descripteur de méthode",
+        "info_panel.identifier.modifier": "Modificateur",
+        "info_panel.identifier.index": "Index",
+        "info_panel.editor.class.decompiling": "(décompilation...)",
+        "info_panel.editor.class.not_found": "Impossible de trouver la classe :",
+        "info_panel.tree.inheritance": "Héritage",
+        "info_panel.tree.implementations": "Implémentations",
+        "info_panel.tree.calls": "Graphique des appels",
+
+        "log_panel.messages": "Messages",
+        "log_panel.users": "Utilisateurs",
+
+        "progress.operation": "%s - Opération en cours",
+        "progress.jar.indexing": "Indexation du jar",
+        "progress.jar.indexing.entries": "Entrées...",
+        "progress.jar.indexing.references": "Références des entrées...",
+        "progress.jar.indexing.methods": "Mise en place des méthodes...",
+        "progress.jar.indexing.process": "Traitement...",
+        "progress.jar.writing": "Écriture du jar...",
+        "progress.sources.writing": "Écriture des sources...",
+        "progress.classes.deobfuscating": "Déobfuscation des classes...",
+        "progress.classes.decompiling": "Décompilation des classes...",
+        "progress.mappings.enigma_file.loading": "Chargement du fichier de mappings",
+        "progress.mappings.enigma_file.done": "Terminé !",
+        "progress.mappings.enigma_file.writing": "Écriture des classes",
+        "progress.mappings.enigma_directory.loading": "Chargement des fichiers de mappings",
+        "progress.mappings.enigma_directory.writing": "Écriture des classes",
+        "progress.mappings.tiny_file.loading": "Chargement du fichier de mappings",
+        "progress.mappings.tiny_v2.loading": "Chargement du fichier de mappings",
+        "progress.mappings.srg_file.generating": "Génération des mappings",
+        "progress.mappings.srg_file.writing": "Écriture des mappings",
+        "progress.stats": "Génération des statistiques",
+        "progress.stats.data": "Génération des données",
+
+        "javadocs.edit": "Éditer les Javadocs",
+        "javadocs.instruction": "Éditer les Javadocs ici.",
+        "javadocs.cancel": "Annuler",
+        "javadocs.save": "Enregistrer",
+
+        "prompt.close.title": "Enregistrer les modifications ?",
+        "prompt.close.summary": "Vos mappings n'ont pas encore été enregistrés. Souhaitez-vous enregistrer ?",
+        "prompt.close.save": "Enregistrer et fermer",
+        "prompt.close.discard": "Annuler les modifications",
+        "prompt.close.cancel": "Annuler",
+        "prompt.open": "Ouvrir",
+        "prompt.cancel": "Annuler",
+        "prompt.connect.title": "Se connecter à un serveur",
+        "prompt.connect.username": "Nom d'utilisateur",
+        "prompt.connect.ip": "IP",
+        "prompt.port": "Port",
+        "prompt.port.nan": "Le port n'est pas un nombre",
+        "prompt.port.invalid": "Le port est hors de portée. Il doit être compris entre 0 et 65535.",
+        "prompt.password": "Mot de passe",
+        "prompt.password.too_long": "Le mot de passe est trop long. Il ne doit pas dépasser 255 caractères.",
+        "prompt.create_server.title": "Créer un serveur",
+
+        "disconnect.disconnected": "Déconnecté",
+        "disconnect.server_closed": "Serveur fermé",
+        "disconnect.wrong_jar": "Les sommes de contrôle du jar ne correspondent pas (vous avez le mauvais jar) !",
+        "disconnect.wrong_password": "Mot de passe incorrect",
+        "disconnect.username_taken": "Le nom d'utilisateur est déjà pris",
+
+        "message.chat.text": "%s : %s",
+        "message.connect.text": "[+] %s",
+        "message.disconnect.text": "[-] %s",
+        "message.edit_docs.text": "%s a édité les javadocs de %s",
+        "message.mark_deobf.text": "%s a marqué %s comme déobfusqué",
+        "message.remove_mapping.text": "%s a supprimé les mappings de %s",
+        "message.rename.text": "%s a renommé %s en %s",
+
+        "status.disconnected": "Déconnecté.",
+        "status.connected": "Connecté.",
+        "status.connected_user_count": "Connecté (%d utilisateurs).",
+        "status.ready": "Prêt.",
+
+        "crash.title": "%s - Rapport de plantage",
+        "crash.summary": "%s a planté ! =(",
+        "crash.export": "Exporter",
+        "crash.ignore": "Ignorer",
+        "crash.exit": "Quitter",
+        "crash.exit.warning": "Si vous choisissez Quitter, vous perdrez tout travail non sauvegardé."
+}
diff --git a/enigma/src/main/resources/lang/zh_cn.json b/enigma/src/main/resources/lang/zh_cn.json
new file mode 100644
index 0000000..f3f503a
--- /dev/null
+++ b/enigma/src/main/resources/lang/zh_cn.json
@@ -0,0 +1,118 @@
+{
+        "language": "Chinese",
+
+        "mapping_format.enigma_file": "Enigma 文件",
+        "mapping_format.enigma_directory": "Enigma 目录",
+        "mapping_format.enigma_zip": "Enigma ZIP",
+        "mapping_format.tiny_v2": "Tiny v2",
+        "mapping_format.tiny_file": "Tiny File",
+        "mapping_format.srg_file": "SRG File",
+        "mapping_format.proguard": "Proguard",
+        "type.methods": "方法",
+        "type.fields": "字段",
+        "type.parameters": "参数",
+        "type.classes": "类",
+
+        "menu.file": "文件",
+        "menu.file.jar.open": "打开 Jar...",
+        "menu.file.jar.close": "关闭 Jar",
+        "menu.file.mappings.open": "打开映射...",
+        "menu.file.mappings.save": "保存映射",
+        "menu.file.mappings.save_as": "将映射另存为...",
+        "menu.file.mappings.close": "关闭映射",
+        "menu.file.mappings.drop": "删除无效映射",
+        "menu.file.export.source": "导出源码...",
+        "menu.file.export.jar": "导出Jar...",
+        "menu.file.stats": "映射统计范围...",
+        "menu.file.stats.title": "选择包括的成员",
+        "menu.file.stats.generate": "生成统计范围",
+        "menu.file.exit": "退出",
+        "menu.decompiler": "反编译",
+        "menu.view": "查看",
+        "menu.view.themes": "主题",
+        "menu.view.themes.default": "Default",
+        "menu.view.themes.darcula": "Darcula",
+        "menu.view.themes.system": "System",
+        "menu.view.themes.none": "None (JVM Default)",
+        "menu.view.languages": "语言",
+        "menu.view.languages.title": "更改语言",
+        "menu.view.languages.summary": "新语言将在下次重新启动后应用.",
+        "menu.view.languages.ok": "确定",
+        "menu.view.search": "搜索",
+        "menu.help": "帮助",
+        "menu.help.about": "关于",
+        "menu.help.about.title": "%s - 关于",
+        "menu.help.about.ok": "确定",
+        "menu.help.github": "GitHub 页面",
+
+        "popup_menu.rename": "改名",
+        "popup_menu.javadoc": "编辑注释",
+        "popup_menu.inheritance": "显示继承",
+        "popup_menu.implementations": "显示实现",
+        "popup_menu.calls": "显示 Calls",
+        "popup_menu.calls.specific": "显示 Calls (具体)",
+        "popup_menu.declaration": "Go to Declaration",
+        "popup_menu.back": "Go back",
+        "popup_menu.forward": "Go forward",
+        "popup_menu.mark_deobfuscated": "标记为反混淆",
+        "popup_menu.reset_obfuscated": "重置混淆",
+
+        "info_panel.classes.obfuscated": "混淆类",
+        "info_panel.classes.deobfuscated": "反混淆类",
+        "info_panel.identifier": "标识符信息",
+        "info_panel.identifier.none": "未选择标识符",
+        "info_panel.identifier.variable": "变量",
+        "info_panel.identifier.field": "字段",
+        "info_panel.identifier.method": "方法",
+        "info_panel.identifier.constructor": "构造器",
+        "info_panel.identifier.class": "类",
+        "info_panel.identifier.type_descriptor": "类型描述符",
+        "info_panel.identifier.method_descriptor": "方法描述符",
+        "info_panel.identifier.modifier": "修饰语",
+        "info_panel.identifier.index": "索引",
+        "info_panel.editor.class.decompiling": "(反编译中...)",
+        "info_panel.editor.class.not_found": "找不到类:",
+        "info_panel.tree.inheritance": "继承",
+        "info_panel.tree.implementations": "实现",
+        "info_panel.tree.calls": "调用图",
+
+        "progress.operation": "%s - 进行中",
+        "progress.jar.indexing": "索引jar",
+        "progress.jar.indexing.entries": "条目...",
+        "progress.jar.indexing.references": "条目引用...",
+        "progress.jar.indexing.methods": "桥接方法...",
+        "progress.jar.indexing.process": "处理中...",
+        "progress.jar.writing": "写出jar中...",
+        "progress.sources.writing": "写出源码中...",
+        "progress.classes.deobfuscating": "反混淆类中...",
+        "progress.classes.decompiling": "反编译类中...",
+        "progress.mappings.enigma_file.loading": "加载映射文件",
+        "progress.mappings.enigma_file.done": "完成!",
+        "progress.mappings.enigma_file.writing": "写出类",
+        "progress.mappings.enigma_directory.loading": "加载映射文件",
+        "progress.mappings.enigma_directory.writing": "写出类",
+        "progress.mappings.tiny_file.loading": "加载映射文件",
+        "progress.mappings.tiny_v2.loading": "加载映射文件",
+        "progress.mappings.srg_file.generating": "生成映射",
+        "progress.mappings.srg_file.writing": "写出映射",
+        "progress.stats": "生成统计范围",
+        "progress.stats.data": "生成数据",
+
+        "javadocs.edit": "编辑注释",
+        "javadocs.instruction": "在此处编辑编辑注释.",
+        "javadocs.cancel": "取消",
+        "javadocs.save": "保存",
+
+        "prompt.close.title": "保存更改?",
+        "prompt.close.summary": "您的映射尚未保存。你想保存吗?",
+        "prompt.close.save": "保存并关闭",
+        "prompt.close.discard": "放弃更改",
+        "prompt.close.cancel": "取消",
+
+        "crash.title": "%s - 崩溃报告",
+        "crash.summary": "%s 已经崩溃! =(",
+        "crash.export": "输出",
+        "crash.ignore": "忽略",
+        "crash.exit": "退出",
+        "crash.exit.warning": "如果选择退出，将丢失所有未保存的工作."
+}
diff --git a/enigma/src/main/resources/profile.json b/enigma/src/main/resources/profile.json
new file mode 100644
index 0000000..e1af4cd
--- /dev/null
+++ b/enigma/src/main/resources/profile.json
@@ -0,0 +1,20 @@
+{
+  "services": {
+    "jar_indexer": [
+      {
+        "id": "enigma:enum_initializer_indexer"
+      },
+      {
+        "id": "enigma:specialized_bridge_method_indexer"
+      }
+    ],
+    "name_proposal": [
+      {
+        "id": "enigma:enum_name_proposer"
+      },
+      {
+        "id": "enigma:specialized_method_name_proposer"
+      }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/enigma/src/test/java/cuchaz/enigma/PackageVisibilityIndexTest.java b/enigma/src/test/java/cuchaz/enigma/PackageVisibilityIndexTest.java
new file mode 100644
index 0000000..1dc9748
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/PackageVisibilityIndexTest.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.analysis.index.PackageVisibilityIndex;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import org.junit.Test;
+
+import java.nio.file.Paths;
+
+import static cuchaz.enigma.TestEntryFactory.newClass;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+
+public class PackageVisibilityIndexTest {
+
+        private static final ClassEntry KEEP = newClass("cuchaz/enigma/inputs/Keep");
+        private static final ClassEntry BASE = newClass("a");
+        private static final ClassEntry SAME_PACKAGE_CHILD = newClass("b");
+        private static final ClassEntry SAME_PACKAGE_CHILD_INNER = newClass("b$a");
+        private static final ClassEntry OTHER_PACKAGE_CHILD = newClass("c");
+        private static final ClassEntry OTHER_PACKAGE_CHILD_INNER = newClass("c$a");
+        private final JarIndex jarIndex;
+
+        public PackageVisibilityIndexTest() throws Exception {
+                ClassCache classCache = ClassCache.of(Paths.get("build/test-obf/packageAccess.jar"));
+                jarIndex = classCache.index(ProgressListener.none());
+        }
+
+        @Test
+        public void test() {
+                PackageVisibilityIndex visibilityIndex = jarIndex.getPackageVisibilityIndex();
+                assertThat(visibilityIndex.getPartition(BASE), containsInAnyOrder(BASE, SAME_PACKAGE_CHILD, SAME_PACKAGE_CHILD_INNER));
+                System.out.println(visibilityIndex.getPartitions());
+                assertThat(visibilityIndex.getPartitions(), containsInAnyOrder(
+                                containsInAnyOrder(BASE, SAME_PACKAGE_CHILD, SAME_PACKAGE_CHILD_INNER),
+                                containsInAnyOrder(OTHER_PACKAGE_CHILD, OTHER_PACKAGE_CHILD_INNER),
+                                contains(KEEP)
+                ));
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestDeobfed.java b/enigma/src/test/java/cuchaz/enigma/TestDeobfed.java
new file mode 100644
index 0000000..494d959
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestDeobfed.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.source.Decompiler;
+import cuchaz.enigma.source.Decompilers;
+import cuchaz.enigma.source.SourceSettings;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import static cuchaz.enigma.TestEntryFactory.newClass;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+
+public class TestDeobfed {
+        private static Enigma enigma;
+        private static ClassCache classCache;
+        private static JarIndex index;
+
+        @BeforeClass
+        public static void beforeClass() throws Exception {
+                enigma = Enigma.create();
+
+                Path obf = Paths.get("build/test-obf/translation.jar");
+                Path deobf = Paths.get("build/test-deobf/translation.jar");
+                Files.createDirectories(deobf.getParent());
+                EnigmaProject project = enigma.openJar(obf, ProgressListener.none());
+                project.exportRemappedJar(ProgressListener.none()).write(deobf, ProgressListener.none());
+
+                classCache = ClassCache.of(deobf);
+                index = classCache.index(ProgressListener.none());
+        }
+
+        @Test
+        public void obfEntries() {
+                assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(
+                        newClass("cuchaz/enigma/inputs/Keep"),
+                        newClass("a"),
+                        newClass("b"),
+                        newClass("c"),
+                        newClass("d"),
+                        newClass("d$1"),
+                        newClass("e"),
+                        newClass("f"),
+                        newClass("g"),
+                        newClass("g$a"),
+                        newClass("g$a$a"),
+                        newClass("g$b"),
+                        newClass("g$b$a"),
+                        newClass("h"),
+                        newClass("h$a"),
+                        newClass("h$a$a"),
+                        newClass("h$b"),
+                        newClass("h$b$a"),
+                        newClass("h$b$a$a"),
+                        newClass("h$b$a$b"),
+                        newClass("i"),
+                        newClass("i$a"),
+                        newClass("i$b")
+                ));
+        }
+
+        @Test
+        public void decompile() {
+                EnigmaProject project = new EnigmaProject(enigma, classCache, index, new byte[20]);
+                Decompiler decompiler = Decompilers.PROCYON.create(project.getClassCache(), new SourceSettings(false, false));
+
+                decompiler.getSource("a");
+                decompiler.getSource("b");
+                decompiler.getSource("c");
+                decompiler.getSource("d");
+                decompiler.getSource("d$1");
+                decompiler.getSource("e");
+                decompiler.getSource("f");
+                decompiler.getSource("g");
+                decompiler.getSource("g$a");
+                decompiler.getSource("g$a$a");
+                decompiler.getSource("g$b");
+                decompiler.getSource("g$b$a");
+                decompiler.getSource("h");
+                decompiler.getSource("h$a");
+                decompiler.getSource("h$a$a");
+                decompiler.getSource("h$b");
+                decompiler.getSource("h$b$a");
+                decompiler.getSource("h$b$a$a");
+                decompiler.getSource("h$b$a$b");
+                decompiler.getSource("i");
+                decompiler.getSource("i$a");
+                decompiler.getSource("i$b");
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestDeobfuscator.java b/enigma/src/test/java/cuchaz/enigma/TestDeobfuscator.java
new file mode 100644
index 0000000..6619d26
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestDeobfuscator.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.source.Decompiler;
+import cuchaz.enigma.source.Decompilers;
+import cuchaz.enigma.source.SourceSettings;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+
+public class TestDeobfuscator {
+        private EnigmaProject openProject() throws IOException {
+                Enigma enigma = Enigma.create();
+                return enigma.openJar(Paths.get("build/test-obf/loneClass.jar"), ProgressListener.none());
+        }
+
+        @Test
+        public void loadJar()
+                throws Exception {
+                openProject();
+        }
+
+        @Test
+        public void decompileClass() throws Exception {
+                EnigmaProject project = openProject();
+                Decompiler decompiler = Decompilers.PROCYON.create(project.getClassCache(), new SourceSettings(false, false));
+
+                decompiler.getSource("a").asString();
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestEntryFactory.java b/enigma/src/test/java/cuchaz/enigma/TestEntryFactory.java
new file mode 100644
index 0000000..9e1425a
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestEntryFactory.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.translation.representation.*;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+public class TestEntryFactory {
+
+        public static ClassEntry newClass(String name) {
+                return new ClassEntry(name);
+        }
+
+        public static FieldEntry newField(String className, String fieldName, String fieldType) {
+                return newField(newClass(className), fieldName, fieldType);
+        }
+
+        public static FieldEntry newField(ClassEntry classEntry, String fieldName, String fieldType) {
+                return new FieldEntry(classEntry, fieldName, new TypeDescriptor(fieldType));
+        }
+
+        public static MethodEntry newMethod(String className, String methodName, String methodSignature) {
+                return newMethod(newClass(className), methodName, methodSignature);
+        }
+
+        public static MethodEntry newMethod(ClassEntry classEntry, String methodName, String methodSignature) {
+                return new MethodEntry(classEntry, methodName, new MethodDescriptor(methodSignature));
+        }
+
+        public static EntryReference<FieldEntry, MethodEntry> newFieldReferenceByMethod(FieldEntry fieldEntry, String callerClassName, String callerName, String callerSignature) {
+                return new EntryReference<>(fieldEntry, "", newMethod(callerClassName, callerName, callerSignature));
+        }
+
+        public static EntryReference<MethodEntry, MethodEntry> newBehaviorReferenceByMethod(MethodEntry methodEntry, String callerClassName, String callerName, String callerSignature) {
+                return new EntryReference<>(methodEntry, "", newMethod(callerClassName, callerName, callerSignature));
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestInnerClasses.java b/enigma/src/test/java/cuchaz/enigma/TestInnerClasses.java
new file mode 100644
index 0000000..85c72f8
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestInnerClasses.java
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.source.Decompiler;
+import cuchaz.enigma.source.Decompilers;
+import cuchaz.enigma.source.SourceSettings;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import org.junit.Test;
+
+import java.nio.file.Paths;
+
+import static cuchaz.enigma.TestEntryFactory.newClass;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+public class TestInnerClasses {
+
+        private static final ClassEntry SimpleOuter = newClass("d");
+        private static final ClassEntry SimpleInner = newClass("d$a");
+        private static final ClassEntry ConstructorArgsOuter = newClass("c");
+        private static final ClassEntry ConstructorArgsInner = newClass("c$a");
+        private static final ClassEntry ClassTreeRoot = newClass("f");
+        private static final ClassEntry ClassTreeLevel1 = newClass("f$a");
+        private static final ClassEntry ClassTreeLevel2 = newClass("f$a$a");
+        private static final ClassEntry ClassTreeLevel3 = newClass("f$a$a$a");
+        private final JarIndex index;
+        private final Decompiler decompiler;
+
+        public TestInnerClasses() throws Exception {
+                ClassCache classCache = ClassCache.of(Paths.get("build/test-obf/innerClasses.jar"));
+                index = classCache.index(ProgressListener.none());
+                decompiler = Decompilers.PROCYON.create(classCache, new SourceSettings(false, false));
+        }
+
+        @Test
+        public void simple() {
+                decompile(SimpleOuter);
+        }
+
+        @Test
+        public void constructorArgs() {
+                decompile(ConstructorArgsOuter);
+        }
+
+        @Test
+        public void classTree() {
+
+                // root level
+                assertThat(index.getEntryIndex().hasClass(ClassTreeRoot), is(true));
+
+                // level 1
+                ClassEntry fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
+                        + "$" + ClassTreeLevel1.getSimpleName());
+                assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true));
+
+                // level 2
+                fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
+                        + "$" + ClassTreeLevel1.getSimpleName()
+                        + "$" + ClassTreeLevel2.getSimpleName());
+                assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true));
+
+                // level 3
+                fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
+                        + "$" + ClassTreeLevel1.getSimpleName()
+                        + "$" + ClassTreeLevel2.getSimpleName()
+                        + "$" + ClassTreeLevel3.getSimpleName());
+                assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true));
+        }
+
+        private void decompile(ClassEntry classEntry) {
+                decompiler.getSource(classEntry.getName());
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java b/enigma/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
new file mode 100644
index 0000000..48975c8
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
@@ -0,0 +1,124 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import org.junit.Test;
+
+import java.nio.file.Paths;
+import java.util.Collection;
+
+import static cuchaz.enigma.TestEntryFactory.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+public class TestJarIndexConstructorReferences {
+
+        private JarIndex index;
+
+        private ClassEntry baseClass = newClass("a");
+        private ClassEntry subClass = newClass("d");
+        private ClassEntry subsubClass = newClass("e");
+        private ClassEntry defaultClass = newClass("c");
+        private ClassEntry callerClass = newClass("b");
+
+        public TestJarIndexConstructorReferences() throws Exception {
+                ClassCache classCache = ClassCache.of(Paths.get("build/test-obf/constructors.jar"));
+                index = classCache.index(ProgressListener.none());
+        }
+
+        @Test
+        public void obfEntries() {
+                assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass,
+                                subClass, subsubClass, defaultClass, callerClass));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void baseDefault() {
+                MethodEntry source = newMethod(baseClass, "<init>", "()V");
+                Collection<EntryReference<MethodEntry, MethodDefEntry>> references = index.getReferenceIndex().getReferencesToMethod(source);
+                assertThat(references, containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "a", "()V"),
+                                newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "()V"),
+                                newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "(III)V")
+                ));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void baseInt() {
+                MethodEntry source = newMethod(baseClass, "<init>", "(I)V");
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "b", "()V")
+                ));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void subDefault() {
+                MethodEntry source = newMethod(subClass, "<init>", "()V");
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "c", "()V"),
+                                newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "(I)V")
+                ));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void subInt() {
+                MethodEntry source = newMethod(subClass, "<init>", "(I)V");
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "d", "()V"),
+                                newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "(II)V"),
+                                newBehaviorReferenceByMethod(source, subsubClass.getName(), "<init>", "(I)V")
+                ));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void subIntInt() {
+                MethodEntry source = newMethod(subClass, "<init>", "(II)V");
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "e", "()V")
+                ));
+        }
+
+        @Test
+        public void subIntIntInt() {
+                MethodEntry source = newMethod(subClass, "<init>", "(III)V");
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), is(empty()));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void subsubInt() {
+                MethodEntry source = newMethod(subsubClass, "<init>", "(I)V");
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "f", "()V")
+                ));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void defaultConstructable() {
+                MethodEntry source = newMethod(defaultClass, "<init>", "()V");
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "g", "()V")
+                ));
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java b/enigma/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
new file mode 100644
index 0000000..76e379c
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
@@ -0,0 +1,227 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.index.EntryIndex;
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.IndexEntryResolver;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import org.junit.Test;
+import org.objectweb.asm.Opcodes;
+
+import java.nio.file.Paths;
+import java.util.Collection;
+
+import static cuchaz.enigma.TestEntryFactory.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+public class TestJarIndexInheritanceTree {
+
+        private JarIndex index;
+
+        private ClassEntry baseClass = newClass("a");
+        private ClassEntry subClassA = newClass("b");
+        private ClassEntry subClassAA = newClass("d");
+        private ClassEntry subClassB = newClass("c");
+        private FieldEntry nameField = newField(baseClass, "a", "Ljava/lang/String;");
+        private FieldEntry numThingsField = newField(subClassB, "a", "I");
+
+        public TestJarIndexInheritanceTree()
+                        throws Exception {
+                ClassCache classCache = ClassCache.of(Paths.get("build/test-obf/inheritanceTree.jar"));
+                index = classCache.index(ProgressListener.none());
+        }
+
+        @Test
+        public void obfEntries() {
+                assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(
+                                newClass("cuchaz/enigma/inputs/Keep"), baseClass, subClassA, subClassAA, subClassB
+                ));
+        }
+
+        @Test
+        public void translationIndex() {
+
+                InheritanceIndex index = this.index.getInheritanceIndex();
+
+                // base class
+                assertThat(index.getParents(baseClass), is(empty()));
+                assertThat(index.getAncestors(baseClass), is(empty()));
+                assertThat(index.getChildren(baseClass), containsInAnyOrder(subClassA, subClassB
+                ));
+
+                // subclass a
+                assertThat(index.getParents(subClassA), contains(baseClass));
+                assertThat(index.getAncestors(subClassA), containsInAnyOrder(baseClass));
+                assertThat(index.getChildren(subClassA), contains(subClassAA));
+
+                // subclass aa
+                assertThat(index.getParents(subClassAA), contains(subClassA));
+                assertThat(index.getAncestors(subClassAA), containsInAnyOrder(subClassA, baseClass));
+                assertThat(index.getChildren(subClassAA), is(empty()));
+
+                // subclass b
+                assertThat(index.getParents(subClassB), contains(baseClass));
+                assertThat(index.getAncestors(subClassB), containsInAnyOrder(baseClass));
+                assertThat(index.getChildren(subClassB), is(empty()));
+        }
+
+        @Test
+        public void access() {
+                assertThat(index.getEntryIndex().getFieldAccess(nameField), is(new AccessFlags(Opcodes.ACC_PRIVATE)));
+                assertThat(index.getEntryIndex().getFieldAccess(numThingsField), is(new AccessFlags(Opcodes.ACC_PRIVATE)));
+        }
+
+        @Test
+        public void relatedMethodImplementations() {
+
+                Collection<MethodEntry> entries;
+
+                EntryResolver resolver = new IndexEntryResolver(index);
+                // getName()
+                entries = resolver.resolveEquivalentMethods(newMethod(baseClass, "a", "()Ljava/lang/String;"));
+                assertThat(entries, containsInAnyOrder(
+                                newMethod(baseClass, "a", "()Ljava/lang/String;"),
+                                newMethod(subClassAA, "a", "()Ljava/lang/String;")
+                ));
+                entries = resolver.resolveEquivalentMethods(newMethod(subClassAA, "a", "()Ljava/lang/String;"));
+                assertThat(entries, containsInAnyOrder(
+                                newMethod(baseClass, "a", "()Ljava/lang/String;"),
+                                newMethod(subClassAA, "a", "()Ljava/lang/String;")
+                ));
+
+                // doBaseThings()
+                entries = resolver.resolveEquivalentMethods(newMethod(baseClass, "a", "()V"));
+                assertThat(entries, containsInAnyOrder(
+                                newMethod(baseClass, "a", "()V"),
+                                newMethod(subClassAA, "a", "()V"),
+                                newMethod(subClassB, "a", "()V")
+                ));
+                entries = resolver.resolveEquivalentMethods(newMethod(subClassAA, "a", "()V"));
+                assertThat(entries, containsInAnyOrder(
+                                newMethod(baseClass, "a", "()V"),
+                                newMethod(subClassAA, "a", "()V"),
+                                newMethod(subClassB, "a", "()V")
+                ));
+                entries = resolver.resolveEquivalentMethods(newMethod(subClassB, "a", "()V"));
+                assertThat(entries, containsInAnyOrder(
+                                newMethod(baseClass, "a", "()V"),
+                                newMethod(subClassAA, "a", "()V"),
+                                newMethod(subClassB, "a", "()V")
+                ));
+
+                // doBThings
+                entries = resolver.resolveEquivalentMethods(newMethod(subClassB, "b", "()V"));
+                assertThat(entries, containsInAnyOrder(newMethod(subClassB, "b", "()V")));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void fieldReferences() {
+                Collection<EntryReference<FieldEntry, MethodDefEntry>> references;
+
+                // name
+                references = index.getReferenceIndex().getReferencesToField(nameField);
+                assertThat(references, containsInAnyOrder(
+                                newFieldReferenceByMethod(nameField, baseClass.getName(), "<init>", "(Ljava/lang/String;)V"),
+                                newFieldReferenceByMethod(nameField, baseClass.getName(), "a", "()Ljava/lang/String;")
+                ));
+
+                // numThings
+                references = index.getReferenceIndex().getReferencesToField(numThingsField);
+                assertThat(references, containsInAnyOrder(
+                                newFieldReferenceByMethod(numThingsField, subClassB.getName(), "<init>", "()V"),
+                                newFieldReferenceByMethod(numThingsField, subClassB.getName(), "b", "()V")
+                ));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void behaviorReferences() {
+
+                MethodEntry source;
+                Collection<EntryReference<MethodEntry, MethodDefEntry>> references;
+
+                // baseClass constructor
+                source = newMethod(baseClass, "<init>", "(Ljava/lang/String;)V");
+                references = index.getReferenceIndex().getReferencesToMethod(source);
+                assertThat(references, containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, subClassA.getName(), "<init>", "(Ljava/lang/String;)V"),
+                                newBehaviorReferenceByMethod(source, subClassB.getName(), "<init>", "()V")
+                ));
+
+                // subClassA constructor
+                source = newMethod(subClassA, "<init>", "(Ljava/lang/String;)V");
+                references = index.getReferenceIndex().getReferencesToMethod(source);
+                assertThat(references, containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, subClassAA.getName(), "<init>", "()V")
+                ));
+
+                // baseClass.getName()
+                source = newMethod(baseClass, "a", "()Ljava/lang/String;");
+                references = index.getReferenceIndex().getReferencesToMethod(source);
+                assertThat(references, containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()Ljava/lang/String;"),
+                                newBehaviorReferenceByMethod(source, subClassB.getName(), "a", "()V")
+                ));
+
+                // subclassAA.getName()
+                source = newMethod(subClassAA, "a", "()Ljava/lang/String;");
+                references = index.getReferenceIndex().getReferencesToMethod(source);
+                assertThat(references, containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()V")
+                ));
+        }
+
+        @Test
+        public void containsEntries() {
+                EntryIndex entryIndex = index.getEntryIndex();
+                // classes
+                assertThat(entryIndex.hasClass(baseClass), is(true));
+                assertThat(entryIndex.hasClass(subClassA), is(true));
+                assertThat(entryIndex.hasClass(subClassAA), is(true));
+                assertThat(entryIndex.hasClass(subClassB), is(true));
+
+                // fields
+                assertThat(entryIndex.hasField(nameField), is(true));
+                assertThat(entryIndex.hasField(numThingsField), is(true));
+
+                // methods
+                // getName()
+                assertThat(entryIndex.hasMethod(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false));
+
+                // doBaseThings()
+                assertThat(entryIndex.hasMethod(newMethod(baseClass, "a", "()V")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(subClassA, "a", "()V")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassAA, "a", "()V")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(subClassB, "a", "()V")), is(true));
+
+                // doBThings()
+                assertThat(entryIndex.hasMethod(newMethod(baseClass, "b", "()V")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassA, "b", "()V")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassAA, "b", "()V")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassB, "b", "()V")), is(true));
+
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java b/enigma/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
new file mode 100644
index 0000000..103c366
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
@@ -0,0 +1,157 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.analysis.*;
+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.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import org.junit.Test;
+
+import java.nio.file.Paths;
+import java.util.Collection;
+import java.util.List;
+
+import static cuchaz.enigma.TestEntryFactory.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+public class TestJarIndexLoneClass {
+
+        private JarIndex index;
+
+        public TestJarIndexLoneClass() throws Exception {
+                ClassCache classCache = ClassCache.of(Paths.get("build/test-obf/loneClass.jar"));
+                index = classCache.index(ProgressListener.none());
+        }
+
+        @Test
+        public void obfEntries() {
+                assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(
+                                newClass("cuchaz/enigma/inputs/Keep"),
+                                newClass("a")
+                ));
+        }
+
+        @Test
+        public void translationIndex() {
+                InheritanceIndex inheritanceIndex = index.getInheritanceIndex();
+                assertThat(inheritanceIndex.getParents(new ClassEntry("a")), is(empty()));
+                assertThat(inheritanceIndex.getParents(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+                assertThat(inheritanceIndex.getAncestors(new ClassEntry("a")), is(empty()));
+                assertThat(inheritanceIndex.getAncestors(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+                assertThat(inheritanceIndex.getChildren(new ClassEntry("a")), is(empty()));
+                assertThat(inheritanceIndex.getChildren(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+        }
+
+        @Test
+        public void access() {
+                EntryIndex entryIndex = index.getEntryIndex();
+                assertThat(entryIndex.getFieldAccess(newField("a", "a", "Ljava/lang/String;")), is(AccessFlags.PRIVATE));
+                assertThat(entryIndex.getMethodAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(AccessFlags.PUBLIC));
+                assertThat(entryIndex.getFieldAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue()));
+                assertThat(entryIndex.getFieldAccess(newField("a", "a", "LFoo;")), is(nullValue()));
+        }
+
+        @Test
+        public void classInheritance() {
+                IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index);
+                ClassInheritanceTreeNode node = treeBuilder.buildClassInheritance(VoidTranslator.INSTANCE, newClass("a"));
+                assertThat(node, is(not(nullValue())));
+                assertThat(node.getObfClassName(), is("a"));
+                assertThat(node.getChildCount(), is(0));
+        }
+
+        @Test
+        public void methodInheritance() {
+                IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index);
+                MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;");
+                MethodInheritanceTreeNode node = treeBuilder.buildMethodInheritance(VoidTranslator.INSTANCE, source);
+                assertThat(node, is(not(nullValue())));
+                assertThat(node.getMethodEntry(), is(source));
+                assertThat(node.getChildCount(), is(0));
+        }
+
+        @Test
+        public void classImplementations() {
+                IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index);
+                ClassImplementationsTreeNode node = treeBuilder.buildClassImplementations(VoidTranslator.INSTANCE, newClass("a"));
+                assertThat(node, is(nullValue()));
+        }
+
+        @Test
+        public void methodImplementations() {
+                IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index);
+                MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;");
+
+                List<MethodImplementationsTreeNode> nodes = treeBuilder.buildMethodImplementations(VoidTranslator.INSTANCE, source);
+                assertThat(nodes, hasSize(1));
+                assertThat(nodes.get(0).getMethodEntry(), is(source));
+        }
+
+        @Test
+        public void relatedMethodImplementations() {
+                Collection<MethodEntry> entries = index.getEntryResolver().resolveEquivalentMethods(newMethod("a", "a", "()Ljava/lang/String;"));
+                assertThat(entries, containsInAnyOrder(
+                                newMethod("a", "a", "()Ljava/lang/String;")
+                ));
+        }
+
+        @Test
+        @SuppressWarnings("unchecked")
+        public void fieldReferences() {
+                FieldEntry source = newField("a", "a", "Ljava/lang/String;");
+                Collection<EntryReference<FieldEntry, MethodDefEntry>> references = index.getReferenceIndex().getReferencesToField(source);
+                assertThat(references, containsInAnyOrder(
+                                newFieldReferenceByMethod(source, "a", "<init>", "(Ljava/lang/String;)V"),
+                                newFieldReferenceByMethod(source, "a", "a", "()Ljava/lang/String;")
+                ));
+        }
+
+        @Test
+        public void behaviorReferences() {
+                assertThat(index.getReferenceIndex().getReferencesToMethod(newMethod("a", "a", "()Ljava/lang/String;")), is(empty()));
+        }
+
+        @Test
+        public void interfaces() {
+                assertThat(index.getInheritanceIndex().getParents(new ClassEntry("a")), is(empty()));
+        }
+
+        @Test
+        public void implementingClasses() {
+                assertThat(index.getInheritanceIndex().getChildren(new ClassEntry("a")), is(empty()));
+        }
+
+        @Test
+        public void isInterface() {
+                assertThat(index.getInheritanceIndex().isParent(new ClassEntry("a")), is(false));
+        }
+
+        @Test
+        public void testContains() {
+                EntryIndex entryIndex = index.getEntryIndex();
+                assertThat(entryIndex.hasClass(newClass("a")), is(true));
+                assertThat(entryIndex.hasClass(newClass("b")), is(false));
+                assertThat(entryIndex.hasField(newField("a", "a", "Ljava/lang/String;")), is(true));
+                assertThat(entryIndex.hasField(newField("a", "b", "Ljava/lang/String;")), is(false));
+                assertThat(entryIndex.hasField(newField("a", "a", "LFoo;")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod("a", "a", "()Ljava/lang/String;")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod("a", "b", "()Ljava/lang/String;")), is(false));
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestMethodDescriptor.java b/enigma/src/test/java/cuchaz/enigma/TestMethodDescriptor.java
new file mode 100644
index 0000000..a73880d
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestMethodDescriptor.java
@@ -0,0 +1,247 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import org.junit.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+public class TestMethodDescriptor {
+
+        @Test
+        public void easiest() {
+                final MethodDescriptor sig = new MethodDescriptor("()V");
+                assertThat(sig.getArgumentDescs(), is(empty()));
+                assertThat(sig.getReturnDesc(), is(new TypeDescriptor("V")));
+        }
+
+        @Test
+        public void primitives() {
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("(I)V");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("I")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("V")));
+                }
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("(I)I");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("I")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("I")));
+                }
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("(IBCJ)Z");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("I"),
+                                        new TypeDescriptor("B"),
+                                        new TypeDescriptor("C"),
+                                        new TypeDescriptor("J")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("Z")));
+                }
+        }
+
+        @Test
+        public void classes() {
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("([LFoo;)V");
+                        assertThat(sig.getArgumentDescs().size(), is(1));
+                        assertThat(sig.getArgumentDescs().get(0), is(new TypeDescriptor("[LFoo;")));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("V")));
+                }
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("(LFoo;)LBar;");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("LFoo;")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("LBar;")));
+                }
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("(LFoo;LMoo;LZoo;)LBar;");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("LFoo;"),
+                                        new TypeDescriptor("LMoo;"),
+                                        new TypeDescriptor("LZoo;")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("LBar;")));
+                }
+        }
+
+        @Test
+        public void arrays() {
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("([I)V");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("[I")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("V")));
+                }
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("([I)[J");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("[I")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("[J")));
+                }
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("([I[Z[F)[D");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("[I"),
+                                        new TypeDescriptor("[Z"),
+                                        new TypeDescriptor("[F")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("[D")));
+                }
+        }
+
+        @Test
+        public void mixed() {
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("(I[JLFoo;)Z");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("I"),
+                                        new TypeDescriptor("[J"),
+                                        new TypeDescriptor("LFoo;")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("Z")));
+                }
+                {
+                        final MethodDescriptor sig = new MethodDescriptor("(III)[LFoo;");
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("I"),
+                                        new TypeDescriptor("I"),
+                                        new TypeDescriptor("I")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("[LFoo;")));
+                }
+        }
+
+        @Test
+        public void replaceClasses() {
+                {
+                        final MethodDescriptor oldSig = new MethodDescriptor("()V");
+                        final MethodDescriptor sig = oldSig.remap(s -> null);
+                        assertThat(sig.getArgumentDescs(), is(empty()));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("V")));
+                }
+                {
+                        final MethodDescriptor oldSig = new MethodDescriptor("(IJLFoo;)V");
+                        final MethodDescriptor sig = oldSig.remap(s -> null);
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("I"),
+                                        new TypeDescriptor("J"),
+                                        new TypeDescriptor("LFoo;")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("V")));
+                }
+                {
+                        final MethodDescriptor oldSig = new MethodDescriptor("(LFoo;LBar;)LMoo;");
+                        final MethodDescriptor sig = oldSig.remap(s -> {
+                                if (s.equals("Foo")) {
+                                        return "Bar";
+                                }
+                                return null;
+                        });
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("LBar;"),
+                                        new TypeDescriptor("LBar;")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("LMoo;")));
+                }
+                {
+                        final MethodDescriptor oldSig = new MethodDescriptor("(LFoo;LBar;)LMoo;");
+                        final MethodDescriptor sig = oldSig.remap(s -> {
+                                if (s.equals("Moo")) {
+                                        return "Cow";
+                                }
+                                return null;
+                        });
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("LFoo;"),
+                                        new TypeDescriptor("LBar;")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("LCow;")));
+                }
+        }
+
+        @Test
+        public void replaceArrayClasses() {
+                {
+                        final MethodDescriptor oldSig = new MethodDescriptor("([LFoo;)[[[LBar;");
+                        final MethodDescriptor sig = oldSig.remap(s -> {
+                                if (s.equals("Foo")) {
+                                        return "Food";
+                                } else if (s.equals("Bar")) {
+                                        return "Beer";
+                                }
+                                return null;
+                        });
+                        assertThat(sig.getArgumentDescs(), contains(
+                                        new TypeDescriptor("[LFood;")
+                        ));
+                        assertThat(sig.getReturnDesc(), is(new TypeDescriptor("[[[LBeer;")));
+                }
+        }
+
+        @Test
+        public void equals() {
+
+                // base
+                assertThat(new MethodDescriptor("()V"), is(new MethodDescriptor("()V")));
+
+                // arguments
+                assertThat(new MethodDescriptor("(I)V"), is(new MethodDescriptor("(I)V")));
+                assertThat(new MethodDescriptor("(ZIZ)V"), is(new MethodDescriptor("(ZIZ)V")));
+                assertThat(new MethodDescriptor("(LFoo;)V"), is(new MethodDescriptor("(LFoo;)V")));
+                assertThat(new MethodDescriptor("(LFoo;LBar;)V"), is(new MethodDescriptor("(LFoo;LBar;)V")));
+                assertThat(new MethodDescriptor("([I)V"), is(new MethodDescriptor("([I)V")));
+                assertThat(new MethodDescriptor("([[D[[[J)V"), is(new MethodDescriptor("([[D[[[J)V")));
+
+                assertThat(new MethodDescriptor("()V"), is(not(new MethodDescriptor("(I)V"))));
+                assertThat(new MethodDescriptor("(I)V"), is(not(new MethodDescriptor("()V"))));
+                assertThat(new MethodDescriptor("(IJ)V"), is(not(new MethodDescriptor("(JI)V"))));
+                assertThat(new MethodDescriptor("([[Z)V"), is(not(new MethodDescriptor("([[LFoo;)V"))));
+                assertThat(new MethodDescriptor("(LFoo;LBar;)V"), is(not(new MethodDescriptor("(LFoo;LCow;)V"))));
+                assertThat(new MethodDescriptor("([LFoo;LBar;)V"), is(not(new MethodDescriptor("(LFoo;LCow;)V"))));
+
+                // return desc
+                assertThat(new MethodDescriptor("()I"), is(new MethodDescriptor("()I")));
+                assertThat(new MethodDescriptor("()Z"), is(new MethodDescriptor("()Z")));
+                assertThat(new MethodDescriptor("()[D"), is(new MethodDescriptor("()[D")));
+                assertThat(new MethodDescriptor("()[[[Z"), is(new MethodDescriptor("()[[[Z")));
+                assertThat(new MethodDescriptor("()LFoo;"), is(new MethodDescriptor("()LFoo;")));
+                assertThat(new MethodDescriptor("()[LFoo;"), is(new MethodDescriptor("()[LFoo;")));
+
+                assertThat(new MethodDescriptor("()I"), is(not(new MethodDescriptor("()Z"))));
+                assertThat(new MethodDescriptor("()Z"), is(not(new MethodDescriptor("()I"))));
+                assertThat(new MethodDescriptor("()[D"), is(not(new MethodDescriptor("()[J"))));
+                assertThat(new MethodDescriptor("()[[[Z"), is(not(new MethodDescriptor("()[[Z"))));
+                assertThat(new MethodDescriptor("()LFoo;"), is(not(new MethodDescriptor("()LBar;"))));
+                assertThat(new MethodDescriptor("()[LFoo;"), is(not(new MethodDescriptor("()[LBar;"))));
+        }
+
+        @Test
+        public void testToString() {
+                assertThat(new MethodDescriptor("()V").toString(), is("()V"));
+                assertThat(new MethodDescriptor("(I)V").toString(), is("(I)V"));
+                assertThat(new MethodDescriptor("(ZIZ)V").toString(), is("(ZIZ)V"));
+                assertThat(new MethodDescriptor("(LFoo;)V").toString(), is("(LFoo;)V"));
+                assertThat(new MethodDescriptor("(LFoo;LBar;)V").toString(), is("(LFoo;LBar;)V"));
+                assertThat(new MethodDescriptor("([I)V").toString(), is("([I)V"));
+                assertThat(new MethodDescriptor("([[D[[[J)V").toString(), is("([[D[[[J)V"));
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestTokensConstructors.java b/enigma/src/test/java/cuchaz/enigma/TestTokensConstructors.java
new file mode 100644
index 0000000..0398de4
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestTokensConstructors.java
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import org.junit.Test;
+
+import java.nio.file.Paths;
+
+import static cuchaz.enigma.TestEntryFactory.newBehaviorReferenceByMethod;
+import static cuchaz.enigma.TestEntryFactory.newMethod;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+public class TestTokensConstructors extends TokenChecker {
+
+        public TestTokensConstructors()
+                        throws Exception {
+                super(Paths.get("build/test-obf/constructors.jar"));
+        }
+
+        @Test
+        public void baseDeclarations() {
+                assertThat(getDeclarationToken(newMethod("a", "<init>", "()V")), is("a"));
+                assertThat(getDeclarationToken(newMethod("a", "<init>", "(I)V")), is("a"));
+        }
+
+        @Test
+        public void subDeclarations() {
+                assertThat(getDeclarationToken(newMethod("d", "<init>", "()V")), is("d"));
+                assertThat(getDeclarationToken(newMethod("d", "<init>", "(I)V")), is("d"));
+                assertThat(getDeclarationToken(newMethod("d", "<init>", "(II)V")), is("d"));
+                assertThat(getDeclarationToken(newMethod("d", "<init>", "(III)V")), is("d"));
+        }
+
+        @Test
+        public void subsubDeclarations() {
+                assertThat(getDeclarationToken(newMethod("e", "<init>", "(I)V")), is("e"));
+        }
+
+        @Test
+        public void defaultDeclarations() {
+                assertThat(getDeclarationToken(newMethod("c", "<init>", "()V")), nullValue());
+        }
+
+        @Test
+        public void baseDefaultReferences() {
+                MethodEntry source = newMethod("a", "<init>", "()V");
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "a", "()V")),
+                                containsInAnyOrder("a")
+                );
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "d", "<init>", "()V")),
+                                is(empty()) // implicit call, not decompiled to token
+                );
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "d", "<init>", "(III)V")),
+                                is(empty()) // implicit call, not decompiled to token
+                );
+        }
+
+        @Test
+        public void baseIntReferences() {
+                MethodEntry source = newMethod("a", "<init>", "(I)V");
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "b", "()V")),
+                                containsInAnyOrder("a")
+                );
+        }
+
+        @Test
+        public void subDefaultReferences() {
+                MethodEntry source = newMethod("d", "<init>", "()V");
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "c", "()V")),
+                                containsInAnyOrder("d")
+                );
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "d", "<init>", "(I)V")),
+                                containsInAnyOrder("this")
+                );
+        }
+
+        @Test
+        public void subIntReferences() {
+                MethodEntry source = newMethod("d", "<init>", "(I)V");
+                assertThat(getReferenceTokens(
+                                newBehaviorReferenceByMethod(source, "b", "d", "()V")),
+                                containsInAnyOrder("d")
+                );
+                assertThat(getReferenceTokens(
+                                newBehaviorReferenceByMethod(source, "d", "<init>", "(II)V")),
+                                containsInAnyOrder("this")
+                );
+                assertThat(getReferenceTokens(
+                                newBehaviorReferenceByMethod(source, "e", "<init>", "(I)V")),
+                                containsInAnyOrder("super")
+                );
+        }
+
+        @Test
+        public void subIntIntReferences() {
+                MethodEntry source = newMethod("d", "<init>", "(II)V");
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "e", "()V")),
+                                containsInAnyOrder("d")
+                );
+        }
+
+        @Test
+        public void subsubIntReferences() {
+                MethodEntry source = newMethod("e", "<init>", "(I)V");
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "f", "()V")),
+                                containsInAnyOrder("e")
+                );
+        }
+
+        @Test
+        public void defaultConstructableReferences() {
+                MethodEntry source = newMethod("c", "<init>", "()V");
+                assertThat(
+                                getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "g", "()V")),
+                                containsInAnyOrder("c")
+                );
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestTranslator.java b/enigma/src/test/java/cuchaz/enigma/TestTranslator.java
new file mode 100644
index 0000000..a420afe
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestTranslator.java
@@ -0,0 +1,155 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.translation.representation.entry.Entry;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static cuchaz.enigma.TestEntryFactory.*;
+
+public class TestTranslator {
+
+        @BeforeClass
+        public static void beforeClass()
+                throws Exception {
+                //TODO FIx
+                //deobfuscator = new Enigma(new JarFile("build/test-obf/translation.jar"));
+                //try (InputStream in = TestTranslator.class.getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) {
+                //      mappings = new MappingsJsonReader().read(new InputStreamReader(in));
+                //      deobfuscator.setMappings(mappings);
+                //      deobfTranslator = deobfuscator.getTranslator(TranslationDirection.Deobfuscating);
+                //      obfTranslator = deobfuscator.getTranslator(TranslationDirection.Obfuscating);
+                //}
+        }
+
+        @Test
+        public void basicClasses() {
+                assertMapping(newClass("a"), newClass("deobf/A_Basic"));
+                assertMapping(newClass("b"), newClass("deobf/B_BaseClass"));
+                assertMapping(newClass("c"), newClass("deobf/C_SubClass"));
+        }
+
+        @Test
+        public void basicFields() {
+                assertMapping(newField("a", "a", "I"), newField("deobf/A_Basic", "f1", "I"));
+                assertMapping(newField("a", "a", "F"), newField("deobf/A_Basic", "f2", "F"));
+                assertMapping(newField("a", "a", "Ljava/lang/String;"), newField("deobf/A_Basic", "f3", "Ljava/lang/String;"));
+        }
+
+        @Test
+        public void basicMethods() {
+                assertMapping(newMethod("a", "a", "()V"), newMethod("deobf/A_Basic", "m1", "()V"));
+                assertMapping(newMethod("a", "a", "()I"), newMethod("deobf/A_Basic", "m2", "()I"));
+                assertMapping(newMethod("a", "a", "(I)V"), newMethod("deobf/A_Basic", "m3", "(I)V"));
+                assertMapping(newMethod("a", "a", "(I)I"), newMethod("deobf/A_Basic", "m4", "(I)I"));
+        }
+
+        // TODO: basic constructors
+
+        @Test
+        public void inheritanceFields() {
+                assertMapping(newField("b", "a", "I"), newField("deobf/B_BaseClass", "f1", "I"));
+                assertMapping(newField("b", "a", "C"), newField("deobf/B_BaseClass", "f2", "C"));
+                assertMapping(newField("c", "b", "I"), newField("deobf/C_SubClass", "f3", "I"));
+                assertMapping(newField("c", "c", "I"), newField("deobf/C_SubClass", "f4", "I"));
+        }
+
+        @Test
+        public void inheritanceFieldsShadowing() {
+                assertMapping(newField("c", "b", "C"), newField("deobf/C_SubClass", "f2", "C"));
+        }
+
+        @Test
+        public void inheritanceFieldsBySubClass() {
+                assertMapping(newField("c", "a", "I"), newField("deobf/C_SubClass", "f1", "I"));
+                // NOTE: can't reference b.C by subclass since it's shadowed
+        }
+
+        @Test
+        public void inheritanceMethods() {
+                assertMapping(newMethod("b", "a", "()I"), newMethod("deobf/B_BaseClass", "m1", "()I"));
+                assertMapping(newMethod("b", "b", "()I"), newMethod("deobf/B_BaseClass", "m2", "()I"));
+                assertMapping(newMethod("c", "c", "()I"), newMethod("deobf/C_SubClass", "m3", "()I"));
+        }
+
+        @Test
+        public void inheritanceMethodsOverrides() {
+                assertMapping(newMethod("c", "a", "()I"), newMethod("deobf/C_SubClass", "m1", "()I"));
+        }
+
+        @Test
+        public void inheritanceMethodsBySubClass() {
+                assertMapping(newMethod("c", "b", "()I"), newMethod("deobf/C_SubClass", "m2", "()I"));
+        }
+
+        @Test
+        public void innerClasses() {
+
+                // classes
+                assertMapping(newClass("g"), newClass("deobf/G_OuterClass"));
+                assertMapping(newClass("g$a"), newClass("deobf/G_OuterClass$A_InnerClass"));
+                assertMapping(newClass("g$a$a"), newClass("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass"));
+                assertMapping(newClass("g$b"), newClass("deobf/G_OuterClass$b"));
+                assertMapping(newClass("g$b$a"), newClass("deobf/G_OuterClass$b$A_NamedInnerClass"));
+
+                // fields
+                assertMapping(newField("g$a", "a", "I"), newField("deobf/G_OuterClass$A_InnerClass", "f1", "I"));
+                assertMapping(newField("g$a", "a", "Ljava/lang/String;"), newField("deobf/G_OuterClass$A_InnerClass", "f2", "Ljava/lang/String;"));
+                assertMapping(newField("g$a$a", "a", "I"), newField("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass", "f3", "I"));
+                assertMapping(newField("g$b$a", "a", "I"), newField("deobf/G_OuterClass$b$A_NamedInnerClass", "f4", "I"));
+
+                // methods
+                assertMapping(newMethod("g$a", "a", "()V"), newMethod("deobf/G_OuterClass$A_InnerClass", "m1", "()V"));
+                assertMapping(newMethod("g$a$a", "a", "()V"), newMethod("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass", "m2", "()V"));
+        }
+
+        @Test
+        public void namelessClass() {
+                assertMapping(newClass("h"), newClass("h"));
+        }
+
+        @Test
+        public void testGenerics() {
+
+                // classes
+                assertMapping(newClass("i"), newClass("deobf/I_Generics"));
+                assertMapping(newClass("i$a"), newClass("deobf/I_Generics$A_Type"));
+                assertMapping(newClass("i$b"), newClass("deobf/I_Generics$B_Generic"));
+
+                // fields
+                assertMapping(newField("i", "a", "Ljava/util/List;"), newField("deobf/I_Generics", "f1", "Ljava/util/List;"));
+                assertMapping(newField("i", "b", "Ljava/util/List;"), newField("deobf/I_Generics", "f2", "Ljava/util/List;"));
+                assertMapping(newField("i", "a", "Ljava/util/Map;"), newField("deobf/I_Generics", "f3", "Ljava/util/Map;"));
+                assertMapping(newField("i$b", "a", "Ljava/lang/Object;"), newField("deobf/I_Generics$B_Generic", "f4", "Ljava/lang/Object;"));
+                assertMapping(newField("i", "a", "Li$b;"), newField("deobf/I_Generics", "f5", "Ldeobf/I_Generics$B_Generic;"));
+                assertMapping(newField("i", "b", "Li$b;"), newField("deobf/I_Generics", "f6", "Ldeobf/I_Generics$B_Generic;"));
+
+                // methods
+                assertMapping(newMethod("i$b", "a", "()Ljava/lang/Object;"), newMethod("deobf/I_Generics$B_Generic", "m1", "()Ljava/lang/Object;"));
+        }
+
+        private void assertMapping(Entry<?> obf, Entry<?> deobf) {
+                //assertThat(deobfTranslator.translateEntry(obf), is(deobf));
+                //assertThat(obfTranslator.translateEntry(deobf), is(obf));
+
+                //String deobfName = deobfTranslator.translate(obf);
+                //if (deobfName != null) {
+                //      assertThat(deobfName, is(deobf.getName()));
+                //}
+
+                //String obfName = obfTranslator.translate(deobf);
+                //if (obfName != null) {
+                //      assertThat(obfName, is(obf.getName()));
+                //}
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TestTypeDescriptor.java b/enigma/src/test/java/cuchaz/enigma/TestTypeDescriptor.java
new file mode 100644
index 0000000..b9ebe55
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TestTypeDescriptor.java
@@ -0,0 +1,243 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import org.junit.Test;
+
+import static cuchaz.enigma.TestEntryFactory.newClass;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+
+public class TestTypeDescriptor {
+
+        @Test
+        public void isVoid() {
+                assertThat(new TypeDescriptor("V").isVoid(), is(true));
+                assertThat(new TypeDescriptor("Z").isVoid(), is(false));
+                assertThat(new TypeDescriptor("B").isVoid(), is(false));
+                assertThat(new TypeDescriptor("C").isVoid(), is(false));
+                assertThat(new TypeDescriptor("I").isVoid(), is(false));
+                assertThat(new TypeDescriptor("J").isVoid(), is(false));
+                assertThat(new TypeDescriptor("F").isVoid(), is(false));
+                assertThat(new TypeDescriptor("D").isVoid(), is(false));
+                assertThat(new TypeDescriptor("LFoo;").isVoid(), is(false));
+                assertThat(new TypeDescriptor("[I").isVoid(), is(false));
+        }
+
+        @Test
+        public void isPrimitive() {
+                assertThat(new TypeDescriptor("V").isPrimitive(), is(false));
+                assertThat(new TypeDescriptor("Z").isPrimitive(), is(true));
+                assertThat(new TypeDescriptor("B").isPrimitive(), is(true));
+                assertThat(new TypeDescriptor("C").isPrimitive(), is(true));
+                assertThat(new TypeDescriptor("I").isPrimitive(), is(true));
+                assertThat(new TypeDescriptor("J").isPrimitive(), is(true));
+                assertThat(new TypeDescriptor("F").isPrimitive(), is(true));
+                assertThat(new TypeDescriptor("D").isPrimitive(), is(true));
+                assertThat(new TypeDescriptor("LFoo;").isPrimitive(), is(false));
+                assertThat(new TypeDescriptor("[I").isPrimitive(), is(false));
+        }
+
+        @Test
+        public void getPrimitive() {
+                assertThat(new TypeDescriptor("Z").getPrimitive(), is(TypeDescriptor.Primitive.BOOLEAN));
+                assertThat(new TypeDescriptor("B").getPrimitive(), is(TypeDescriptor.Primitive.BYTE));
+                assertThat(new TypeDescriptor("C").getPrimitive(), is(TypeDescriptor.Primitive.CHARACTER));
+                assertThat(new TypeDescriptor("I").getPrimitive(), is(TypeDescriptor.Primitive.INTEGER));
+                assertThat(new TypeDescriptor("J").getPrimitive(), is(TypeDescriptor.Primitive.LONG));
+                assertThat(new TypeDescriptor("F").getPrimitive(), is(TypeDescriptor.Primitive.FLOAT));
+                assertThat(new TypeDescriptor("D").getPrimitive(), is(TypeDescriptor.Primitive.DOUBLE));
+        }
+
+        @Test
+        public void isClass() {
+                assertThat(new TypeDescriptor("V").isType(), is(false));
+                assertThat(new TypeDescriptor("Z").isType(), is(false));
+                assertThat(new TypeDescriptor("B").isType(), is(false));
+                assertThat(new TypeDescriptor("C").isType(), is(false));
+                assertThat(new TypeDescriptor("I").isType(), is(false));
+                assertThat(new TypeDescriptor("J").isType(), is(false));
+                assertThat(new TypeDescriptor("F").isType(), is(false));
+                assertThat(new TypeDescriptor("D").isType(), is(false));
+                assertThat(new TypeDescriptor("LFoo;").isType(), is(true));
+                assertThat(new TypeDescriptor("[I").isType(), is(false));
+        }
+
+        @Test
+        public void getClassEntry() {
+                assertThat(new TypeDescriptor("LFoo;").getTypeEntry(), is(newClass("Foo")));
+                assertThat(new TypeDescriptor("Ljava/lang/String;").getTypeEntry(), is(newClass("java/lang/String")));
+        }
+
+        @Test
+        public void getArrayClassEntry() {
+                assertThat(new TypeDescriptor("[LFoo;").getTypeEntry(), is(newClass("Foo")));
+                assertThat(new TypeDescriptor("[[[Ljava/lang/String;").getTypeEntry(), is(newClass("java/lang/String")));
+        }
+
+        @Test
+        public void isArray() {
+                assertThat(new TypeDescriptor("V").isArray(), is(false));
+                assertThat(new TypeDescriptor("Z").isArray(), is(false));
+                assertThat(new TypeDescriptor("B").isArray(), is(false));
+                assertThat(new TypeDescriptor("C").isArray(), is(false));
+                assertThat(new TypeDescriptor("I").isArray(), is(false));
+                assertThat(new TypeDescriptor("J").isArray(), is(false));
+                assertThat(new TypeDescriptor("F").isArray(), is(false));
+                assertThat(new TypeDescriptor("D").isArray(), is(false));
+                assertThat(new TypeDescriptor("LFoo;").isArray(), is(false));
+                assertThat(new TypeDescriptor("[I").isArray(), is(true));
+        }
+
+        @Test
+        public void getArrayDimension() {
+                assertThat(new TypeDescriptor("[I").getArrayDimension(), is(1));
+                assertThat(new TypeDescriptor("[[I").getArrayDimension(), is(2));
+                assertThat(new TypeDescriptor("[[[I").getArrayDimension(), is(3));
+        }
+
+        @Test
+        public void getArrayType() {
+                assertThat(new TypeDescriptor("[I").getArrayType(), is(new TypeDescriptor("I")));
+                assertThat(new TypeDescriptor("[[I").getArrayType(), is(new TypeDescriptor("I")));
+                assertThat(new TypeDescriptor("[[[I").getArrayType(), is(new TypeDescriptor("I")));
+                assertThat(new TypeDescriptor("[Ljava/lang/String;").getArrayType(), is(new TypeDescriptor("Ljava/lang/String;")));
+        }
+
+        @Test
+        public void hasClass() {
+                assertThat(new TypeDescriptor("LFoo;").containsType(), is(true));
+                assertThat(new TypeDescriptor("Ljava/lang/String;").containsType(), is(true));
+                assertThat(new TypeDescriptor("[LBar;").containsType(), is(true));
+                assertThat(new TypeDescriptor("[[[LCat;").containsType(), is(true));
+
+                assertThat(new TypeDescriptor("V").containsType(), is(false));
+                assertThat(new TypeDescriptor("[I").containsType(), is(false));
+                assertThat(new TypeDescriptor("[[[I").containsType(), is(false));
+                assertThat(new TypeDescriptor("Z").containsType(), is(false));
+        }
+
+        @Test
+        public void parseVoid() {
+                final String answer = "V";
+                assertThat(TypeDescriptor.parseFirst("V"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("VVV"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("VIJ"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("V[I"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("VLFoo;"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("V[LFoo;"), is(answer));
+        }
+
+        @Test
+        public void parsePrimitive() {
+                final String answer = "I";
+                assertThat(TypeDescriptor.parseFirst("I"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("III"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("IJZ"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("I[I"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("ILFoo;"), is(answer));
+                assertThat(TypeDescriptor.parseFirst("I[LFoo;"), is(answer));
+        }
+
+        @Test
+        public void parseClass() {
+                {
+                        final String answer = "LFoo;";
+                        assertThat(TypeDescriptor.parseFirst("LFoo;"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("LFoo;I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("LFoo;JZ"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("LFoo;[I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("LFoo;LFoo;"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("LFoo;[LFoo;"), is(answer));
+                }
+                {
+                        final String answer = "Ljava/lang/String;";
+                        assertThat(TypeDescriptor.parseFirst("Ljava/lang/String;"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("Ljava/lang/String;I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("Ljava/lang/String;JZ"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("Ljava/lang/String;[I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("Ljava/lang/String;LFoo;"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("Ljava/lang/String;[LFoo;"), is(answer));
+                }
+        }
+
+        @Test
+        public void parseArray() {
+                {
+                        final String answer = "[I";
+                        assertThat(TypeDescriptor.parseFirst("[I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[III"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[IJZ"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[I[I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[ILFoo;"), is(answer));
+                }
+                {
+                        final String answer = "[[I";
+                        assertThat(TypeDescriptor.parseFirst("[[I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[[III"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[[IJZ"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[[I[I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[[ILFoo;"), is(answer));
+                }
+                {
+                        final String answer = "[LFoo;";
+                        assertThat(TypeDescriptor.parseFirst("[LFoo;"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[LFoo;II"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[LFoo;JZ"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[LFoo;[I"), is(answer));
+                        assertThat(TypeDescriptor.parseFirst("[LFoo;LFoo;"), is(answer));
+                }
+        }
+
+        @Test
+        public void equals() {
+                assertThat(new TypeDescriptor("V"), is(new TypeDescriptor("V")));
+                assertThat(new TypeDescriptor("Z"), is(new TypeDescriptor("Z")));
+                assertThat(new TypeDescriptor("B"), is(new TypeDescriptor("B")));
+                assertThat(new TypeDescriptor("C"), is(new TypeDescriptor("C")));
+                assertThat(new TypeDescriptor("I"), is(new TypeDescriptor("I")));
+                assertThat(new TypeDescriptor("J"), is(new TypeDescriptor("J")));
+                assertThat(new TypeDescriptor("F"), is(new TypeDescriptor("F")));
+                assertThat(new TypeDescriptor("D"), is(new TypeDescriptor("D")));
+                assertThat(new TypeDescriptor("LFoo;"), is(new TypeDescriptor("LFoo;")));
+                assertThat(new TypeDescriptor("[I"), is(new TypeDescriptor("[I")));
+                assertThat(new TypeDescriptor("[[[I"), is(new TypeDescriptor("[[[I")));
+                assertThat(new TypeDescriptor("[LFoo;"), is(new TypeDescriptor("[LFoo;")));
+
+                assertThat(new TypeDescriptor("V"), is(not(new TypeDescriptor("I"))));
+                assertThat(new TypeDescriptor("I"), is(not(new TypeDescriptor("J"))));
+                assertThat(new TypeDescriptor("I"), is(not(new TypeDescriptor("LBar;"))));
+                assertThat(new TypeDescriptor("I"), is(not(new TypeDescriptor("[I"))));
+                assertThat(new TypeDescriptor("LFoo;"), is(not(new TypeDescriptor("LBar;"))));
+                assertThat(new TypeDescriptor("[I"), is(not(new TypeDescriptor("[Z"))));
+                assertThat(new TypeDescriptor("[[[I"), is(not(new TypeDescriptor("[I"))));
+                assertThat(new TypeDescriptor("[LFoo;"), is(not(new TypeDescriptor("[LBar;"))));
+        }
+
+        @Test
+        public void testToString() {
+                assertThat(new TypeDescriptor("V").toString(), is("V"));
+                assertThat(new TypeDescriptor("Z").toString(), is("Z"));
+                assertThat(new TypeDescriptor("B").toString(), is("B"));
+                assertThat(new TypeDescriptor("C").toString(), is("C"));
+                assertThat(new TypeDescriptor("I").toString(), is("I"));
+                assertThat(new TypeDescriptor("J").toString(), is("J"));
+                assertThat(new TypeDescriptor("F").toString(), is("F"));
+                assertThat(new TypeDescriptor("D").toString(), is("D"));
+                assertThat(new TypeDescriptor("LFoo;").toString(), is("LFoo;"));
+                assertThat(new TypeDescriptor("[I").toString(), is("[I"));
+                assertThat(new TypeDescriptor("[[[I").toString(), is("[[[I"));
+                assertThat(new TypeDescriptor("[LFoo;").toString(), is("[LFoo;"));
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/TokenChecker.java b/enigma/src/test/java/cuchaz/enigma/TokenChecker.java
new file mode 100644
index 0000000..96fc6da
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/TokenChecker.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * 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;
+
+import com.google.common.collect.Lists;
+import cuchaz.enigma.analysis.ClassCache;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.source.SourceIndex;
+import cuchaz.enigma.source.*;
+import cuchaz.enigma.source.Token;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+
+public class TokenChecker {
+        private final Decompiler decompiler;
+
+        protected TokenChecker(Path path) throws IOException {
+                ClassCache classCache = ClassCache.of(path);
+                decompiler = Decompilers.PROCYON.create(classCache, new SourceSettings(false, false));
+        }
+
+        protected String getDeclarationToken(Entry<?> entry) {
+                // decompile the class
+                Source source = decompiler.getSource(entry.getContainingClass().getFullName());
+                // DEBUG
+                // tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null );
+                String string = source.asString();
+                SourceIndex index = source.index();
+
+                // get the token value
+                Token token = index.getDeclarationToken(entry);
+                if (token == null) {
+                        return null;
+                }
+                return string.substring(token.start, token.end);
+        }
+
+        @SuppressWarnings("unchecked")
+        protected Collection<String> getReferenceTokens(EntryReference<? extends Entry<?>, ? extends Entry<?>> reference) {
+                // decompile the class
+                Source source = decompiler.getSource(reference.context.getContainingClass().getFullName());
+                String string = source.asString();
+                SourceIndex index = source.index();
+
+                // get the token values
+                List<String> values = Lists.newArrayList();
+                for (Token token : index.getReferenceTokens((EntryReference<Entry<?>, Entry<?>>) reference)) {
+                        values.add(string.substring(token.start, token.end));
+                }
+                return values;
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/Keep.java b/enigma/src/test/java/cuchaz/enigma/inputs/Keep.java
new file mode 100644
index 0000000..4dbe8e2
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/Keep.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * 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.inputs;
+
+public class Keep {
+        public static void main(String[] args) {
+                System.out.println("Keep me!");
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/constructors/BaseClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/BaseClass.java
new file mode 100644
index 0000000..f07e1f8
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/BaseClass.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * 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.inputs.constructors;
+
+// a
+public class BaseClass {
+
+        // <init>()V
+        public BaseClass() {
+                System.out.println("Default constructor");
+        }
+
+        // <init>(I)V
+        public BaseClass(int i) {
+                System.out.println("Int constructor " + i);
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/constructors/Caller.java b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/Caller.java
new file mode 100644
index 0000000..71439fd
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/Caller.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * 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.inputs.constructors;
+
+// b
+public class Caller {
+
+        // a()V
+        public void callBaseDefault() {
+                // a.<init>()V
+                System.out.println(new BaseClass());
+        }
+
+        // b()V
+        public void callBaseInt() {
+                // a.<init>(I)V
+                System.out.println(new BaseClass(5));
+        }
+
+        // c()V
+        public void callSubDefault() {
+                // d.<init>()V
+                System.out.println(new SubClass());
+        }
+
+        // d()V
+        public void callSubInt() {
+                // d.<init>(I)V
+                System.out.println(new SubClass(6));
+        }
+
+        // e()V
+        public void callSubIntInt() {
+                // d.<init>(II)V
+                System.out.println(new SubClass(4, 2));
+        }
+
+        // f()V
+        public void callSubSubInt() {
+                // e.<init>(I)V
+                System.out.println(new SubSubClass(3));
+        }
+
+        // g()V
+        public void callDefaultConstructable() {
+                // c.<init>()V
+                System.out.println(new DefaultConstructable());
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/constructors/DefaultConstructable.java b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/DefaultConstructable.java
new file mode 100644
index 0000000..c3d4170
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/DefaultConstructable.java
@@ -0,0 +1,16 @@
+/*******************************************************************************
+ * 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.inputs.constructors;
+
+public class DefaultConstructable {
+        // only default constructor
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/constructors/SubClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/SubClass.java
new file mode 100644
index 0000000..bc56b3b
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/SubClass.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * 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.inputs.constructors;
+
+// d extends a
+public class SubClass extends BaseClass {
+
+        // <init>()V
+        public SubClass() {
+                // a.<init>()V
+        }
+
+        // <init>(I)V
+        public SubClass(int num) {
+                // <init>()V
+                this();
+                System.out.println("SubClass " + num);
+        }
+
+        // <init>(II)V
+        public SubClass(int a, int b) {
+                // <init>(I)V
+                this(a + b);
+        }
+
+        // <init>(III)V
+        public SubClass(int a, int b, int c) {
+                // a.<init>()V
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/constructors/SubSubClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/SubSubClass.java
new file mode 100644
index 0000000..87b69d3
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/constructors/SubSubClass.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * 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.inputs.constructors;
+
+// e extends d
+public class SubSubClass extends SubClass {
+
+        // <init>(I)V
+        public SubSubClass(int i) {
+                // c.<init>(I)V
+                super(i);
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
new file mode 100644
index 0000000..b9c4929
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * 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.inputs.inheritanceTree;
+
+// a
+public abstract class BaseClass {
+
+        // a
+        private String name;
+
+        // <init>(Ljava/lang/String;)V
+        protected BaseClass(String name) {
+                this.name = name;
+        }
+
+        // a()Ljava/lang/String;
+        public String getName() {
+                return name;
+        }
+
+        // a()V
+        public abstract void doBaseThings();
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java
new file mode 100644
index 0000000..50e963c
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * 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.inputs.inheritanceTree;
+
+// b extends a
+public abstract class SubclassA extends BaseClass {
+
+        // <init>(Ljava/lang/String;)V
+        protected SubclassA(String name) {
+                // call to a.<init>(Ljava/lang/String)V
+                super(name);
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
new file mode 100644
index 0000000..d0dd664
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * 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.inputs.inheritanceTree;
+
+// c extends a
+public class SubclassB extends BaseClass {
+
+        // a
+        private int numThings;
+
+        // <init>()V
+        protected SubclassB() {
+                // a.<init>(Ljava/lang/String;)V
+                super("B");
+
+                // access to a
+                numThings = 4;
+        }
+
+        @Override
+        // a()V
+        public void doBaseThings() {
+                // call to a.a()Ljava/lang/String;
+                System.out.println("Base things by B! " + getName());
+        }
+
+        // b()V
+        public void doBThings() {
+                // access to a
+                System.out.println("" + numThings + " B things!");
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java b/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java
new file mode 100644
index 0000000..c584570
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * 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.inputs.inheritanceTree;
+
+// d extends b
+public class SubsubclassAA extends SubclassA {
+
+        protected SubsubclassAA() {
+                // call to b.<init>(Ljava/lang/String;)V
+                super("AA");
+        }
+
+        @Override
+        // a()Ljava/lang/String;
+        public String getName() {
+                // call to b.a()Ljava/lang/String;
+                return "subsub" + super.getName();
+        }
+
+        @Override
+        // a()V
+        public void doBaseThings() {
+                // call to d.a()Ljava/lang/String;
+                System.out.println("Base things by " + getName());
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java
new file mode 100644
index 0000000..f652d87
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * 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.inputs.innerClasses;
+
+public class A_Anonymous {
+
+        public void foo() {
+                Runnable runnable = new Runnable() {
+                        @Override
+                        public void run() {
+                                // don't care
+                        }
+                };
+                runnable.run();
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java
new file mode 100644
index 0000000..d1b7601
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * 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.inputs.innerClasses;
+
+public class B_AnonymousWithScopeArgs {
+
+        public static void foo(final D_Simple arg) {
+                System.out.println(new Object() {
+                        @Override
+                        public String toString() {
+                                return arg.toString();
+                        }
+                });
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java
new file mode 100644
index 0000000..94061fa
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * 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.inputs.innerClasses;
+
+@SuppressWarnings("unused")
+public class C_ConstructorArgs {
+
+        Inner i;
+
+        public void foo() {
+                i = new Inner(5);
+        }
+
+        class Inner {
+
+                private int a;
+
+                public Inner(int a) {
+                        this.a = a;
+                }
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/D_Simple.java b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/D_Simple.java
new file mode 100644
index 0000000..71b3a6d
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/D_Simple.java
@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * 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.inputs.innerClasses;
+
+public class D_Simple {
+
+        class Inner {
+                // nothing to do
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java
new file mode 100644
index 0000000..976ec42
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * 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.inputs.innerClasses;
+
+public class E_AnonymousWithOuterAccess {
+
+        // reproduction of error case documented at:
+        // https://bitbucket.org/cuchaz/enigma/issue/61/stackoverflowerror-when-deobfuscating
+
+        public Object makeInner() {
+                outerMethod();
+                return new Object() {
+                        @Override
+                        public String toString() {
+                                return outerMethod();
+                        }
+                };
+        }
+
+        private String outerMethod() {
+                return "foo";
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/F_ClassTree.java b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/F_ClassTree.java
new file mode 100644
index 0000000..b1de3c9
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/innerClasses/F_ClassTree.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * 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.inputs.innerClasses;
+
+public class F_ClassTree {
+
+        public class Level1 {
+
+                public int f1;
+
+                public class Level2 {
+
+                        public int f2;
+
+                        public class Level3 {
+
+                                public int f3;
+                        }
+                }
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java
new file mode 100644
index 0000000..ddc4e31
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * 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.inputs.loneClass;
+
+public class LoneClass {
+
+        private String name;
+
+        public LoneClass(String name) {
+                this.name = name;
+        }
+
+        public String getName() {
+                return name;
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/Base.java b/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/Base.java
new file mode 100644
index 0000000..6f5fe30
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/Base.java
@@ -0,0 +1,7 @@
+package cuchaz.enigma.inputs.packageAccess;
+
+public class Base {
+        protected int make() {
+                return 42;
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/SamePackageChild.java b/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/SamePackageChild.java
new file mode 100644
index 0000000..cf0f657
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/SamePackageChild.java
@@ -0,0 +1,12 @@
+package cuchaz.enigma.inputs.packageAccess;
+
+public class SamePackageChild extends Base {
+
+        class Inner {
+                final int value;
+
+                Inner() {
+                        value = SamePackageChild.this.make(); // no synthetic method
+                }
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/sub/OtherPackageChild.java b/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/sub/OtherPackageChild.java
new file mode 100644
index 0000000..19fb19c
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/packageAccess/sub/OtherPackageChild.java
@@ -0,0 +1,14 @@
+package cuchaz.enigma.inputs.packageAccess.sub;
+
+import cuchaz.enigma.inputs.packageAccess.Base;
+
+public class OtherPackageChild extends Base {
+
+        class Inner {
+                final int value;
+
+                Inner() {
+                        value = OtherPackageChild.this.make(); // synthetic method call
+                }
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/A_Basic.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/A_Basic.java
new file mode 100644
index 0000000..26f3718
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/A_Basic.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+public class A_Basic {
+
+        public int one;
+        public float two;
+        public String three;
+
+        public void m1() {
+        }
+
+        public int m2() {
+                return 42;
+        }
+
+        public void m3(int a1) {
+        }
+
+        public int m4(int a1) {
+                return 5; // chosen by fair die roll, guaranteed to be random
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/B_BaseClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/B_BaseClass.java
new file mode 100644
index 0000000..fd7f6e7
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/B_BaseClass.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+public class B_BaseClass {
+
+        public int f1;
+        public char f2;
+
+        public int m1() {
+                return 5;
+        }
+
+        public int m2() {
+                return 42;
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/C_SubClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/C_SubClass.java
new file mode 100644
index 0000000..9d74e44
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/C_SubClass.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+public class C_SubClass extends B_BaseClass {
+
+        public char f2; // shadows B_BaseClass.f2
+        public int f3;
+        public int f4;
+
+        @Override
+        public int m1() {
+                return 32;
+        }
+
+        public int m3() {
+                return 7;
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/D_AnonymousTesting.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/D_AnonymousTesting.java
new file mode 100644
index 0000000..99c83bb
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/D_AnonymousTesting.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class D_AnonymousTesting {
+
+        public List<Object> getObjs() {
+                List<Object> objs = new ArrayList<Object>();
+                objs.add(new Object() {
+                        @Override
+                        public String toString() {
+                                return "Object!";
+                        }
+                });
+                return objs;
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/E_Bridges.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/E_Bridges.java
new file mode 100644
index 0000000..0b8cf2a
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/E_Bridges.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+import java.util.Iterator;
+
+public class E_Bridges implements Iterator<Object> {
+
+        @Override
+        public boolean hasNext() {
+                return false;
+        }
+
+        @Override
+        public String next() {
+                // the compiler will generate a bridge for this method
+                return "foo";
+        }
+
+        @Override
+        public void remove() {
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java
new file mode 100644
index 0000000..8a92792
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+@SuppressWarnings("FinalizeCalledExplicitly")
+public class F_ObjectMethods {
+
+        public void callEmAll()
+                throws Throwable {
+                clone();
+                equals(this);
+                finalize();
+                getClass();
+                hashCode();
+                notify();
+                notifyAll();
+                toString();
+                wait();
+                wait(0);
+                wait(0, 0);
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/G_OuterClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/G_OuterClass.java
new file mode 100644
index 0000000..a1e6a85
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/G_OuterClass.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+public class G_OuterClass {
+
+        public class A_InnerClass {
+
+                public int f1;
+                public String f2;
+
+                public void m1() {}
+
+                public class A_InnerInnerClass {
+
+                        public int f3;
+
+                        public void m2() {}
+                }
+        }
+
+        public class B_NamelessClass {
+                public class A_NamedInnerClass {
+                        public int f4;
+                }
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/H_NamelessClass.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/H_NamelessClass.java
new file mode 100644
index 0000000..013c55a
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/H_NamelessClass.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+public class H_NamelessClass {
+
+        public class A_InnerClass {
+
+                public int f1;
+                public String f2;
+
+                public void m1() {}
+
+                public class A_InnerInnerClass {
+
+                        public int f3;
+
+                        public void m2() {}
+                }
+        }
+
+        public class B_NamelessClass {
+                public class A_NamedInnerClass {
+                        public int f4;
+
+                        public class A_AnotherInnerClass {}
+
+                        public class B_YetAnotherInnerClass {}
+                }
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/inputs/translation/I_Generics.java b/enigma/src/test/java/cuchaz/enigma/inputs/translation/I_Generics.java
new file mode 100644
index 0000000..fd2ebdd
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/inputs/translation/I_Generics.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * 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.inputs.translation;
+
+import java.util.List;
+import java.util.Map;
+
+public class I_Generics {
+
+        public List<Integer> f1;
+        public List<A_Type> f2;
+        public Map<A_Type, A_Type> f3;
+        public B_Generic<Integer> f5;
+        public B_Generic<A_Type> f6;
+
+        public class A_Type {
+        }
+
+        public class B_Generic<T> {
+                public T f4;
+
+                public T m1() {
+                        return null;
+                }
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestComments.java b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestComments.java
new file mode 100644
index 0000000..e831943
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestComments.java
@@ -0,0 +1,39 @@
+package cuchaz.enigma.translation.mapping;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.mapping.serde.MappingFileNameFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsReader;
+import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer;
+import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import org.junit.Test;
+
+public class TestComments {
+    private static Path DIRECTORY;
+
+    static {
+        try {
+            DIRECTORY = Paths.get(TestTinyV2InnerClasses.class.getResource("/comments/").toURI());
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void testParseAndWrite() throws IOException, MappingParseException {
+        ProgressListener progressListener = ProgressListener.none();
+        MappingSaveParameters params = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
+        EntryTree<EntryMapping> mappings = EnigmaMappingsReader.DIRECTORY.read(
+                        DIRECTORY, progressListener, params);
+
+        new TinyV2Writer("intermediary", "named")
+                        .write(mappings, DIRECTORY.resolve("convertedtiny.tiny"), progressListener, params);
+    }
+
+}
\ No newline at end of file
diff --git a/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestTinyV2InnerClasses.java b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestTinyV2InnerClasses.java
new file mode 100644
index 0000000..65941e5
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestTinyV2InnerClasses.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * 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;
+
+import cuchaz.enigma.Enigma;
+import cuchaz.enigma.EnigmaProject;
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsReader;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public final class TestTinyV2InnerClasses {
+        private Path jar;
+        private Path mappings;
+
+        public TestTinyV2InnerClasses() throws Exception {
+                jar = Paths.get("build/test-obf/innerClasses.jar");
+                mappings = Paths.get(TestTinyV2InnerClasses.class.getResource("/tinyV2InnerClasses/").toURI());
+        }
+
+//      @Test
+        public void testMappings() throws Exception {
+                EnigmaProject project = Enigma.create().openJar(jar, ProgressListener.none());
+                project.setMappings(EnigmaMappingsReader.DIRECTORY.read(mappings, ProgressListener.none(), project.getEnigma().getProfile().getMappingSaveParameters()));
+
+        }
+}
diff --git a/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestV2Main.java b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestV2Main.java
new file mode 100644
index 0000000..6e4d7b9
--- /dev/null
+++ b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestV2Main.java
@@ -0,0 +1,23 @@
+package cuchaz.enigma.translation.mapping;
+
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.mapping.serde.MappingFileNameFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsReader;
+import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer;
+import cuchaz.enigma.translation.mapping.tree.EntryTree;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public final class TestV2Main {
+        public static void main(String... args) throws Exception {
+                Path path = Paths.get(TestV2Main.class.getResource("/tinyV2InnerClasses/").toURI());
+
+                MappingSaveParameters parameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
+
+                EntryTree<EntryMapping> tree = EnigmaMappingsReader.DIRECTORY.read(path, ProgressListener.none(), parameters);
+
+                new TinyV2Writer("obf", "deobf").write(tree, Paths.get("currentYarn.tiny"), ProgressListener.none(), parameters);
+        }
+}
diff --git a/enigma/src/test/resources/comments/test.mapping b/enigma/src/test/resources/comments/test.mapping
new file mode 100644
index 0000000..d134558
--- /dev/null
+++ b/enigma/src/test/resources/comments/test.mapping
@@ -0,0 +1,18 @@
+CLASS net/minecraft/class_1158 net/minecraft/util/math/Quaternion
+        COMMENT it circel
+        COMMENT next line
+        FIELD field_21493 IDENTITY Lnet/minecraft/class_1158;
+                COMMENT moar comment thing
+                COMMENT near field
+        METHOD foo bar (FFFF)V
+                COMMENT method comment
+                COMMENT second line
+                COMMENT third line
+                ARG 1 b
+                        COMMENT arg comment
+        CLASS old new
+                COMMENT inner comment
+                FIELD field_19263 iterator Lnet/minecraft/class_3980;
+                METHOD tryAdvance (Ljava/util/function/Consumer;)Z
+                        ARG 1 consumer
+                                COMMENT very inner comment
\ No newline at end of file
diff --git a/enigma/src/test/resources/proguard-build.conf b/enigma/src/test/resources/proguard-build.conf
new file mode 100644
index 0000000..691d8a2
--- /dev/null
+++ b/enigma/src/test/resources/proguard-build.conf
@@ -0,0 +1,6 @@
+-dontoptimize
+-dontobfuscate
+-dontwarn
+-keep class cuchaz.enigma.Main { static void main(java.lang.String[]); }
+-keep class cuchaz.enigma.command.Main { static void main(java.lang.String[]); }
+-keep class de.sciss.syntaxpane.** { *; }
diff --git a/enigma/src/test/resources/proguard-test.conf b/enigma/src/test/resources/proguard-test.conf
new file mode 100644
index 0000000..9411d26
--- /dev/null
+++ b/enigma/src/test/resources/proguard-test.conf
@@ -0,0 +1,8 @@
+-overloadaggressively
+-repackageclasses
+-allowaccessmodification
+-dontoptimize
+-dontshrink
+-keepparameternames
+-keepattributes
+-keep class cuchaz.enigma.inputs.Keep
diff --git a/enigma/src/test/resources/tinyV2InnerClasses/c.mapping b/enigma/src/test/resources/tinyV2InnerClasses/c.mapping
new file mode 100644
index 0000000..f9b0442
--- /dev/null
+++ b/enigma/src/test/resources/tinyV2InnerClasses/c.mapping
@@ -0,0 +1,2 @@
+CLASS c
+        CLASS a Kid
diff --git a/enigma/src/test/resources/tinyV2InnerClasses/cuchaz/enigma/Dad.mapping b/enigma/src/test/resources/tinyV2InnerClasses/cuchaz/enigma/Dad.mapping
new file mode 100644
index 0000000..8d43ba9
--- /dev/null
+++ b/enigma/src/test/resources/tinyV2InnerClasses/cuchaz/enigma/Dad.mapping
@@ -0,0 +1,5 @@
+CLASS f cuchaz/enigma/Dad
+        CLASS a One
+                CLASS a Two
+                        CLASS a
+                                FIELD a value I
diff --git a/enigma/src/test/resources/translation.mappings b/enigma/src/test/resources/translation.mappings
new file mode 100644
index 0000000..c08765c
--- /dev/null
+++ b/enigma/src/test/resources/translation.mappings
@@ -0,0 +1,41 @@
+CLASS a deobf/A_Basic
+        FIELD a f1 I
+        FIELD a f2 F
+        FIELD a f3 Ljava/lang/String;
+        METHOD a m1 ()V
+        METHOD a m2 ()I
+        METHOD a m3 (I)V
+        METHOD a m4 (I)I
+CLASS b deobf/B_BaseClass
+        FIELD a f1 I
+        FIELD a f2 C
+        METHOD a m1 ()I
+        METHOD b m2 ()I
+CLASS c deobf/C_SubClass
+        FIELD b f2 C
+        FIELD b f3 I
+        FIELD c f4 I
+        METHOD a m1 ()I
+        METHOD c m3 ()I
+CLASS g deobf/G_OuterClass
+        CLASS g$a A_InnerClass
+                CLASS g$a$a A_InnerInnerClass
+                        FIELD a f3 I
+                        METHOD a m2 ()V
+                FIELD a f1 I
+                FIELD a f2 Ljava/lang/String;
+                METHOD a m1 ()V
+        CLASS g$b
+                CLASS g$b$a A_NamedInnerClass
+                        FIELD a f4 I
+CLASS h
+CLASS i deobf/I_Generics
+        CLASS i$a A_Type
+        CLASS i$b B_Generic
+                FIELD a f4 Ljava/lang/Object;
+                METHOD a m1 ()Ljava/lang/Object;
+        FIELD a f1 Ljava/util/List;
+        FIELD b f2 Ljava/util/List;
+        FIELD a f3 Ljava/util/Map;
+        FIELD a f5 Li$b;
+        FIELD b f6 Li$b;