switch all classes to new signature/type system

92 files changed, 12785 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/CommandMain.java b/src/cuchaz/enigma/CommandMain.java
new file mode 100644
index 00000000..1ec2ad23
--- /dev/null
+++ b/src/cuchaz/enigma/CommandMain.java
@@ -0,0 +1,136 @@
+package cuchaz.enigma;
+
+import java.io.File;
+import java.io.FileReader;
+import java.util.jar.JarFile;
+
+import cuchaz.enigma.Deobfuscator.ProgressListener;
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsReader;
+
+public class CommandMain {
+        
+        public static class ConsoleProgressListener implements ProgressListener {
+                
+                private static final int ReportTime = 5000; // 5s
+
+                private int m_totalWork;
+                private long m_startTime;
+                private long m_lastReportTime;
+                
+                @Override
+                public void init(int totalWork, String title) {
+                        m_totalWork = totalWork;
+                        m_startTime = System.currentTimeMillis();
+                        m_lastReportTime = m_startTime;
+                        System.out.println(title);
+                }
+
+                @Override
+                public void onProgress(int numDone, String message) {
+                        
+                        long now = System.currentTimeMillis();
+                        boolean isLastUpdate = numDone == m_totalWork;
+                        boolean shouldReport = isLastUpdate || now - m_lastReportTime > ReportTime;
+                        
+                        if (shouldReport) {
+                                int percent = numDone*100/m_totalWork;
+                                System.out.println(String.format("\tProgress: %3d%%", percent));
+                                m_lastReportTime = now;
+                        }
+                        if (isLastUpdate) {
+                                double elapsedSeconds = (now - m_startTime)/1000;
+                                System.out.println(String.format("Finished in %.1f seconds", elapsedSeconds));
+                        }
+                }
+        }
+        
+        public static void main(String[] args)
+        throws Exception {
+                
+                try {
+                        
+                        // process the command
+                        String command = getArg(args, 0, "command");
+                        if (command.equalsIgnoreCase("deobfuscate")) {
+                                deobfuscate(args);
+                        } else if(command.equalsIgnoreCase("decompile")) {
+                                decompile(args);
+                        } else {
+                                throw new IllegalArgumentException("Command not recognized: " + command);
+                        }
+                } catch (IllegalArgumentException ex) {
+                        System.out.println(ex.getMessage());
+                        printHelp();
+                }
+        }
+
+        private static void printHelp() {
+                System.out.println(String.format("%s - %s", Constants.Name, Constants.Version));
+                System.out.println("Usage:");
+                System.out.println("\tjava -cp enigma.jar cuchaz.enigma.CommandMain <command>");
+                System.out.println("\twhere <command> is one of:");
+                System.out.println("\t\tdeobfuscate <mappings file> <in jar> <out jar>");
+                System.out.println("\t\tdecompile <mappings file> <in jar> <out folder>");
+        }
+        
+        private static void decompile(String[] args)
+        throws Exception {
+                File fileMappings = getReadableFile(getArg(args, 1, "mappings file"));
+                File fileJarIn = getReadableFile(getArg(args, 2, "in jar"));
+                File fileJarOut = getWritableFolder(getArg(args, 3, "out folder"));
+                Deobfuscator deobfuscator = getDeobfuscator(fileMappings, new JarFile(fileJarIn));
+                deobfuscator.writeSources(fileJarOut, new ConsoleProgressListener());
+        }
+
+        private static void deobfuscate(String[] args)
+        throws Exception {
+                File fileMappings = getReadableFile(getArg(args, 1, "mappings file"));
+                File fileJarIn = getReadableFile(getArg(args, 2, "in jar"));
+                File fileJarOut = getWritableFile(getArg(args, 3, "out jar"));
+                Deobfuscator deobfuscator = getDeobfuscator(fileMappings, new JarFile(fileJarIn));
+                deobfuscator.writeJar(fileJarOut, new ConsoleProgressListener());
+        }
+        
+        private static Deobfuscator getDeobfuscator(File fileMappings, JarFile jar)
+        throws Exception {
+                System.out.println("Reading mappings...");
+                Mappings mappings = new MappingsReader().read(new FileReader(fileMappings));
+                System.out.println("Reading jar...");
+                Deobfuscator deobfuscator = new Deobfuscator(jar);
+                deobfuscator.setMappings(mappings);
+                return deobfuscator;
+        }
+        
+        private static String getArg(String[] args, int i, String name) {
+                if (i >= args.length) {
+                        throw new IllegalArgumentException(name + " is required");
+                }
+                return args[i];
+        }
+
+        private static File getWritableFile(String path) {
+                File file = new File(path).getAbsoluteFile();
+                File dir = file.getParentFile();
+                if (dir == null || !dir.exists()) {
+                        throw new IllegalArgumentException("Cannot write to folder: " + file);
+                }
+                return file;
+        }
+
+        private static File getWritableFolder(String path) {
+                File dir = new File(path).getAbsoluteFile();
+                if (!dir.exists()) {
+                        throw new IllegalArgumentException("Cannot write to folder: " + dir);
+                }
+                return dir;
+        }
+        
+        private static File getReadableFile(String path) {
+                File file = new File(path).getAbsoluteFile();
+                if (!file.exists()) {
+                        throw new IllegalArgumentException("Cannot find file: " + file.getAbsolutePath());
+                }
+                return file;
+        }
+}
diff --git a/src/cuchaz/enigma/Constants.java b/src/cuchaz/enigma/Constants.java
new file mode 100644
index 00000000..a1ba2e98
--- /dev/null
+++ b/src/cuchaz/enigma/Constants.java
@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+public class Constants {
+        public static final String Name = "Enigma";
+        public static final String Version = "0.6 beta";
+        public static final String Url = "http://www.cuchazinteractive.com/enigma";
+        public static final int MiB = 1024 * 1024; // 1 mebibyte
+        public static final int KiB = 1024; // 1 kebibyte
+        public static final String NonePackage = "none";
+}
diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
new file mode 100644
index 00000000..5f61686b
--- /dev/null
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -0,0 +1,539 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.\
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+
+import javassist.CtClass;
+import javassist.bytecode.Descriptor;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.strobel.assembler.metadata.MetadataSystem;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.decompiler.DecompilerContext;
+import com.strobel.decompiler.DecompilerSettings;
+import com.strobel.decompiler.PlainTextOutput;
+import com.strobel.decompiler.languages.java.JavaOutputVisitor;
+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.analysis.EntryReference;
+import cuchaz.enigma.analysis.JarClassIterator;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.analysis.SourceIndex;
+import cuchaz.enigma.analysis.SourceIndexVisitor;
+import cuchaz.enigma.analysis.Token;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassMapping;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.FieldMapping;
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsRenamer;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.MethodMapping;
+import cuchaz.enigma.mapping.TranslationDirection;
+import cuchaz.enigma.mapping.Translator;
+
+public class Deobfuscator {
+        
+        public interface ProgressListener {
+                void init(int totalWork, String title);
+                void onProgress(int numDone, String message);
+        }
+        
+        private JarFile m_jar;
+        private DecompilerSettings m_settings;
+        private JarIndex m_jarIndex;
+        private Mappings m_mappings;
+        private MappingsRenamer m_renamer;
+        private Map<TranslationDirection,Translator> m_translatorCache;
+        
+        public Deobfuscator(JarFile jar) throws IOException {
+                m_jar = jar;
+                
+                // build the jar index
+                m_jarIndex = new JarIndex();
+                m_jarIndex.indexJar(m_jar, true);
+                
+                // config the decompiler
+                m_settings = DecompilerSettings.javaDefaults();
+                m_settings.setMergeVariables(true);
+                m_settings.setForceExplicitImports(true);
+                m_settings.setForceExplicitTypeArguments(true);
+                // DEBUG
+                //m_settings.setShowSyntheticMembers(true);
+                
+                // init defaults
+                m_translatorCache = Maps.newTreeMap();
+                
+                // init mappings
+                setMappings(new Mappings());
+        }
+        
+        public String getJarName() {
+                return m_jar.getName();
+        }
+        
+        public JarIndex getJarIndex() {
+                return m_jarIndex;
+        }
+        
+        public Mappings getMappings() {
+                return m_mappings;
+        }
+        
+        public void setMappings(Mappings val) {
+                if (val == null) {
+                        val = new Mappings();
+                }
+                
+                // pass 1: look for any classes that got moved to inner classes
+                Map<String,String> renames = Maps.newHashMap();
+                for (ClassMapping classMapping : val.classes()) {
+                        // make sure we strip the packages off of obfuscated inner classes
+                        String innerClassName = new ClassEntry(classMapping.getObfName()).getSimpleName();
+                        String outerClassName = m_jarIndex.getOuterClass(innerClassName);
+                        if (outerClassName != null) {
+                                // build the composite class name
+                                String newName = outerClassName + "$" + innerClassName;
+                                
+                                // add a rename
+                                renames.put(classMapping.getObfName(), newName);
+                                
+                                System.out.println(String.format("Converted class mapping %s to %s", classMapping.getObfName(), newName));
+                        }
+                }
+                for (Map.Entry<String,String> entry : renames.entrySet()) {
+                        val.renameObfClass(entry.getKey(), entry.getValue());
+                }
+                
+                // pass 2: look for fields/methods that are actually declared in superclasses
+                MappingsRenamer renamer = new MappingsRenamer(m_jarIndex, val);
+                for (ClassMapping classMapping : Lists.newArrayList(val.classes())) {
+                        ClassEntry obfClassEntry = new ClassEntry(classMapping.getObfName());
+                        
+                        // fields
+                        for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
+                                FieldEntry fieldEntry = new FieldEntry(obfClassEntry, fieldMapping.getObfName());
+                                ClassEntry resolvedObfClassEntry = m_jarIndex.getTranslationIndex().resolveEntryClass(fieldEntry);
+                                if (resolvedObfClassEntry != null && !resolvedObfClassEntry.equals(fieldEntry.getClassEntry())) {
+                                        boolean wasMoved = renamer.moveFieldToObfClass(classMapping, fieldMapping, resolvedObfClassEntry);
+                                        if (wasMoved) {
+                                                System.out.println(String.format("Moved field %s to class %s", fieldEntry, resolvedObfClassEntry));
+                                        } else {
+                                                System.err.println(String.format("WARNING: Would move field %s to class %s but the field was already there. Dropping instead.", fieldEntry, resolvedObfClassEntry));
+                                        }
+                                }
+                        }
+                        
+                        // methods
+                        for (MethodMapping methodMapping : Lists.newArrayList(classMapping.methods())) {
+                                // skip constructors
+                                if (methodMapping.isConstructor()) {
+                                        continue;
+                                }
+                                
+                                MethodEntry methodEntry = new MethodEntry(
+                                        obfClassEntry,
+                                        methodMapping.getObfName(),
+                                        methodMapping.getObfSignature()
+                                );
+                                ClassEntry resolvedObfClassEntry = m_jarIndex.getTranslationIndex().resolveEntryClass(methodEntry);
+                                if (resolvedObfClassEntry != null && !resolvedObfClassEntry.equals(methodEntry.getClassEntry())) {
+                                        boolean wasMoved = renamer.moveMethodToObfClass(classMapping, methodMapping, resolvedObfClassEntry);
+                                        if (wasMoved) {
+                                                System.out.println(String.format("Moved method %s to class %s", methodEntry, resolvedObfClassEntry));
+                                        } else {
+                                                System.err.println(String.format("WARNING: Would move method %s to class %s but the method was already there. Dropping instead.", methodEntry, resolvedObfClassEntry));
+                                        }
+                                }
+                        }
+                        
+                        // TODO: recurse to inner classes?
+                }
+                
+                // drop mappings that don't match the jar
+                List<ClassEntry> unknownClasses = Lists.newArrayList();
+                for (ClassMapping classMapping : val.classes()) {
+                        checkClassMapping(unknownClasses, classMapping);
+                }
+                if (!unknownClasses.isEmpty()) {
+                        throw new Error("Unable to find classes in jar: " + unknownClasses);
+                }
+                
+                m_mappings = val;
+                m_renamer = renamer;
+                m_translatorCache.clear();
+        }
+        
+        private void checkClassMapping(List<ClassEntry> unknownClasses, ClassMapping classMapping) {
+                // check the class
+                ClassEntry classEntry = new ClassEntry(classMapping.getObfName());
+                String outerClassName = m_jarIndex.getOuterClass(classEntry.getSimpleName());
+                if (outerClassName != null) {
+                        classEntry = new ClassEntry(outerClassName + "$" + classMapping.getObfName());
+                }
+                if (!m_jarIndex.getObfClassEntries().contains(classEntry)) {
+                        unknownClasses.add(classEntry);
+                }
+                
+                // check the fields
+                for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, fieldMapping.getObfName());
+                        if (!m_jarIndex.containsObfField(fieldEntry)) {
+                                System.err.println("WARNING: unable to find field " + fieldEntry + ". dropping mapping.");
+                                classMapping.removeFieldMapping(fieldMapping);
+                        }
+                }
+                
+                // check methods
+                for (MethodMapping methodMapping : Lists.newArrayList(classMapping.methods())) {
+                        BehaviorEntry obfBehaviorEntry = BehaviorEntryFactory.createObf(classEntry, methodMapping);
+                        if (!m_jarIndex.containsObfBehavior(obfBehaviorEntry)) {
+                                System.err.println("WARNING: unable to find behavior " + obfBehaviorEntry + ". dropping mapping.");
+                                classMapping.removeMethodMapping(methodMapping);
+                        }
+                }
+                
+                // check inner classes
+                for (ClassMapping innerClassMapping : classMapping.innerClasses()) {
+                        checkClassMapping(unknownClasses, innerClassMapping);
+                }
+        }
+        
+        public Translator getTranslator(TranslationDirection direction) {
+                Translator translator = m_translatorCache.get(direction);
+                if (translator == null) {
+                        translator = m_mappings.getTranslator(direction, m_jarIndex.getTranslationIndex());
+                        m_translatorCache.put(direction, translator);
+                }
+                return translator;
+        }
+        
+        public void getSeparatedClasses(List<ClassEntry> obfClasses, List<ClassEntry> deobfClasses) {
+                for (ClassEntry obfClassEntry : m_jarIndex.getObfClassEntries()) {
+                        // skip inner classes
+                        if (obfClassEntry.isInnerClass()) {
+                                continue;
+                        }
+                        
+                        // separate the classes
+                        ClassEntry deobfClassEntry = deobfuscateEntry(obfClassEntry);
+                        if (!deobfClassEntry.equals(obfClassEntry)) {
+                                // if the class has a mapping, clearly it's deobfuscated
+                                deobfClasses.add(deobfClassEntry);
+                        } else if (!obfClassEntry.getPackageName().equals(Constants.NonePackage)) {
+                                // also call it deobufscated if it's not in the none package
+                                deobfClasses.add(obfClassEntry);
+                        } else {
+                                // otherwise, assume it's still obfuscated
+                                obfClasses.add(obfClassEntry);
+                        }
+                }
+        }
+        
+        public CompilationUnit getSourceTree(String obfClassName) {
+                // is this class deobfuscated?
+                // we need to tell the decompiler the deobfuscated name so it doesn't get freaked out
+                // the decompiler only sees the deobfuscated class, so we need to load it by the deobfuscated name
+                String lookupClassName = obfClassName;
+                ClassMapping classMapping = m_mappings.getClassByObf(obfClassName);
+                if (classMapping != null && classMapping.getDeobfName() != null) {
+                        lookupClassName = classMapping.getDeobfName();
+                }
+                
+                // is this class even in the jar?
+                if (!m_jarIndex.containsObfClass(new ClassEntry(obfClassName))) {
+                        return null;
+                }
+                
+                // set the type loader
+                m_settings.setTypeLoader(new TranslatingTypeLoader(
+                        m_jar,
+                        m_jarIndex,
+                        getTranslator(TranslationDirection.Obfuscating),
+                        getTranslator(TranslationDirection.Deobfuscating)
+                ));
+                
+                // decompile it!
+                TypeDefinition resolvedType = new MetadataSystem(m_settings.getTypeLoader()).lookupType(lookupClassName).resolve();
+                DecompilerContext context = new DecompilerContext();
+                context.setCurrentType(resolvedType);
+                context.setSettings(m_settings);
+                AstBuilder builder = new AstBuilder(context);
+                builder.addType(resolvedType);
+                builder.runTransformations(null);
+                return builder.getCompilationUnit();
+        }
+        
+        public SourceIndex getSourceIndex(CompilationUnit sourceTree, String source) {
+                // build the source index
+                SourceIndex index = new SourceIndex(source);
+                sourceTree.acceptVisitor(new SourceIndexVisitor(), index);
+                
+                // DEBUG
+                // sourceTree.acceptVisitor( new TreeDumpVisitor( new File( "tree.txt" ) ), null );
+                
+                // resolve all the classes in the source references
+                for (Token token : index.referenceTokens()) {
+                        EntryReference<Entry,Entry> deobfReference = index.getDeobfReference(token);
+                        
+                        // get the obfuscated entry
+                        Entry obfEntry = obfuscateEntry(deobfReference.entry);
+                        
+                        // try to resolve the class
+                        ClassEntry resolvedObfClassEntry = m_jarIndex.getTranslationIndex().resolveEntryClass(obfEntry);
+                        if (resolvedObfClassEntry != null && !resolvedObfClassEntry.equals(obfEntry.getClassEntry())) {
+                                // change the class of the entry
+                                obfEntry = obfEntry.cloneToNewClass(resolvedObfClassEntry);
+                                
+                                // save the new deobfuscated reference
+                                deobfReference.entry = deobfuscateEntry(obfEntry);
+                                index.replaceDeobfReference(token, deobfReference);
+                        }
+                        
+                        // DEBUG
+                        // System.out.println( token + " -> " + reference + " -> " + index.getReferenceToken( reference ) );
+                }
+                
+                return index;
+        }
+        
+        public String getSource(CompilationUnit sourceTree) {
+                // render the AST into source
+                StringWriter buf = new StringWriter();
+                sourceTree.acceptVisitor(new InsertParenthesesVisitor(), null);
+                sourceTree.acceptVisitor(new JavaOutputVisitor(new PlainTextOutput(buf), m_settings), null);
+                return buf.toString();
+        }
+        
+        public void writeSources(File dirOut, ProgressListener progress) throws IOException {
+                // get the classes to decompile
+                Set<ClassEntry> classEntries = Sets.newHashSet();
+                for (ClassEntry obfClassEntry : m_jarIndex.getObfClassEntries()) {
+                        // skip inner classes
+                        if (obfClassEntry.isInnerClass()) {
+                                continue;
+                        }
+                        
+                        classEntries.add(obfClassEntry);
+                }
+                
+                if (progress != null) {
+                        progress.init(classEntries.size(), "Decompiling classes...");
+                }
+                
+                // DEOBFUSCATE ALL THE THINGS!! @_@
+                int i = 0;
+                for (ClassEntry obfClassEntry : classEntries) {
+                        ClassEntry deobfClassEntry = deobfuscateEntry(new ClassEntry(obfClassEntry));
+                        if (progress != null) {
+                                progress.onProgress(i++, deobfClassEntry.toString());
+                        }
+                        
+                        try {
+                                // get the source
+                                String source = getSource(getSourceTree(obfClassEntry.getName()));
+                                
+                                // write the file
+                                File file = new File(dirOut, deobfClassEntry.getName().replace('.', '/') + ".java");
+                                file.getParentFile().mkdirs();
+                                try (FileWriter out = new FileWriter(file)) {
+                                        out.write(source);
+                                }
+                        } catch (Throwable t) {
+                                throw new Error("Unable to deobfuscate class " + deobfClassEntry.toString() + " (" + obfClassEntry.toString() + ")", t);
+                        }
+                }
+                if (progress != null) {
+                        progress.onProgress(i, "Done!");
+                }
+        }
+        
+        public void writeJar(File out, ProgressListener progress) {
+                try (JarOutputStream outJar = new JarOutputStream(new FileOutputStream(out))) {
+                        if (progress != null) {
+                                progress.init(JarClassIterator.getClassEntries(m_jar).size(), "Translating classes...");
+                        }
+                        
+                        // prep the loader
+                        TranslatingTypeLoader loader = new TranslatingTypeLoader(
+                                m_jar,
+                                m_jarIndex,
+                                getTranslator(TranslationDirection.Obfuscating),
+                                getTranslator(TranslationDirection.Deobfuscating)
+                        );
+                        
+                        int i = 0;
+                        for (CtClass c : JarClassIterator.classes(m_jar)) {
+                                if (progress != null) {
+                                        progress.onProgress(i++, c.getName());
+                                }
+                                
+                                try {
+                                        c = loader.transformClass(c);
+                                        outJar.putNextEntry(new JarEntry(c.getName().replace('.', '/') + ".class"));
+                                        outJar.write(c.toBytecode());
+                                        outJar.closeEntry();
+                                } catch (Throwable t) {
+                                        throw new Error("Unable to deobfuscate class " + c.getName(), t);
+                                }
+                        }
+                        if (progress != null) {
+                                progress.onProgress(i, "Done!");
+                        }
+                        
+                        outJar.close();
+                } catch (IOException ex) {
+                        throw new Error("Unable to write to Jar file!");
+                }
+        }
+        
+        public <T extends Entry> T obfuscateEntry(T deobfEntry) {
+                if (deobfEntry == null) {
+                        return null;
+                }
+                return getTranslator(TranslationDirection.Obfuscating).translateEntry(deobfEntry);
+        }
+        
+        public <T extends Entry> T deobfuscateEntry(T obfEntry) {
+                if (obfEntry == null) {
+                        return null;
+                }
+                return getTranslator(TranslationDirection.Deobfuscating).translateEntry(obfEntry);
+        }
+        
+        public <E extends Entry,C extends Entry> EntryReference<E,C> obfuscateReference(EntryReference<E,C> deobfReference) {
+                if (deobfReference == null) {
+                        return null;
+                }
+                return new EntryReference<E,C>(
+                        obfuscateEntry(deobfReference.entry),
+                        obfuscateEntry(deobfReference.context),
+                        deobfReference
+                );
+        }
+        
+        public <E extends Entry,C extends Entry> EntryReference<E,C> deobfuscateReference(EntryReference<E,C> obfReference) {
+                if (obfReference == null) {
+                        return null;
+                }
+                return new EntryReference<E,C>(
+                        deobfuscateEntry(obfReference.entry),
+                        deobfuscateEntry(obfReference.context),
+                        obfReference
+                );
+        }
+        
+        public boolean isObfuscatedIdentifier(Entry obfEntry) {
+                return m_jarIndex.containsObfEntry(obfEntry);
+        }
+        
+        public boolean isRenameable(EntryReference<Entry,Entry> obfReference) {
+                return obfReference.isNamed() && isObfuscatedIdentifier(obfReference.getNameableEntry());
+        }
+        
+        // NOTE: these methods are a bit messy... oh well
+        
+        public boolean hasDeobfuscatedName(Entry obfEntry) {
+                Translator translator = getTranslator(TranslationDirection.Deobfuscating);
+                if (obfEntry instanceof ClassEntry) {
+                        return translator.translate((ClassEntry)obfEntry) != null;
+                } else if (obfEntry instanceof FieldEntry) {
+                        return translator.translate((FieldEntry)obfEntry) != null;
+                } else if (obfEntry instanceof MethodEntry) {
+                        return translator.translate((MethodEntry)obfEntry) != null;
+                } else if (obfEntry instanceof ConstructorEntry) {
+                        // constructors have no names
+                        return false;
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        return translator.translate((ArgumentEntry)obfEntry) != null;
+                } else {
+                        throw new Error("Unknown entry type: " + obfEntry.getClass().getName());
+                }
+        }
+        
+        public void rename(Entry obfEntry, String newName) {
+                if (obfEntry instanceof ClassEntry) {
+                        m_renamer.setClassName((ClassEntry)obfEntry, Descriptor.toJvmName(newName));
+                } else if (obfEntry instanceof FieldEntry) {
+                        m_renamer.setFieldName((FieldEntry)obfEntry, newName);
+                } else if (obfEntry instanceof MethodEntry) {
+                        m_renamer.setMethodTreeName((MethodEntry)obfEntry, newName);
+                } else if (obfEntry instanceof ConstructorEntry) {
+                        throw new IllegalArgumentException("Cannot rename constructors");
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        m_renamer.setArgumentName((ArgumentEntry)obfEntry, newName);
+                } else {
+                        throw new Error("Unknown entry type: " + obfEntry.getClass().getName());
+                }
+                
+                // clear caches
+                m_translatorCache.clear();
+        }
+        
+        public void removeMapping(Entry obfEntry) {
+                if (obfEntry instanceof ClassEntry) {
+                        m_renamer.removeClassMapping((ClassEntry)obfEntry);
+                } else if (obfEntry instanceof FieldEntry) {
+                        m_renamer.removeFieldMapping((FieldEntry)obfEntry);
+                } else if (obfEntry instanceof MethodEntry) {
+                        m_renamer.removeMethodTreeMapping((MethodEntry)obfEntry);
+                } else if (obfEntry instanceof ConstructorEntry) {
+                        throw new IllegalArgumentException("Cannot rename constructors");
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        m_renamer.removeArgumentMapping((ArgumentEntry)obfEntry);
+                } else {
+                        throw new Error("Unknown entry type: " + obfEntry);
+                }
+                
+                // clear caches
+                m_translatorCache.clear();
+        }
+        
+        public void markAsDeobfuscated(Entry obfEntry) {
+                if (obfEntry instanceof ClassEntry) {
+                        m_renamer.markClassAsDeobfuscated((ClassEntry)obfEntry);
+                } else if (obfEntry instanceof FieldEntry) {
+                        m_renamer.markFieldAsDeobfuscated((FieldEntry)obfEntry);
+                } else if (obfEntry instanceof MethodEntry) {
+                        m_renamer.markMethodTreeAsDeobfuscated((MethodEntry)obfEntry);
+                } else if (obfEntry instanceof ConstructorEntry) {
+                        throw new IllegalArgumentException("Cannot rename constructors");
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        m_renamer.markArgumentAsDeobfuscated((ArgumentEntry)obfEntry);
+                } else {
+                        throw new Error("Unknown entry type: " + obfEntry);
+                }
+                
+                // clear caches
+                m_translatorCache.clear();
+        }
+}
diff --git a/src/cuchaz/enigma/Main.java b/src/cuchaz/enigma/Main.java
new file mode 100644
index 00000000..acae94b1
--- /dev/null
+++ b/src/cuchaz/enigma/Main.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.io.File;
+import java.util.jar.JarFile;
+
+import cuchaz.enigma.gui.Gui;
+
+public class Main {
+        
+        public static void main(String[] args) throws Exception {
+                Gui gui = new Gui();
+                
+                // parse command-line args
+                if (args.length >= 1) {
+                        gui.getController().openJar(new JarFile(getFile(args[0])));
+                }
+                if (args.length >= 2) {
+                        gui.getController().openMappings(getFile(args[1]));
+                }
+                
+                // DEBUG
+                //gui.getController().openDeclaration(new ClassEntry("none/bxq"));
+        }
+        
+        private static File getFile(String path) {
+                // expand ~ to the home dir
+                if (path.startsWith("~")) {
+                        // get the home dir
+                        File dirHome = new File(System.getProperty("user.home"));
+                        
+                        // is the path just ~/ or is it ~user/ ?
+                        if (path.startsWith("~/")) {
+                                return new File(dirHome, path.substring(2));
+                        } else {
+                                return new File(dirHome.getParentFile(), path.substring(1));
+                        }
+                }
+                
+                return new File(path);
+        }
+}
diff --git a/src/cuchaz/enigma/TranslatingTypeLoader.java b/src/cuchaz/enigma/TranslatingTypeLoader.java
new file mode 100644
index 00000000..cfa03a1a
--- /dev/null
+++ b/src/cuchaz/enigma/TranslatingTypeLoader.java
@@ -0,0 +1,211 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import javassist.ByteArrayClassPath;
+import javassist.CannotCompileException;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+import javassist.bytecode.Descriptor;
+
+import com.google.common.collect.Maps;
+import com.strobel.assembler.metadata.Buffer;
+import com.strobel.assembler.metadata.ClasspathTypeLoader;
+import com.strobel.assembler.metadata.ITypeLoader;
+
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.bytecode.ClassRenamer;
+import cuchaz.enigma.bytecode.ClassTranslator;
+import cuchaz.enigma.bytecode.InnerClassWriter;
+import cuchaz.enigma.bytecode.MethodParameterWriter;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class TranslatingTypeLoader implements ITypeLoader {
+        
+        private JarFile m_jar;
+        private JarIndex m_jarIndex;
+        private Translator m_obfuscatingTranslator;
+        private Translator m_deobfuscatingTranslator;
+        private Map<String,byte[]> m_cache;
+        private ClasspathTypeLoader m_defaultTypeLoader;
+        
+        public TranslatingTypeLoader(JarFile jar, JarIndex jarIndex) {
+                this(jar, jarIndex, new Translator(), new Translator());
+        }
+        
+        public TranslatingTypeLoader(JarFile jar, JarIndex jarIndex, Translator obfuscatingTranslator, Translator deobfuscatingTranslator) {
+                m_jar = jar;
+                m_jarIndex = jarIndex;
+                m_obfuscatingTranslator = obfuscatingTranslator;
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_cache = Maps.newHashMap();
+                m_defaultTypeLoader = new ClasspathTypeLoader();
+        }
+        
+        public void clearCache() {
+                m_cache.clear();
+        }
+        
+        @Override
+        public boolean tryLoadType(String deobfClassName, Buffer out) {
+                // check the cache
+                byte[] data;
+                if (m_cache.containsKey(deobfClassName)) {
+                        data = m_cache.get(deobfClassName);
+                } else {
+                        data = loadType(deobfClassName);
+                        m_cache.put(deobfClassName, data);
+                }
+                
+                if (data == null) {
+                        // chain to default type loader
+                        return m_defaultTypeLoader.tryLoadType(deobfClassName, out);
+                }
+                
+                // send the class to the decompiler
+                out.reset(data.length);
+                System.arraycopy(data, 0, out.array(), out.position(), data.length);
+                out.position(0);
+                return true;
+        }
+        
+        public CtClass loadClass(String deobfClassName) {
+                byte[] data = loadType(deobfClassName);
+                if (data == null) {
+                        return null;
+                }
+                
+                // return a javassist handle for the class
+                String javaClassFileName = Descriptor.toJavaName(deobfClassName);
+                ClassPool classPool = new ClassPool();
+                classPool.insertClassPath(new ByteArrayClassPath(javaClassFileName, data));
+                try {
+                        return classPool.get(javaClassFileName);
+                } catch (NotFoundException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private byte[] loadType(String deobfClassName) {
+                ClassEntry deobfClassEntry = new ClassEntry(deobfClassName);
+                ClassEntry obfClassEntry = m_obfuscatingTranslator.translateEntry(deobfClassEntry);
+                
+                // is this an inner class referenced directly?
+                String obfOuterClassName = m_jarIndex.getOuterClass(obfClassEntry.getSimpleName());
+                if (obfOuterClassName != null) {
+                        // this class doesn't really exist. Reference it by outer$inner instead
+                        System.err.println(String.format("WARNING: class %s referenced by bare inner name instead of via outer class %s", deobfClassName, obfOuterClassName));
+                        return null;
+                }
+                
+                /* DEBUG
+                if( !Arrays.asList( "java", "org", "io" ).contains( deobfClassName.split( "/" )[0] ) ) {
+                        System.out.println( String.format( "Looking for %s (%s)", deobfClassEntry.getName(), obfClassEntry.getName() ) );
+                }
+                */
+                
+                // get the jar entry
+                String classFileName;
+                if (obfClassEntry.isInnerClass()) {
+                        // use just the inner class name for inner classes
+                        classFileName = obfClassEntry.getInnerClassName();
+                } else if (obfClassEntry.getPackageName().equals(Constants.NonePackage)) {
+                        // use the outer class simple name for classes in the none package
+                        classFileName = obfClassEntry.getSimpleName();
+                } else {
+                        // otherwise, just use the class name (ie for classes in packages)
+                        classFileName = obfClassEntry.getName();
+                }
+                
+                JarEntry entry = m_jar.getJarEntry(classFileName + ".class");
+                if (entry == null) {
+                        return null;
+                }
+                
+                try {
+                        // read the class file into a buffer
+                        ByteArrayOutputStream data = new ByteArrayOutputStream();
+                        byte[] buf = new byte[1024 * 1024]; // 1 KiB
+                        InputStream in = m_jar.getInputStream(entry);
+                        while (true) {
+                                int bytesRead = in.read(buf);
+                                if (bytesRead <= 0) {
+                                        break;
+                                }
+                                data.write(buf, 0, bytesRead);
+                        }
+                        data.close();
+                        in.close();
+                        buf = data.toByteArray();
+                        
+                        // load the javassist handle to the raw class
+                        String javaClassFileName = Descriptor.toJavaName(classFileName);
+                        ClassPool classPool = new ClassPool();
+                        classPool.insertClassPath(new ByteArrayClassPath(javaClassFileName, buf));
+                        CtClass c = classPool.get(javaClassFileName);
+                        
+                        c = transformClass(c);
+                        
+                        // sanity checking
+                        assertClassName(c, deobfClassEntry);
+                        
+                        // DEBUG
+                        //Util.writeClass( c );
+                        
+                        // we have a transformed class!
+                        return c.toBytecode();
+                } catch (IOException | NotFoundException | CannotCompileException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public CtClass transformClass(CtClass c) throws IOException, NotFoundException, CannotCompileException {
+                // we moved a lot of classes out of the default package into the none package
+                // make sure all the class references are consistent
+                ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                
+                // reconstruct inner classes
+                new InnerClassWriter(m_jarIndex).write(c);
+                
+                // re-get the javassist handle since we changed class names
+                ClassEntry obfClassEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                String javaClassReconstructedName = Descriptor.toJavaName(obfClassEntry.getName());
+                ClassPool classPool = new ClassPool();
+                classPool.insertClassPath(new ByteArrayClassPath(javaClassReconstructedName, c.toBytecode()));
+                c = classPool.get(javaClassReconstructedName);
+                
+                // check that the file is correct after inner class reconstruction (ie cause Javassist to fail fast if something is wrong)
+                assertClassName(c, obfClassEntry);
+                
+                // do all kinds of deobfuscating transformations on the class
+                new MethodParameterWriter(m_deobfuscatingTranslator).writeMethodArguments(c);
+                new ClassTranslator(m_deobfuscatingTranslator).translate(c);
+                
+                return c;
+        }
+        
+        private void assertClassName(CtClass c, ClassEntry obfClassEntry) {
+                String name1 = Descriptor.toJvmName(c.getName());
+                assert (name1.equals(obfClassEntry.getName())) : String.format("Looking for %s, instead found %s", obfClassEntry.getName(), name1);
+                
+                String name2 = Descriptor.toJvmName(c.getClassFile().getName());
+                assert (name2.equals(obfClassEntry.getName())) : String.format("Looking for %s, instead found %s", obfClassEntry.getName(), name2);
+        }
+}
diff --git a/src/cuchaz/enigma/Util.java b/src/cuchaz/enigma/Util.java
new file mode 100644
index 00000000..7f04bda0
--- /dev/null
+++ b/src/cuchaz/enigma/Util.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.awt.Desktop;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.jar.JarFile;
+
+import javassist.CannotCompileException;
+import javassist.CtClass;
+import javassist.bytecode.Descriptor;
+
+import com.google.common.io.CharStreams;
+
+public class Util {
+        
+        public static int combineHashesOrdered(Object... objs) {
+                return combineHashesOrdered(Arrays.asList(objs));
+        }
+        
+        public static int combineHashesOrdered(Iterable<Object> objs) {
+                final int prime = 67;
+                int result = 1;
+                for (Object obj : objs) {
+                        result *= prime;
+                        if (obj != null) {
+                                result += obj.hashCode();
+                        }
+                }
+                return result;
+        }
+        
+        public static void closeQuietly(Closeable closeable) {
+                if (closeable != null) {
+                        try {
+                                closeable.close();
+                        } catch (IOException ex) {
+                                // just ignore any further exceptions
+                        }
+                }
+        }
+        
+        public static void closeQuietly(JarFile jarFile) {
+                // silly library should implement Closeable...
+                if (jarFile != null) {
+                        try {
+                                jarFile.close();
+                        } catch (IOException ex) {
+                                // just ignore any further exceptions
+                        }
+                }
+        }
+        
+        public static String readStreamToString(InputStream in) throws IOException {
+                return CharStreams.toString(new InputStreamReader(in, "UTF-8"));
+        }
+        
+        public static String readResourceToString(String path) throws IOException {
+                InputStream in = Util.class.getResourceAsStream(path);
+                if (in == null) {
+                        throw new IllegalArgumentException("Resource not found! " + path);
+                }
+                return readStreamToString(in);
+        }
+        
+        public static void openUrl(String url) {
+                if (Desktop.isDesktopSupported()) {
+                        Desktop desktop = Desktop.getDesktop();
+                        try {
+                                desktop.browse(new URI(url));
+                        } catch (IOException ex) {
+                                throw new Error(ex);
+                        } catch (URISyntaxException ex) {
+                                throw new IllegalArgumentException(ex);
+                        }
+                }
+        }
+        
+        public static void writeClass(CtClass c) {
+                String name = Descriptor.toJavaName(c.getName());
+                File file = new File(name + ".class");
+                try (FileOutputStream out = new FileOutputStream(file)) {
+                        out.write(c.toBytecode());
+                } catch (IOException | CannotCompileException ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/Access.java b/src/cuchaz/enigma/analysis/Access.java
new file mode 100644
index 00000000..8d3409ac
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/Access.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.lang.reflect.Modifier;
+
+import javassist.CtBehavior;
+import javassist.CtField;
+
+public enum Access {
+        
+        Public,
+        Protected,
+        Private;
+        
+        public static Access get(CtBehavior behavior) {
+                return get(behavior.getModifiers());
+        }
+        
+        public static Access get(CtField field) {
+                return get(field.getModifiers());
+        }
+        
+        public static Access get(int modifiers) {
+                if (Modifier.isPublic(modifiers)) {
+                        return Public;
+                } else if (Modifier.isProtected(modifiers)) {
+                        return Protected;
+                } else if (Modifier.isPrivate(modifiers)) {
+                        return Private;
+                }
+                // assume public by default
+                return Public;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java b/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java
new file mode 100644
index 00000000..9adac5e9
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java
@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.Set;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreeNode;
+
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.Translator;
+
+public class BehaviorReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode<BehaviorEntry,BehaviorEntry> {
+        
+        private static final long serialVersionUID = -3658163700783307520L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private BehaviorEntry m_entry;
+        private EntryReference<BehaviorEntry,BehaviorEntry> m_reference;
+        private Access m_access;
+        
+        public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, BehaviorEntry entry) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+                m_reference = null;
+        }
+        
+        public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference<BehaviorEntry,BehaviorEntry> reference, Access access) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = reference.entry;
+                m_reference = reference;
+                m_access = access;
+        }
+        
+        @Override
+        public BehaviorEntry getEntry() {
+                return m_entry;
+        }
+        
+        @Override
+        public EntryReference<BehaviorEntry,BehaviorEntry> getReference() {
+                return m_reference;
+        }
+        
+        @Override
+        public String toString() {
+                if (m_reference != null) {
+                        return String.format("%s (%s)", m_deobfuscatingTranslator.translateEntry(m_reference.context), m_access);
+                }
+                return m_deobfuscatingTranslator.translateEntry(m_entry).toString();
+        }
+        
+        public void load(JarIndex index, boolean recurse) {
+                // get all the child nodes
+                for (EntryReference<BehaviorEntry,BehaviorEntry> reference : index.getBehaviorReferences(m_entry)) {
+                        add(new BehaviorReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_entry)));
+                }
+                
+                if (recurse && children != null) {
+                        for (Object child : children) {
+                                if (child instanceof BehaviorReferenceTreeNode) {
+                                        BehaviorReferenceTreeNode node = (BehaviorReferenceTreeNode)child;
+                                        
+                                        // don't recurse into ancestor
+                                        Set<Entry> ancestors = Sets.newHashSet();
+                                        TreeNode n = (TreeNode)node;
+                                        while (n.getParent() != null) {
+                                                n = n.getParent();
+                                                if (n instanceof BehaviorReferenceTreeNode) {
+                                                        ancestors.add( ((BehaviorReferenceTreeNode)n).getEntry());
+                                                }
+                                        }
+                                        if (ancestors.contains(node.getEntry())) {
+                                                continue;
+                                        }
+                                        
+                                        node.load(index, true);
+                                }
+                        }
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java b/src/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
new file mode 100644
index 00000000..49aac5f0
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class ClassImplementationsTreeNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = 3112703459157851912L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private ClassEntry m_entry;
+        
+        public ClassImplementationsTreeNode(Translator deobfuscatingTranslator, ClassEntry entry) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+        }
+        
+        public ClassEntry getClassEntry() {
+                return m_entry;
+        }
+        
+        public String getDeobfClassName() {
+                return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        }
+        
+        @Override
+        public String toString() {
+                String className = getDeobfClassName();
+                if (className == null) {
+                        className = m_entry.getClassName();
+                }
+                return className;
+        }
+        
+        public void load(JarIndex index) {
+                // get all method implementations
+                List<ClassImplementationsTreeNode> nodes = Lists.newArrayList();
+                for (String implementingClassName : index.getImplementingClasses(m_entry.getClassName())) {
+                        nodes.add(new ClassImplementationsTreeNode(m_deobfuscatingTranslator, new ClassEntry(implementingClassName)));
+                }
+                
+                // add them to this node
+                for (ClassImplementationsTreeNode node : nodes) {
+                        this.add(node);
+                }
+        }
+        
+        public static ClassImplementationsTreeNode findNode(ClassImplementationsTreeNode node, MethodEntry entry) {
+                // is this the node?
+                if (node.m_entry.equals(entry)) {
+                        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;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java b/src/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
new file mode 100644
index 00000000..3eaa3912
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class ClassInheritanceTreeNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = 4432367405826178490L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private String m_obfClassName;
+        
+        public ClassInheritanceTreeNode(Translator deobfuscatingTranslator, String obfClassName) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_obfClassName = obfClassName;
+        }
+        
+        public String getObfClassName() {
+                return m_obfClassName;
+        }
+        
+        public String getDeobfClassName() {
+                return m_deobfuscatingTranslator.translateClass(m_obfClassName);
+        }
+        
+        @Override
+        public String toString() {
+                String deobfClassName = getDeobfClassName();
+                if (deobfClassName != null) {
+                        return deobfClassName;
+                }
+                return m_obfClassName;
+        }
+        
+        public void load(TranslationIndex ancestries, boolean recurse) {
+                // get all the child nodes
+                List<ClassInheritanceTreeNode> nodes = Lists.newArrayList();
+                for (ClassEntry subclassEntry : ancestries.getSubclass(new ClassEntry(m_obfClassName))) {
+                        nodes.add(new ClassInheritanceTreeNode(m_deobfuscatingTranslator, subclassEntry.getName()));
+                }
+                
+                // add them to this node
+                for (ClassInheritanceTreeNode node : nodes) {
+                        this.add(node);
+                }
+                
+                if (recurse) {
+                        for (ClassInheritanceTreeNode node : nodes) {
+                                node.load(ancestries, true);
+                        }
+                }
+        }
+        
+        public static ClassInheritanceTreeNode findNode(ClassInheritanceTreeNode node, ClassEntry entry) {
+                // is this the node?
+                if (node.getObfClassName().equals(entry.getName())) {
+                        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;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/EntryReference.java b/src/cuchaz/enigma/analysis/EntryReference.java
new file mode 100644
index 00000000..bb611df5
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/EntryReference.java
@@ -0,0 +1,126 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.Arrays;
+import java.util.List;
+
+import cuchaz.enigma.Util;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+
+public class EntryReference<E extends Entry,C extends Entry> {
+        
+        private static final List<String> ConstructorNonNames = Arrays.asList("this", "super", "static");
+        public E entry;
+        public C context;
+        
+        private boolean m_isNamed;
+        
+        public EntryReference(E entry, String sourceName) {
+                this(entry, sourceName, null);
+        }
+        
+        public EntryReference(E entry, String sourceName, C context) {
+                if (entry == null) {
+                        throw new IllegalArgumentException("Entry cannot be null!");
+                }
+                
+                this.entry = entry;
+                this.context = context;
+                
+                m_isNamed = sourceName != null && sourceName.length() > 0;
+                if (entry instanceof ConstructorEntry && ConstructorNonNames.contains(sourceName)) {
+                        m_isNamed = false;
+                }
+        }
+        
+        public EntryReference(E entry, C context, EntryReference<E,C> other) {
+                this.entry = entry;
+                this.context = context;
+                m_isNamed = other.m_isNamed;
+        }
+        
+        public ClassEntry getLocationClassEntry() {
+                if (context != null) {
+                        return context.getClassEntry();
+                }
+                return entry.getClassEntry();
+        }
+        
+        public boolean isNamed() {
+                return m_isNamed;
+        }
+        
+        public Entry getNameableEntry() {
+                if (entry instanceof ConstructorEntry) {
+                        // renaming a constructor really means renaming the class
+                        return entry.getClassEntry();
+                }
+                return entry;
+        }
+        
+        public String getNamableName() {
+                if (getNameableEntry() instanceof ClassEntry) {
+                        ClassEntry classEntry = (ClassEntry)getNameableEntry();
+                        if (classEntry.isInnerClass()) {
+                                // make sure we only rename the inner class name
+                                return classEntry.getInnerClassName();
+                        }
+                }
+                
+                return getNameableEntry().getName();
+        }
+        
+        @Override
+        public int hashCode() {
+                if (context != null) {
+                        return Util.combineHashesOrdered(entry.hashCode(), context.hashCode());
+                }
+                return entry.hashCode();
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof EntryReference) {
+                        return equals((EntryReference<?,?>)other);
+                }
+                return false;
+        }
+        
+        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);
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/EntryRenamer.java b/src/cuchaz/enigma/analysis/EntryRenamer.java
new file mode 100644
index 00000000..b54489cd
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/EntryRenamer.java
@@ -0,0 +1,171 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.AbstractMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+
+public class EntryRenamer {
+        
+        public static <T> void renameClassesInSet(Map<String,String> renames, Set<T> set) {
+                List<T> entries = Lists.newArrayList();
+                for (T val : set) {
+                        entries.add(renameClassesInThing(renames, val));
+                }
+                set.clear();
+                set.addAll(entries);
+        }
+        
+        public static <Key,Val> void renameClassesInMap(Map<String,String> renames, Map<Key,Val> map) {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for (Map.Entry<Key,Val> entry : map.entrySet()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+                                renameClassesInThing(renames, entry.getKey()),
+                                renameClassesInThing(renames, entry.getValue())
+                        ));
+                }
+                map.clear();
+                for (Map.Entry<Key,Val> entry : entriesToAdd) {
+                        map.put(entry.getKey(), entry.getValue());
+                }
+        }
+        
+        public static <Key,Val> void renameClassesInMultimap(Map<String,String> renames, Multimap<Key,Val> map) {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for (Map.Entry<Key,Val> entry : map.entries()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+                                renameClassesInThing(renames, entry.getKey()),
+                                renameClassesInThing(renames, entry.getValue())
+                        ));
+                }
+                map.clear();
+                for (Map.Entry<Key,Val> entry : entriesToAdd) {
+                        map.put(entry.getKey(), entry.getValue());
+                }
+        }
+        
+        public static <Key,Val> void renameMethodsInMultimap(Map<MethodEntry,MethodEntry> renames, Multimap<Key,Val> map) {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for (Map.Entry<Key,Val> entry : map.entries()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+                                renameMethodsInThing(renames, entry.getKey()),
+                                renameMethodsInThing(renames, entry.getValue())
+                        ));
+                }
+                map.clear();
+                for (Map.Entry<Key,Val> entry : entriesToAdd) {
+                        map.put(entry.getKey(), entry.getValue());
+                }
+        }
+        
+        public static <Key,Val> void renameMethodsInMap(Map<MethodEntry,MethodEntry> renames, Map<Key,Val> map) {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for (Map.Entry<Key,Val> entry : map.entrySet()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+                                renameMethodsInThing(renames, entry.getKey()),
+                                renameMethodsInThing(renames, entry.getValue())
+                        ));
+                }
+                map.clear();
+                for (Map.Entry<Key,Val> entry : entriesToAdd) {
+                        map.put(entry.getKey(), entry.getValue());
+                }
+        }
+        
+        @SuppressWarnings("unchecked")
+        public static <T> T renameMethodsInThing(Map<MethodEntry,MethodEntry> renames, T thing) {
+                if (thing instanceof MethodEntry) {
+                        MethodEntry methodEntry = (MethodEntry)thing;
+                        MethodEntry newMethodEntry = renames.get(methodEntry);
+                        if (newMethodEntry != null) {
+                                return (T)new MethodEntry(
+                                        methodEntry.getClassEntry(),
+                                        newMethodEntry.getName(),
+                                        methodEntry.getSignature()
+                                );
+                        }
+                        return thing;
+                } else if (thing instanceof ArgumentEntry) {
+                        ArgumentEntry argumentEntry = (ArgumentEntry)thing;
+                        return (T)new ArgumentEntry(
+                                renameMethodsInThing(renames, argumentEntry.getBehaviorEntry()),
+                                argumentEntry.getIndex(),
+                                argumentEntry.getName()
+                        );
+                } else if (thing instanceof EntryReference) {
+                        EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
+                        reference.entry = renameMethodsInThing(renames, reference.entry);
+                        reference.context = renameMethodsInThing(renames, reference.context);
+                        return thing;
+                }
+                return thing;
+        }
+        
+        @SuppressWarnings("unchecked")
+        public static <T> T renameClassesInThing(Map<String,String> renames, T thing) {
+                if (thing instanceof String) {
+                        String stringEntry = (String)thing;
+                        if (renames.containsKey(stringEntry)) {
+                                return (T)renames.get(stringEntry);
+                        }
+                } else if (thing instanceof ClassEntry) {
+                        ClassEntry classEntry = (ClassEntry)thing;
+                        return (T)new ClassEntry(renameClassesInThing(renames, classEntry.getClassName()));
+                } else if (thing instanceof FieldEntry) {
+                        FieldEntry fieldEntry = (FieldEntry)thing;
+                        return (T)new FieldEntry(renameClassesInThing(renames, fieldEntry.getClassEntry()), fieldEntry.getName());
+                } else if (thing instanceof ConstructorEntry) {
+                        ConstructorEntry constructorEntry = (ConstructorEntry)thing;
+                        return (T)new ConstructorEntry(
+                                renameClassesInThing(renames, constructorEntry.getClassEntry()),
+                                constructorEntry.getSignature()
+                        );
+                } else if (thing instanceof MethodEntry) {
+                        MethodEntry methodEntry = (MethodEntry)thing;
+                        return (T)new MethodEntry(
+                                renameClassesInThing(renames, methodEntry.getClassEntry()),
+                                methodEntry.getName(),
+                                methodEntry.getSignature()
+                        );
+                } else if (thing instanceof ArgumentEntry) {
+                        ArgumentEntry argumentEntry = (ArgumentEntry)thing;
+                        return (T)new ArgumentEntry(
+                                renameClassesInThing(renames, argumentEntry.getBehaviorEntry()),
+                                argumentEntry.getIndex(),
+                                argumentEntry.getName()
+                        );
+                } else if (thing instanceof EntryReference) {
+                        EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
+                        reference.entry = renameClassesInThing(renames, reference.entry);
+                        reference.context = renameClassesInThing(renames, reference.context);
+                        return thing;
+                }
+                
+                return thing;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java b/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
new file mode 100644
index 00000000..2173eea6
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class FieldReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode<FieldEntry,BehaviorEntry> {
+        
+        private static final long serialVersionUID = -7934108091928699835L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private FieldEntry m_entry;
+        private EntryReference<FieldEntry,BehaviorEntry> m_reference;
+        private Access m_access;
+        
+        public FieldReferenceTreeNode(Translator deobfuscatingTranslator, FieldEntry entry) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+                m_reference = null;
+        }
+        
+        private FieldReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference<FieldEntry,BehaviorEntry> reference, Access access) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = reference.entry;
+                m_reference = reference;
+                m_access = access;
+        }
+        
+        @Override
+        public FieldEntry getEntry() {
+                return m_entry;
+        }
+        
+        @Override
+        public EntryReference<FieldEntry,BehaviorEntry> getReference() {
+                return m_reference;
+        }
+        
+        @Override
+        public String toString() {
+                if (m_reference != null) {
+                        return String.format("%s (%s)", m_deobfuscatingTranslator.translateEntry(m_reference.context), m_access);
+                }
+                return m_deobfuscatingTranslator.translateEntry(m_entry).toString();
+        }
+        
+        public void load(JarIndex index, boolean recurse) {
+                // get all the child nodes
+                if (m_reference == null) {
+                        for (EntryReference<FieldEntry,BehaviorEntry> reference : index.getFieldReferences(m_entry)) {
+                                add(new FieldReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_entry)));
+                        }
+                } else {
+                        for (EntryReference<BehaviorEntry,BehaviorEntry> reference : index.getBehaviorReferences(m_reference.context)) {
+                                add(new BehaviorReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_reference.context)));
+                        }
+                }
+                
+                if (recurse && children != null) {
+                        for (Object node : children) {
+                                if (node instanceof BehaviorReferenceTreeNode) {
+                                        ((BehaviorReferenceTreeNode)node).load(index, true);
+                                } else if (node instanceof FieldReferenceTreeNode) {
+                                        ((FieldReferenceTreeNode)node).load(index, true);
+                                }
+                        }
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/JarClassIterator.java b/src/cuchaz/enigma/analysis/JarClassIterator.java
new file mode 100644
index 00000000..72a99122
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/JarClassIterator.java
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import javassist.ByteArrayClassPath;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+import javassist.bytecode.Descriptor;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class JarClassIterator implements Iterator<CtClass> {
+        
+        private JarFile m_jar;
+        private Iterator<JarEntry> m_iter;
+        
+        public JarClassIterator(JarFile jar) {
+                m_jar = jar;
+                
+                // get the jar entries that correspond to classes
+                List<JarEntry> classEntries = Lists.newArrayList();
+                Enumeration<JarEntry> entries = m_jar.entries();
+                while (entries.hasMoreElements()) {
+                        JarEntry entry = entries.nextElement();
+                        
+                        // is this a class file?
+                        if (entry.getName().endsWith(".class")) {
+                                classEntries.add(entry);
+                        }
+                }
+                m_iter = classEntries.iterator();
+        }
+        
+        @Override
+        public boolean hasNext() {
+                return m_iter.hasNext();
+        }
+        
+        @Override
+        public CtClass next() {
+                JarEntry entry = m_iter.next();
+                try {
+                        return getClass(m_jar, entry);
+                } catch (IOException | NotFoundException ex) {
+                        throw new Error("Unable to load class: " + entry.getName());
+                }
+        }
+        
+        @Override
+        public void remove() {
+                throw new UnsupportedOperationException();
+        }
+        
+        public static List<ClassEntry> getClassEntries(JarFile jar) {
+                List<ClassEntry> classEntries = Lists.newArrayList();
+                Enumeration<JarEntry> entries = jar.entries();
+                while (entries.hasMoreElements()) {
+                        JarEntry entry = entries.nextElement();
+                        
+                        // is this a class file?
+                        if (!entry.isDirectory() && entry.getName().endsWith(".class")) {
+                                classEntries.add(getClassEntry(entry));
+                        }
+                }
+                return classEntries;
+        }
+        
+        public static Iterable<CtClass> classes(final JarFile jar) {
+                return new Iterable<CtClass>() {
+                        @Override
+                        public Iterator<CtClass> iterator() {
+                                return new JarClassIterator(jar);
+                        }
+                };
+        }
+        
+        public static CtClass getClass(JarFile jar, ClassEntry classEntry) {
+                try {
+                        return getClass(jar, new JarEntry(classEntry.getName() + ".class"));
+                } catch (IOException | NotFoundException ex) {
+                        throw new Error("Unable to load class: " + classEntry.getName());
+                }
+        }
+        
+        private static CtClass getClass(JarFile jar, JarEntry entry) throws IOException, NotFoundException {
+                // read the class into a buffer
+                ByteArrayOutputStream bos = new ByteArrayOutputStream();
+                byte[] buf = new byte[Constants.KiB];
+                int totalNumBytesRead = 0;
+                InputStream in = jar.getInputStream(entry);
+                while (in.available() > 0) {
+                        int numBytesRead = in.read(buf);
+                        if (numBytesRead < 0) {
+                                break;
+                        }
+                        bos.write(buf, 0, numBytesRead);
+                        
+                        // sanity checking
+                        totalNumBytesRead += numBytesRead;
+                        if (totalNumBytesRead > Constants.MiB) {
+                                throw new Error("Class file " + entry.getName() + " larger than 1 MiB! Something is wrong!");
+                        }
+                }
+                
+                // get a javassist handle for the class
+                String className = Descriptor.toJavaName(getClassEntry(entry).getName());
+                ClassPool classPool = new ClassPool();
+                classPool.appendSystemPath();
+                classPool.insertClassPath(new ByteArrayClassPath(className, bos.toByteArray()));
+                return classPool.get(className);
+        }
+        
+        private static ClassEntry getClassEntry(JarEntry entry) {
+                return new ClassEntry(entry.getName().substring(0, entry.getName().length() - ".class".length()));
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java
new file mode 100644
index 00000000..3aac8bd0
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/JarIndex.java
@@ -0,0 +1,734 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.lang.reflect.Modifier;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.jar.JarFile;
+
+import javassist.CannotCompileException;
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtField;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.FieldInfo;
+import javassist.expr.ConstructorCall;
+import javassist.expr.ExprEditor;
+import javassist.expr.FieldAccess;
+import javassist.expr.MethodCall;
+import javassist.expr.NewExpr;
+
+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 com.google.common.collect.Sets;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.bytecode.ClassRenamer;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class JarIndex {
+        
+        private Set<ClassEntry> m_obfClassEntries;
+        private TranslationIndex m_translationIndex;
+        private Multimap<String,String> m_interfaces;
+        private Map<Entry,Access> m_access;
+        private Map<FieldEntry,ClassEntry> m_fieldClasses; // TODO: this will become obsolete!
+        private Multimap<String,MethodEntry> m_methodImplementations;
+        private Multimap<BehaviorEntry,EntryReference<BehaviorEntry,BehaviorEntry>> m_behaviorReferences;
+        private Multimap<FieldEntry,EntryReference<FieldEntry,BehaviorEntry>> m_fieldReferences;
+        private Multimap<String,String> m_innerClasses;
+        private Map<String,String> m_outerClasses;
+        private Map<String,BehaviorEntry> m_anonymousClasses;
+        
+        public JarIndex() {
+                m_obfClassEntries = Sets.newHashSet();
+                m_translationIndex = new TranslationIndex();
+                m_interfaces = HashMultimap.create();
+                m_access = Maps.newHashMap();
+                m_fieldClasses = Maps.newHashMap();
+                m_methodImplementations = HashMultimap.create();
+                m_behaviorReferences = HashMultimap.create();
+                m_fieldReferences = HashMultimap.create();
+                m_innerClasses = HashMultimap.create();
+                m_outerClasses = Maps.newHashMap();
+                m_anonymousClasses = Maps.newHashMap();
+        }
+        
+        public void indexJar(JarFile jar, boolean buildInnerClasses) {
+                
+                // step 1: read the class names
+                for (ClassEntry classEntry : JarClassIterator.getClassEntries(jar)) {
+                        if (classEntry.isInDefaultPackage()) {
+                                // move out of default package
+                                classEntry = new ClassEntry(Constants.NonePackage + "/" + classEntry.getName());
+                        }
+                        m_obfClassEntries.add(classEntry);
+                }
+                
+                // step 2: index field/method/constructor access
+                for (CtClass c : JarClassIterator.classes(jar)) {
+                        ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                        for (CtField field : c.getDeclaredFields()) {
+                                m_access.put(JavassistUtil.getFieldEntry(field), Access.get(field));
+                        }
+                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                m_access.put(JavassistUtil.getBehaviorEntry(behavior), Access.get(behavior));
+                        }
+                }
+                
+                // step 3: index extends, implements, fields, and methods
+                for (CtClass c : JarClassIterator.classes(jar)) {
+                        ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                        m_translationIndex.indexClass(c);
+                        String className = Descriptor.toJvmName(c.getName());
+                        for (String interfaceName : c.getClassFile().getInterfaces()) {
+                                className = Descriptor.toJvmName(className);
+                                interfaceName = Descriptor.toJvmName(interfaceName);
+                                if (className.equals(interfaceName)) {
+                                        throw new IllegalArgumentException("Class cannot be its own interface! " + className);
+                                }
+                                m_interfaces.put(className, interfaceName);
+                        }
+                        for (CtField field : c.getDeclaredFields()) {
+                                indexField(field);
+                        }
+                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                indexBehavior(behavior);
+                        }
+                }
+                
+                // step 4: index field, method, constructor references
+                for (CtClass c : JarClassIterator.classes(jar)) {
+                        ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                indexBehaviorReferences(behavior);
+                        }
+                }
+                
+                if (buildInnerClasses) {
+                        // step 5: index inner classes and anonymous classes
+                        for (CtClass c : JarClassIterator.classes(jar)) {
+                                ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                                String outerClassName = findOuterClass(c);
+                                if (outerClassName != null) {
+                                        String innerClassName = c.getSimpleName();
+                                        m_innerClasses.put(outerClassName, innerClassName);
+                                        boolean innerWasAdded = m_outerClasses.put(innerClassName, outerClassName) == null;
+                                        assert (innerWasAdded);
+                                        
+                                        BehaviorEntry enclosingBehavior = isAnonymousClass(c, outerClassName);
+                                        if (enclosingBehavior != null) {
+                                                m_anonymousClasses.put(innerClassName, enclosingBehavior);
+                                                
+                                                // DEBUG
+                                                // System.out.println( "ANONYMOUS: " + outerClassName + "$" + innerClassName );
+                                        } else {
+                                                // DEBUG
+                                                // System.out.println( "INNER: " + outerClassName + "$" + innerClassName );
+                                        }
+                                }
+                        }
+                        
+                        // step 6: update other indices with inner class info
+                        Map<String,String> renames = Maps.newHashMap();
+                        for (Map.Entry<String,String> entry : m_outerClasses.entrySet()) {
+                                renames.put(Constants.NonePackage + "/" + entry.getKey(), entry.getValue() + "$" + entry.getKey());
+                        }
+                        EntryRenamer.renameClassesInSet(renames, m_obfClassEntries);
+                        m_translationIndex.renameClasses(renames);
+                        EntryRenamer.renameClassesInMultimap(renames, m_interfaces);
+                        EntryRenamer.renameClassesInMultimap(renames, m_methodImplementations);
+                        EntryRenamer.renameClassesInMultimap(renames, m_behaviorReferences);
+                        EntryRenamer.renameClassesInMultimap(renames, m_fieldReferences);
+                        EntryRenamer.renameClassesInMap(renames, m_access);
+                }
+        }
+        
+        private void indexField(CtField field) {
+                // get the field entry
+                String className = Descriptor.toJvmName(field.getDeclaringClass().getName());
+                FieldEntry fieldEntry = new FieldEntry(new ClassEntry(className), field.getName());
+                
+                // is the field a class type?
+                if (field.getSignature().startsWith("L")) {
+                        ClassEntry fieldTypeEntry = new ClassEntry(field.getSignature().substring(1, field.getSignature().length() - 1));
+                        m_fieldClasses.put(fieldEntry, fieldTypeEntry);
+                }
+        }
+        
+        private void indexBehavior(CtBehavior behavior) {
+                // get the behavior entry
+                final BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(behavior);
+                if (behaviorEntry instanceof MethodEntry) {
+                        MethodEntry methodEntry = (MethodEntry)behaviorEntry;
+                        
+                        // index implementation
+                        m_methodImplementations.put(behaviorEntry.getClassName(), methodEntry);
+                }
+                // looks like we don't care about constructors here
+        }
+        
+        private void indexBehaviorReferences(CtBehavior behavior) {
+                // index method calls
+                final BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(behavior);
+                try {
+                        behavior.instrument(new ExprEditor() {
+                                @Override
+                                public void edit(MethodCall call) {
+                                        MethodEntry calledMethodEntry = JavassistUtil.getMethodEntry(call);
+                                        ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledMethodEntry);
+                                        if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledMethodEntry.getClassEntry())) {
+                                                calledMethodEntry = new MethodEntry(
+                                                        resolvedClassEntry,
+                                                        calledMethodEntry.getName(),
+                                                        calledMethodEntry.getSignature()
+                                                );
+                                        }
+                                        EntryReference<BehaviorEntry,BehaviorEntry> reference = new EntryReference<BehaviorEntry,BehaviorEntry>(
+                                                calledMethodEntry,
+                                                call.getMethodName(),
+                                                behaviorEntry
+                                        );
+                                        m_behaviorReferences.put(calledMethodEntry, reference);
+                                }
+                                
+                                @Override
+                                public void edit(FieldAccess call) {
+                                        FieldEntry calledFieldEntry = JavassistUtil.getFieldEntry(call);
+                                        ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledFieldEntry);
+                                        if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledFieldEntry.getClassEntry())) {
+                                                calledFieldEntry = new FieldEntry(resolvedClassEntry, call.getFieldName());
+                                        }
+                                        EntryReference<FieldEntry,BehaviorEntry> reference = new EntryReference<FieldEntry,BehaviorEntry>(
+                                                calledFieldEntry,
+                                                call.getFieldName(),
+                                                behaviorEntry
+                                        );
+                                        m_fieldReferences.put(calledFieldEntry, reference);
+                                }
+                                
+                                @Override
+                                public void edit(ConstructorCall call) {
+                                        ConstructorEntry calledConstructorEntry = JavassistUtil.getConstructorEntry(call);
+                                        EntryReference<BehaviorEntry,BehaviorEntry> reference = new EntryReference<BehaviorEntry,BehaviorEntry>(
+                                                calledConstructorEntry,
+                                                call.getMethodName(),
+                                                behaviorEntry
+                                        );
+                                        m_behaviorReferences.put(calledConstructorEntry, reference);
+                                }
+                                
+                                @Override
+                                public void edit(NewExpr call) {
+                                        ConstructorEntry calledConstructorEntry = JavassistUtil.getConstructorEntry(call);
+                                        EntryReference<BehaviorEntry,BehaviorEntry> reference = new EntryReference<BehaviorEntry,BehaviorEntry>(
+                                                calledConstructorEntry,
+                                                call.getClassName(),
+                                                behaviorEntry
+                                        );
+                                        m_behaviorReferences.put(calledConstructorEntry, reference);
+                                }
+                        });
+                } catch (CannotCompileException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private String findOuterClass(CtClass c) {
+                
+                // inner classes:
+                // have constructors that can (illegally) set synthetic fields
+                // the outer class is the only class that calls constructors
+                
+                // use the synthetic fields to find the synthetic constructors
+                for (CtConstructor constructor : c.getDeclaredConstructors()) {
+                        Set<String> syntheticFieldTypes = Sets.newHashSet();
+                        if (!isIllegalConstructor(syntheticFieldTypes, constructor)) {
+                                continue;
+                        }
+                        
+                        ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                        ConstructorEntry constructorEntry = JavassistUtil.getConstructorEntry(constructor);
+                        
+                        // gather the classes from the illegally-set synthetic fields
+                        Set<ClassEntry> illegallySetClasses = Sets.newHashSet();
+                        for (String type : syntheticFieldTypes) {
+                                if (type.startsWith("L")) {
+                                        ClassEntry outerClassEntry = new ClassEntry(type.substring(1, type.length() - 1));
+                                        if (isSaneOuterClass(outerClassEntry, classEntry)) {
+                                                illegallySetClasses.add(outerClassEntry);
+                                        }
+                                }
+                        }
+                        
+                        // who calls this constructor?
+                        Set<ClassEntry> callerClasses = Sets.newHashSet();
+                        for (EntryReference<BehaviorEntry,BehaviorEntry> reference : getBehaviorReferences(constructorEntry)) {
+                                
+                                // make sure it's not a call to super
+                                if (reference.entry instanceof ConstructorEntry && reference.context instanceof ConstructorEntry) {
+                                        
+                                        // is the entry a superclass of the context?
+                                        ClassEntry calledClassEntry = reference.entry.getClassEntry();
+                                        ClassEntry superclassEntry = m_translationIndex.getSuperclass(reference.context.getClassEntry());
+                                        if (superclassEntry != null && superclassEntry.equals(calledClassEntry)) {
+                                                // it's a super call, skip
+                                                continue;
+                                        }
+                                }
+                                
+                                if (isSaneOuterClass(reference.context.getClassEntry(), classEntry)) {
+                                        callerClasses.add(reference.context.getClassEntry());
+                                }
+                        }
+                        
+                        // do we have an answer yet?
+                        if (callerClasses.isEmpty()) {
+                                if (illegallySetClasses.size() == 1) {
+                                        return illegallySetClasses.iterator().next().getName();
+                                } else {
+                                        System.out.println(String.format("WARNING: Unable to find outer class for %s. No caller and no illegally set field classes.", classEntry));
+                                }
+                        } else {
+                                if (callerClasses.size() == 1) {
+                                        return callerClasses.iterator().next().getName();
+                                } else {
+                                        // multiple callers, do the illegally set classes narrow it down?
+                                        Set<ClassEntry> intersection = Sets.newHashSet(callerClasses);
+                                        intersection.retainAll(illegallySetClasses);
+                                        if (intersection.size() == 1) {
+                                                return intersection.iterator().next().getName();
+                                        } else {
+                                                System.out.println(String.format("WARNING: Unable to choose outer class for %s among options: %s", classEntry, callerClasses));
+                                        }
+                                }
+                        }
+                }
+                
+                return null;
+        }
+        
+        private boolean isSaneOuterClass(ClassEntry outerClassEntry, ClassEntry innerClassEntry) {
+                
+                // clearly this would be silly
+                if (outerClassEntry.equals(innerClassEntry)) {
+                        return false;
+                }
+                
+                // is the outer class in the jar?
+                if (!m_obfClassEntries.contains(outerClassEntry)) {
+                        return false;
+                }
+                
+                return true;
+        }
+        
+        @SuppressWarnings("unchecked")
+        private boolean isIllegalConstructor(Set<String> syntheticFieldTypes, CtConstructor constructor) {
+                
+                // illegal constructors only set synthetic member fields, then call super()
+                String className = constructor.getDeclaringClass().getName();
+                
+                // collect all the field accesses, constructor calls, and method calls
+                final List<FieldAccess> illegalFieldWrites = Lists.newArrayList();
+                final List<ConstructorCall> constructorCalls = Lists.newArrayList();
+                try {
+                        constructor.instrument(new ExprEditor() {
+                                @Override
+                                public void edit(FieldAccess fieldAccess) {
+                                        if (fieldAccess.isWriter() && constructorCalls.isEmpty()) {
+                                                illegalFieldWrites.add(fieldAccess);
+                                        }
+                                }
+                                
+                                @Override
+                                public void edit(ConstructorCall constructorCall) {
+                                        constructorCalls.add(constructorCall);
+                                }
+                        });
+                } catch (CannotCompileException ex) {
+                        // we're not compiling anything... this is stupid
+                        throw new Error(ex);
+                }
+                
+                // are there any illegal field writes?
+                if (illegalFieldWrites.isEmpty()) {
+                        return false;
+                }
+                
+                // are all the writes to synthetic fields?
+                for (FieldAccess fieldWrite : illegalFieldWrites) {
+                        
+                        // all illegal writes have to be to the local class
+                        if (!fieldWrite.getClassName().equals(className)) {
+                                System.err.println(String.format("WARNING: illegal write to non-member field %s.%s", fieldWrite.getClassName(), fieldWrite.getFieldName()));
+                                return false;
+                        }
+                        
+                        // find the field
+                        FieldInfo fieldInfo = null;
+                        for (FieldInfo info : (List<FieldInfo>)constructor.getDeclaringClass().getClassFile().getFields()) {
+                                if (info.getName().equals(fieldWrite.getFieldName()) && info.getDescriptor().equals(fieldWrite.getSignature())) {
+                                        fieldInfo = info;
+                                        break;
+                                }
+                        }
+                        if (fieldInfo == null) {
+                                // field is in a superclass or something, can't be a local synthetic member
+                                return false;
+                        }
+                        
+                        // is this field synthetic?
+                        boolean isSynthetic = (fieldInfo.getAccessFlags() & AccessFlag.SYNTHETIC) != 0;
+                        if (isSynthetic) {
+                                syntheticFieldTypes.add(fieldInfo.getDescriptor());
+                        } else {
+                                System.err.println(String.format("WARNING: illegal write to non synthetic field %s %s.%s", fieldInfo.getDescriptor(), className, fieldInfo.getName()));
+                                return false;
+                        }
+                }
+                
+                // we passed all the tests!
+                return true;
+        }
+        
+        private BehaviorEntry isAnonymousClass(CtClass c, String outerClassName) {
+                
+                ClassEntry innerClassEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                
+                // anonymous classes:
+                // can't be abstract
+                // have only one constructor
+                // it's called exactly once by the outer class
+                // the type the instance is assigned to can't be this type
+                
+                // is abstract?
+                if (Modifier.isAbstract(c.getModifiers())) {
+                        return null;
+                }
+                
+                // is there exactly one constructor?
+                if (c.getDeclaredConstructors().length != 1) {
+                        return null;
+                }
+                CtConstructor constructor = c.getDeclaredConstructors()[0];
+                
+                // is this constructor called exactly once?
+                ConstructorEntry constructorEntry = JavassistUtil.getConstructorEntry(constructor);
+                Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references = getBehaviorReferences(constructorEntry);
+                if (references.size() != 1) {
+                        return null;
+                }
+                
+                // does the caller use this type?
+                BehaviorEntry caller = references.iterator().next().context;
+                for (FieldEntry fieldEntry : getReferencedFields(caller)) {
+                        ClassEntry fieldClass = getFieldClass(fieldEntry);
+                        if (fieldClass != null && fieldClass.equals(innerClassEntry)) {
+                                // caller references this type, so it can't be anonymous
+                                return null;
+                        }
+                }
+                for (BehaviorEntry behaviorEntry : getReferencedBehaviors(caller)) {
+                        if (behaviorEntry.getSignature().hasClass(innerClassEntry)) {
+                                return null;
+                        }
+                }
+                
+                return caller;
+        }
+        
+        public Set<ClassEntry> getObfClassEntries() {
+                return m_obfClassEntries;
+        }
+        
+        public TranslationIndex getTranslationIndex() {
+                return m_translationIndex;
+        }
+        
+        public Access getAccess(Entry entry) {
+                return m_access.get(entry);
+        }
+        
+        public ClassEntry getFieldClass(FieldEntry fieldEntry) {
+                return m_fieldClasses.get(fieldEntry);
+        }
+        
+        public ClassInheritanceTreeNode getClassInheritance(Translator deobfuscatingTranslator, ClassEntry obfClassEntry) {
+                
+                // get the root node
+                List<String> ancestry = Lists.newArrayList();
+                ancestry.add(obfClassEntry.getName());
+                for (ClassEntry classEntry : m_translationIndex.getAncestry(obfClassEntry)) {
+                        ancestry.add(classEntry.getName());
+                }
+                ClassInheritanceTreeNode rootNode = new ClassInheritanceTreeNode(
+                        deobfuscatingTranslator,
+                        ancestry.get(ancestry.size() - 1)
+                );
+                
+                // expand all children recursively
+                rootNode.load(m_translationIndex, true);
+                
+                return rootNode;
+        }
+        
+        public ClassImplementationsTreeNode getClassImplementations(Translator deobfuscatingTranslator, ClassEntry obfClassEntry) {
+                
+                // is this even an interface?
+                if (isInterface(obfClassEntry.getClassName())) {
+                        ClassImplementationsTreeNode node = new ClassImplementationsTreeNode(deobfuscatingTranslator, obfClassEntry);
+                        node.load(this);
+                        return node;
+                }
+                return null;
+        }
+        
+        public MethodInheritanceTreeNode getMethodInheritance(Translator deobfuscatingTranslator, MethodEntry obfMethodEntry) {
+                
+                // travel to the ancestor implementation
+                ClassEntry baseImplementationClassEntry = obfMethodEntry.getClassEntry();
+                for (ClassEntry ancestorClassEntry : m_translationIndex.getAncestry(obfMethodEntry.getClassEntry())) {
+                        MethodEntry ancestorMethodEntry = new MethodEntry(
+                                new ClassEntry(ancestorClassEntry),
+                                obfMethodEntry.getName(),
+                                obfMethodEntry.getSignature()
+                        );
+                        if (containsObfBehavior(ancestorMethodEntry)) {
+                                baseImplementationClassEntry = ancestorClassEntry;
+                        }
+                }
+                
+                // make a root node at the base
+                MethodEntry methodEntry = new MethodEntry(
+                        baseImplementationClassEntry,
+                        obfMethodEntry.getName(),
+                        obfMethodEntry.getSignature()
+                );
+                MethodInheritanceTreeNode rootNode = new MethodInheritanceTreeNode(
+                        deobfuscatingTranslator,
+                        methodEntry,
+                        containsObfBehavior(methodEntry)
+                );
+                
+                // expand the full tree
+                rootNode.load(this, true);
+                
+                return rootNode;
+        }
+        
+        public MethodImplementationsTreeNode getMethodImplementations(Translator deobfuscatingTranslator, MethodEntry obfMethodEntry) {
+                
+                MethodEntry interfaceMethodEntry;
+                
+                // is this method on an interface?
+                if (isInterface(obfMethodEntry.getClassName())) {
+                        interfaceMethodEntry = obfMethodEntry;
+                } else {
+                        // get the interface class
+                        List<MethodEntry> methodInterfaces = Lists.newArrayList();
+                        for (String interfaceName : getInterfaces(obfMethodEntry.getClassName())) {
+                                // is this method defined in this interface?
+                                MethodEntry methodInterface = new MethodEntry(
+                                        new ClassEntry(interfaceName),
+                                        obfMethodEntry.getName(),
+                                        obfMethodEntry.getSignature()
+                                );
+                                if (containsObfBehavior(methodInterface)) {
+                                        methodInterfaces.add(methodInterface);
+                                }
+                        }
+                        if (methodInterfaces.isEmpty()) {
+                                return null;
+                        }
+                        if (methodInterfaces.size() > 1) {
+                                throw new Error("Too many interfaces define this method! This is not yet supported by Enigma!");
+                        }
+                        interfaceMethodEntry = methodInterfaces.get(0);
+                }
+                
+                MethodImplementationsTreeNode rootNode = new MethodImplementationsTreeNode(deobfuscatingTranslator, interfaceMethodEntry);
+                rootNode.load(this);
+                return rootNode;
+        }
+        
+        public Set<MethodEntry> getRelatedMethodImplementations(MethodEntry obfMethodEntry) {
+                Set<MethodEntry> methodEntries = Sets.newHashSet();
+                getRelatedMethodImplementations(methodEntries, getMethodInheritance(null, obfMethodEntry));
+                return methodEntries;
+        }
+        
+        private void getRelatedMethodImplementations(Set<MethodEntry> methodEntries, MethodInheritanceTreeNode node) {
+                MethodEntry methodEntry = node.getMethodEntry();
+                if (containsObfBehavior(methodEntry)) {
+                        // collect the entry
+                        methodEntries.add(methodEntry);
+                }
+                
+                // look at interface methods too
+                MethodImplementationsTreeNode implementations = getMethodImplementations(null, methodEntry);
+                if (implementations != null) {
+                        getRelatedMethodImplementations(methodEntries, implementations);
+                }
+                
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        getRelatedMethodImplementations(methodEntries, (MethodInheritanceTreeNode)node.getChildAt(i));
+                }
+        }
+        
+        private void getRelatedMethodImplementations(Set<MethodEntry> methodEntries, MethodImplementationsTreeNode node) {
+                MethodEntry methodEntry = node.getMethodEntry();
+                if (containsObfBehavior(methodEntry)) {
+                        // collect the entry
+                        methodEntries.add(methodEntry);
+                }
+                
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        getRelatedMethodImplementations(methodEntries, (MethodImplementationsTreeNode)node.getChildAt(i));
+                }
+        }
+        
+        public Collection<EntryReference<FieldEntry,BehaviorEntry>> getFieldReferences(FieldEntry fieldEntry) {
+                return m_fieldReferences.get(fieldEntry);
+        }
+        
+        public Collection<FieldEntry> getReferencedFields(BehaviorEntry behaviorEntry) {
+                // linear search is fast enough for now
+                Set<FieldEntry> fieldEntries = Sets.newHashSet();
+                for (EntryReference<FieldEntry,BehaviorEntry> reference : m_fieldReferences.values()) {
+                        if (reference.context == behaviorEntry) {
+                                fieldEntries.add(reference.entry);
+                        }
+                }
+                return fieldEntries;
+        }
+        
+        public Collection<EntryReference<BehaviorEntry,BehaviorEntry>> getBehaviorReferences(BehaviorEntry behaviorEntry) {
+                return m_behaviorReferences.get(behaviorEntry);
+        }
+        
+        public Collection<BehaviorEntry> getReferencedBehaviors(BehaviorEntry behaviorEntry) {
+                // linear search is fast enough for now
+                Set<BehaviorEntry> behaviorEntries = Sets.newHashSet();
+                for (EntryReference<BehaviorEntry,BehaviorEntry> reference : m_behaviorReferences.values()) {
+                        if (reference.context == behaviorEntry) {
+                                behaviorEntries.add(reference.entry);
+                        }
+                }
+                return behaviorEntries;
+        }
+        
+        public Collection<String> getInnerClasses(String obfOuterClassName) {
+                return m_innerClasses.get(obfOuterClassName);
+        }
+        
+        public String getOuterClass(String obfInnerClassName) {
+                // make sure we use the right name
+                if (new ClassEntry(obfInnerClassName).getPackageName() != null) {
+                        throw new IllegalArgumentException("Don't reference obfuscated inner classes using packages: " + obfInnerClassName);
+                }
+                return m_outerClasses.get(obfInnerClassName);
+        }
+        
+        public boolean isAnonymousClass(String obfInnerClassName) {
+                return m_anonymousClasses.containsKey(obfInnerClassName);
+        }
+        
+        public BehaviorEntry getAnonymousClassCaller(String obfInnerClassName) {
+                return m_anonymousClasses.get(obfInnerClassName);
+        }
+        
+        public Set<String> getInterfaces(String className) {
+                Set<String> interfaceNames = new HashSet<String>();
+                interfaceNames.addAll(m_interfaces.get(className));
+                for (ClassEntry ancestor : m_translationIndex.getAncestry(new ClassEntry(className))) {
+                        interfaceNames.addAll(m_interfaces.get(ancestor.getName()));
+                }
+                return interfaceNames;
+        }
+        
+        public Set<String> getImplementingClasses(String targetInterfaceName) {
+                // linear search is fast enough for now
+                Set<String> classNames = Sets.newHashSet();
+                for (Map.Entry<String,String> entry : m_interfaces.entries()) {
+                        String className = entry.getKey();
+                        String interfaceName = entry.getValue();
+                        if (interfaceName.equals(targetInterfaceName)) {
+                                classNames.add(className);
+                                m_translationIndex.getSubclassNamesRecursively(classNames, new ClassEntry(className));
+                        }
+                }
+                return classNames;
+        }
+        
+        public boolean isInterface(String className) {
+                return m_interfaces.containsValue(className);
+        }
+        
+        public boolean containsObfClass(ClassEntry obfClassEntry) {
+                return m_obfClassEntries.contains(obfClassEntry);
+        }
+        
+        public boolean containsObfField(FieldEntry obfFieldEntry) {
+                return m_access.containsKey(obfFieldEntry);
+        }
+        
+        public boolean containsObfBehavior(BehaviorEntry obfBehaviorEntry) {
+                return m_access.containsKey(obfBehaviorEntry);
+        }
+        
+        public boolean containsObfArgument(ArgumentEntry obfArgumentEntry) {
+                // check the behavior
+                if (!containsObfBehavior(obfArgumentEntry.getBehaviorEntry())) {
+                        return false;
+                }
+                
+                // check the argument
+                if (obfArgumentEntry.getIndex() >= obfArgumentEntry.getBehaviorEntry().getSignature().getArgumentTypes().size()) {
+                        return false;
+                }
+                
+                return true;
+        }
+        
+        public boolean containsObfEntry(Entry obfEntry) {
+                if (obfEntry instanceof ClassEntry) {
+                        return containsObfClass((ClassEntry)obfEntry);
+                } else if (obfEntry instanceof FieldEntry) {
+                        return containsObfField((FieldEntry)obfEntry);
+                } else if (obfEntry instanceof BehaviorEntry) {
+                        return containsObfBehavior((BehaviorEntry)obfEntry);
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        return containsObfArgument((ArgumentEntry)obfEntry);
+                } else {
+                        throw new Error("Entry type not supported: " + obfEntry.getClass().getName());
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java b/src/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
new file mode 100644
index 00000000..10092268
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class MethodImplementationsTreeNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = 3781080657461899915L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private MethodEntry m_entry;
+        
+        public MethodImplementationsTreeNode(Translator deobfuscatingTranslator, MethodEntry entry) {
+                if (entry == null) {
+                        throw new IllegalArgumentException("entry cannot be null!");
+                }
+                
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+        }
+        
+        public MethodEntry getMethodEntry() {
+                return m_entry;
+        }
+        
+        public String getDeobfClassName() {
+                return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        }
+        
+        public String getDeobfMethodName() {
+                return m_deobfuscatingTranslator.translate(m_entry);
+        }
+        
+        @Override
+        public String toString() {
+                String className = getDeobfClassName();
+                if (className == null) {
+                        className = m_entry.getClassName();
+                }
+                
+                String methodName = getDeobfMethodName();
+                if (methodName == null) {
+                        methodName = m_entry.getName();
+                }
+                return className + "." + methodName + "()";
+        }
+        
+        public void load(JarIndex index) {
+                // get all method implementations
+                List<MethodImplementationsTreeNode> nodes = Lists.newArrayList();
+                for (String implementingClassName : index.getImplementingClasses(m_entry.getClassName())) {
+                        MethodEntry methodEntry = new MethodEntry(
+                                new ClassEntry(implementingClassName),
+                                m_entry.getName(),
+                                m_entry.getSignature()
+                        );
+                        if (index.containsObfBehavior(methodEntry)) {
+                                nodes.add(new MethodImplementationsTreeNode(m_deobfuscatingTranslator, methodEntry));
+                        }
+                }
+                
+                // add them to this node
+                for (MethodImplementationsTreeNode node : nodes) {
+                        this.add(node);
+                }
+        }
+        
+        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;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java b/src/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
new file mode 100644
index 00000000..87182204
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class MethodInheritanceTreeNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = 1096677030991810007L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private MethodEntry m_entry;
+        private boolean m_isImplemented;
+        
+        public MethodInheritanceTreeNode(Translator deobfuscatingTranslator, MethodEntry entry, boolean isImplemented) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+                m_isImplemented = isImplemented;
+        }
+        
+        public MethodEntry getMethodEntry() {
+                return m_entry;
+        }
+        
+        public String getDeobfClassName() {
+                return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        }
+        
+        public String getDeobfMethodName() {
+                return m_deobfuscatingTranslator.translate(m_entry);
+        }
+        
+        public boolean isImplemented() {
+                return m_isImplemented;
+        }
+        
+        @Override
+        public String toString() {
+                String className = getDeobfClassName();
+                if (className == null) {
+                        className = m_entry.getClassName();
+                }
+                
+                if (!m_isImplemented) {
+                        return className;
+                } else {
+                        String methodName = getDeobfMethodName();
+                        if (methodName == null) {
+                                methodName = m_entry.getName();
+                        }
+                        return className + "." + methodName + "()";
+                }
+        }
+        
+        public void load(JarIndex index, boolean recurse) {
+                // get all the child nodes
+                List<MethodInheritanceTreeNode> nodes = Lists.newArrayList();
+                for (ClassEntry subclassEntry : index.getTranslationIndex().getSubclass(m_entry.getClassEntry())) {
+                        MethodEntry methodEntry = new MethodEntry(
+                                subclassEntry,
+                                m_entry.getName(),
+                                m_entry.getSignature()
+                        );
+                        nodes.add(new MethodInheritanceTreeNode(
+                                m_deobfuscatingTranslator,
+                                methodEntry,
+                                index.containsObfBehavior(methodEntry)
+                        ));
+                }
+                
+                // add them to this node
+                for (MethodInheritanceTreeNode node : nodes) {
+                        this.add(node);
+                }
+                
+                if (recurse) {
+                        for (MethodInheritanceTreeNode node : nodes) {
+                                node.load(index, true);
+                        }
+                }
+        }
+        
+        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;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/ReferenceTreeNode.java b/src/cuchaz/enigma/analysis/ReferenceTreeNode.java
new file mode 100644
index 00000000..2b08616a
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/ReferenceTreeNode.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import cuchaz.enigma.mapping.Entry;
+
+public interface ReferenceTreeNode<E extends Entry,C extends Entry> {
+        E getEntry();
+        EntryReference<E,C> getReference();
+}
diff --git a/src/cuchaz/enigma/analysis/SourceIndex.java b/src/cuchaz/enigma/analysis/SourceIndex.java
new file mode 100644
index 00000000..b43ab614
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/SourceIndex.java
@@ -0,0 +1,173 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+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 com.strobel.decompiler.languages.Region;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+
+import cuchaz.enigma.mapping.Entry;
+
+public class SourceIndex {
+        
+        private String m_source;
+        private TreeMap<Token,EntryReference<Entry,Entry>> m_tokenToReference;
+        private Multimap<EntryReference<Entry,Entry>,Token> m_referenceToTokens;
+        private Map<Entry,Token> m_declarationToToken;
+        private List<Integer> m_lineOffsets;
+        
+        public SourceIndex(String source) {
+                m_source = source;
+                m_tokenToReference = Maps.newTreeMap();
+                m_referenceToTokens = HashMultimap.create();
+                m_declarationToToken = Maps.newHashMap();
+                m_lineOffsets = Lists.newArrayList();
+                
+                // count the lines
+                m_lineOffsets.add(0);
+                for (int i = 0; i < source.length(); i++) {
+                        if (source.charAt(i) == '\n') {
+                                m_lineOffsets.add(i + 1);
+                        }
+                }
+        }
+        
+        public String getSource() {
+                return m_source;
+        }
+        
+        public Token getToken(AstNode node) {
+                
+                // get the text of the node
+                String name = "";
+                if (node instanceof Identifier) {
+                        name = ((Identifier)node).getName();
+                }
+                
+                // get a token for this node's region
+                Region region = node.getRegion();
+                if (region.getBeginLine() == 0 || region.getEndLine() == 0) {
+                        // DEBUG
+                        System.err.println(String.format("WARNING: %s \"%s\" has invalid region: %s", node.getNodeType(), name, region));
+                        return null;
+                }
+                Token token = new Token(
+                        toPos(region.getBeginLine(), region.getBeginColumn()),
+                        toPos(region.getEndLine(), region.getEndColumn()),
+                        m_source
+                );
+                if (token.start == 0) {
+                        // DEBUG
+                        System.err.println(String.format("WARNING: %s \"%s\" has invalid start: %s", node.getNodeType(), name, region));
+                        return null;
+                }
+                
+                // DEBUG
+                // System.out.println( String.format( "%s \"%s\" region: %s", node.getNodeType(), name, region ) );
+                
+                // for tokens representing inner classes, make sure we only get the simple name
+                int pos = name.lastIndexOf('$');
+                if (pos >= 0) {
+                        token.end -= pos + 1;
+                }
+                
+                return token;
+        }
+        
+        public void addReference(AstNode node, Entry deobfEntry, Entry deobfContext) {
+                Token token = getToken(node);
+                if (token != null) {
+                        EntryReference<Entry,Entry> deobfReference = new EntryReference<Entry,Entry>(deobfEntry, token.text, deobfContext);
+                        m_tokenToReference.put(token, deobfReference);
+                        m_referenceToTokens.put(deobfReference, token);
+                }
+        }
+        
+        public void addDeclaration(AstNode node, Entry deobfEntry) {
+                Token token = getToken(node);
+                if (token != null) {
+                        EntryReference<Entry,Entry> reference = new EntryReference<Entry,Entry>(deobfEntry, token.text);
+                        m_tokenToReference.put(token, reference);
+                        m_referenceToTokens.put(reference, token);
+                        m_declarationToToken.put(deobfEntry, token);
+                }
+        }
+        
+        public Token getReferenceToken(int pos) {
+                Token token = m_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 m_referenceToTokens.get(deobfReference);
+        }
+        
+        public EntryReference<Entry,Entry> getDeobfReference(Token token) {
+                if (token == null) {
+                        return null;
+                }
+                return m_tokenToReference.get(token);
+        }
+        
+        public void replaceDeobfReference(Token token, EntryReference<Entry,Entry> newDeobfReference) {
+                EntryReference<Entry,Entry> oldDeobfReference = m_tokenToReference.get(token);
+                m_tokenToReference.put(token, newDeobfReference);
+                Collection<Token> tokens = m_referenceToTokens.get(oldDeobfReference);
+                m_referenceToTokens.removeAll(oldDeobfReference);
+                m_referenceToTokens.putAll(newDeobfReference, tokens);
+        }
+        
+        public Iterable<Token> referenceTokens() {
+                return m_tokenToReference.keySet();
+        }
+        
+        public Iterable<Token> declarationTokens() {
+                return m_declarationToToken.values();
+        }
+        
+        public Token getDeclarationToken(Entry deobfEntry) {
+                return m_declarationToToken.get(deobfEntry);
+        }
+        
+        public int getLineNumber(int pos) {
+                // line number is 1-based
+                int line = 0;
+                for (Integer offset : m_lineOffsets) {
+                        if (offset > pos) {
+                                break;
+                        }
+                        line++;
+                }
+                return line;
+        }
+        
+        public int getColumnNumber(int pos) {
+                // column number is 1-based
+                return pos - m_lineOffsets.get(getLineNumber(pos) - 1) + 1;
+        }
+        
+        private int toPos(int line, int col) {
+                // line and col are 1-based
+                return m_lineOffsets.get(line - 1) + col - 1;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
new file mode 100644
index 00000000..41551283
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
@@ -0,0 +1,164 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import com.strobel.assembler.metadata.MemberReference;
+import com.strobel.assembler.metadata.MethodDefinition;
+import com.strobel.assembler.metadata.MethodReference;
+import com.strobel.assembler.metadata.ParameterDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+import com.strobel.decompiler.languages.TextLocation;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.IdentifierExpression;
+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.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.SuperReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ThisReferenceExpression;
+
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
+        
+        private BehaviorEntry m_behaviorEntry;
+        
+        public SourceIndexBehaviorVisitor(BehaviorEntry behaviorEntry) {
+                m_behaviorEntry = behaviorEntry;
+        }
+        
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @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());
+                BehaviorEntry behaviorEntry = null;
+                if (ref instanceof MethodReference) {
+                        MethodReference methodRef = (MethodReference)ref;
+                        if (methodRef.isConstructor()) {
+                                behaviorEntry = new ConstructorEntry(classEntry, new Signature(ref.getSignature()));
+                        } else if (methodRef.isTypeInitializer()) {
+                                behaviorEntry = new ConstructorEntry(classEntry);
+                        } else {
+                                behaviorEntry = new MethodEntry(classEntry, ref.getName(), new Signature(ref.getSignature()));
+                        }
+                }
+                if (behaviorEntry != 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(tokenNode, behaviorEntry, m_behaviorEntry);
+                        }
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitMemberReferenceExpression(MemberReferenceExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                if (ref != null) {
+                        // make sure this is actually a field
+                        if (ref.getSignature().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());
+                        index.addReference(node.getMemberNameToken(), fieldEntry, m_behaviorEntry);
+                }
+                
+                return recurse(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(node.getIdentifierToken(), classEntry, m_behaviorEntry);
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitParameterDeclaration(ParameterDeclaration node, SourceIndex index) {
+                ParameterDefinition def = node.getUserData(Keys.PARAMETER_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                MethodDefinition methodDef = (MethodDefinition)def.getMethod();
+                BehaviorEntry behaviorEntry;
+                if (methodDef.isConstructor()) {
+                        behaviorEntry = new ConstructorEntry(classEntry, new Signature(methodDef.getSignature()));
+                } else {
+                        behaviorEntry = new MethodEntry(classEntry, methodDef.getName(), new Signature(methodDef.getSignature()));
+                }
+                ArgumentEntry argumentEntry = new ArgumentEntry(behaviorEntry, def.getPosition(), node.getName());
+                index.addDeclaration(node.getNameToken(), argumentEntry);
+                
+                return recurse(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());
+                        index.addReference(node.getIdentifierToken(), fieldEntry, m_behaviorEntry);
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitObjectCreationExpression(ObjectCreationExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                if (ref != null) {
+                        ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                        ConstructorEntry constructorEntry = new ConstructorEntry(classEntry, new Signature(ref.getSignature()));
+                        if (node.getType() instanceof SimpleType) {
+                                SimpleType simpleTypeNode = (SimpleType)node.getType();
+                                index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, m_behaviorEntry);
+                        }
+                }
+                
+                return recurse(node, index);
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
new file mode 100644
index 00000000..72220350
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+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.AstNode;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.EnumValueDeclaration;
+import com.strobel.decompiler.languages.java.ast.FieldDeclaration;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import com.strobel.decompiler.languages.java.ast.VariableInitializer;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class SourceIndexClassVisitor extends SourceIndexVisitor {
+        
+        private ClassEntry m_classEntry;
+        
+        public SourceIndexClassVisitor(ClassEntry classEntry) {
+                m_classEntry = classEntry;
+        }
+        
+        @Override
+        public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) {
+                // is this this class, or a subtype?
+                TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getInternalName());
+                if (!classEntry.equals(m_classEntry)) {
+                        // it's a sub-type, recurse
+                        index.addDeclaration(node.getNameToken(), classEntry);
+                        return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
+                }
+                
+                return recurse(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(node.getIdentifierToken(), classEntry, m_classEntry);
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
+                MethodDefinition def = node.getUserData(Keys.METHOD_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(classEntry, def.getName(), def.getSignature());
+                AstNode tokenNode = node.getNameToken();
+                if (behaviorEntry instanceof ConstructorEntry) {
+                        ConstructorEntry constructorEntry = (ConstructorEntry)behaviorEntry;
+                        if (constructorEntry.isStatic()) {
+                                tokenNode = node.getModifiers().firstOrNullObject();
+                        }
+                }
+                index.addDeclaration(tokenNode, behaviorEntry);
+                return node.acceptVisitor(new SourceIndexBehaviorVisitor(behaviorEntry), index);
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
+                MethodDefinition def = node.getUserData(Keys.METHOD_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                ConstructorEntry constructorEntry = new ConstructorEntry(classEntry, new Signature(def.getSignature()));
+                index.addDeclaration(node.getNameToken(), constructorEntry);
+                return node.acceptVisitor(new SourceIndexBehaviorVisitor(constructorEntry), index);
+        }
+        
+        @Override
+        public Void visitFieldDeclaration(FieldDeclaration node, SourceIndex index) {
+                FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                FieldEntry fieldEntry = new FieldEntry(classEntry, def.getName());
+                assert (node.getVariables().size() == 1);
+                VariableInitializer variable = node.getVariables().firstOrNullObject();
+                index.addDeclaration(variable.getNameToken(), fieldEntry);
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitEnumValueDeclaration(EnumValueDeclaration node, SourceIndex index) {
+                // treat enum declarations as field declarations
+                FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                FieldEntry fieldEntry = new FieldEntry(classEntry, def.getName());
+                index.addDeclaration(node.getNameToken(), fieldEntry);
+                
+                return recurse(node, index);
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
new file mode 100644
index 00000000..0d5bdc02
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
@@ -0,0 +1,452 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.decompiler.languages.java.ast.Annotation;
+import com.strobel.decompiler.languages.java.ast.AnonymousObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayInitializerExpression;
+import com.strobel.decompiler.languages.java.ast.ArraySpecifier;
+import com.strobel.decompiler.languages.java.ast.AssertStatement;
+import com.strobel.decompiler.languages.java.ast.AssignmentExpression;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.BinaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.BlockStatement;
+import com.strobel.decompiler.languages.java.ast.BreakStatement;
+import com.strobel.decompiler.languages.java.ast.CaseLabel;
+import com.strobel.decompiler.languages.java.ast.CastExpression;
+import com.strobel.decompiler.languages.java.ast.CatchClause;
+import com.strobel.decompiler.languages.java.ast.ClassOfExpression;
+import com.strobel.decompiler.languages.java.ast.Comment;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+import com.strobel.decompiler.languages.java.ast.ComposedType;
+import com.strobel.decompiler.languages.java.ast.ConditionalExpression;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.ContinueStatement;
+import com.strobel.decompiler.languages.java.ast.DoWhileStatement;
+import com.strobel.decompiler.languages.java.ast.EmptyStatement;
+import com.strobel.decompiler.languages.java.ast.EnumValueDeclaration;
+import com.strobel.decompiler.languages.java.ast.ExpressionStatement;
+import com.strobel.decompiler.languages.java.ast.FieldDeclaration;
+import com.strobel.decompiler.languages.java.ast.ForEachStatement;
+import com.strobel.decompiler.languages.java.ast.ForStatement;
+import com.strobel.decompiler.languages.java.ast.GotoStatement;
+import com.strobel.decompiler.languages.java.ast.IAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.IdentifierExpression;
+import com.strobel.decompiler.languages.java.ast.IfElseStatement;
+import com.strobel.decompiler.languages.java.ast.ImportDeclaration;
+import com.strobel.decompiler.languages.java.ast.IndexerExpression;
+import com.strobel.decompiler.languages.java.ast.InstanceInitializer;
+import com.strobel.decompiler.languages.java.ast.InstanceOfExpression;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.JavaTokenNode;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.LabelStatement;
+import com.strobel.decompiler.languages.java.ast.LabeledStatement;
+import com.strobel.decompiler.languages.java.ast.LambdaExpression;
+import com.strobel.decompiler.languages.java.ast.LocalTypeDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.MethodGroupExpression;
+import com.strobel.decompiler.languages.java.ast.NewLineNode;
+import com.strobel.decompiler.languages.java.ast.NullReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.PackageDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParenthesizedExpression;
+import com.strobel.decompiler.languages.java.ast.PrimitiveExpression;
+import com.strobel.decompiler.languages.java.ast.ReturnStatement;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.SuperReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.SwitchSection;
+import com.strobel.decompiler.languages.java.ast.SwitchStatement;
+import com.strobel.decompiler.languages.java.ast.SynchronizedStatement;
+import com.strobel.decompiler.languages.java.ast.TextNode;
+import com.strobel.decompiler.languages.java.ast.ThisReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ThrowStatement;
+import com.strobel.decompiler.languages.java.ast.TryCatchStatement;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.UnaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.VariableDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.VariableInitializer;
+import com.strobel.decompiler.languages.java.ast.WhileStatement;
+import com.strobel.decompiler.languages.java.ast.WildcardType;
+import com.strobel.decompiler.patterns.Pattern;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class SourceIndexVisitor implements IAstVisitor<SourceIndex,Void> {
+        
+        @Override
+        public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) {
+                TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getInternalName());
+                index.addDeclaration(node.getNameToken(), classEntry);
+                
+                return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
+        }
+        
+        protected Void recurse(AstNode node, SourceIndex index) {
+                for (final AstNode child : node.getChildren()) {
+                        child.acceptVisitor(this, index);
+                }
+                return null;
+        }
+        
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitFieldDeclaration(FieldDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitEnumValueDeclaration(EnumValueDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitParameterDeclaration(ParameterDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitInvocationExpression(InvocationExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitMemberReferenceExpression(MemberReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSimpleType(SimpleType node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIdentifierExpression(IdentifierExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitComment(Comment node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitPatternPlaceholder(AstNode node, Pattern pattern, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitTypeReference(TypeReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitJavaTokenNode(JavaTokenNode node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIdentifier(Identifier node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitNullReferenceExpression(NullReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitThisReferenceExpression(ThisReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSuperReferenceExpression(SuperReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitClassOfExpression(ClassOfExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitBlockStatement(BlockStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitExpressionStatement(ExpressionStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitBreakStatement(BreakStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitContinueStatement(ContinueStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitDoWhileStatement(DoWhileStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitEmptyStatement(EmptyStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIfElseStatement(IfElseStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitLabelStatement(LabelStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitLabeledStatement(LabeledStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitReturnStatement(ReturnStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSwitchStatement(SwitchStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSwitchSection(SwitchSection node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitCaseLabel(CaseLabel node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitThrowStatement(ThrowStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitCatchClause(CatchClause node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitAnnotation(Annotation node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitNewLine(NewLineNode node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitVariableDeclaration(VariableDeclarationStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitVariableInitializer(VariableInitializer node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitText(TextNode node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitImportDeclaration(ImportDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitInitializerBlock(InstanceInitializer node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitTypeParameterDeclaration(TypeParameterDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitCompilationUnit(CompilationUnit node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitPackageDeclaration(PackageDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitArraySpecifier(ArraySpecifier node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitComposedType(ComposedType node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitWhileStatement(WhileStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitPrimitiveExpression(PrimitiveExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitCastExpression(CastExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitBinaryOperatorExpression(BinaryOperatorExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitInstanceOfExpression(InstanceOfExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIndexerExpression(IndexerExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitUnaryOperatorExpression(UnaryOperatorExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitConditionalExpression(ConditionalExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitArrayInitializerExpression(ArrayInitializerExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitObjectCreationExpression(ObjectCreationExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitArrayCreationExpression(ArrayCreationExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitAssignmentExpression(AssignmentExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitForStatement(ForStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitForEachStatement(ForEachStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitTryCatchStatement(TryCatchStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitGotoStatement(GotoStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitParenthesizedExpression(ParenthesizedExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSynchronizedStatement(SynchronizedStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitAnonymousObjectCreationExpression(AnonymousObjectCreationExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitWildcardType(WildcardType node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitMethodGroupExpression(MethodGroupExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitAssertStatement(AssertStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitLambdaExpression(LambdaExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitLocalTypeDeclarationStatement(LocalTypeDeclarationStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/Token.java b/src/cuchaz/enigma/analysis/Token.java
new file mode 100644
index 00000000..481d2f47
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/Token.java
@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+public class Token implements Comparable<Token> {
+        
+        public int start;
+        public int end;
+        public String text;
+        
+        public Token(int start, int end) {
+                this(start, end, null);
+        }
+        
+        public Token(int start, int end, String source) {
+                this.start = start;
+                this.end = end;
+                if (source != null) {
+                        this.text = source.substring(start, end);
+                }
+        }
+        
+        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) {
+                if (other instanceof Token) {
+                        return equals((Token)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(Token other) {
+                return start == other.start && end == other.end;
+        }
+        
+        @Override
+        public String toString() {
+                return String.format("[%d,%d]", start, end);
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/TranslationIndex.java b/src/cuchaz/enigma/analysis/TranslationIndex.java
new file mode 100644
index 00000000..7597c3ae
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/TranslationIndex.java
@@ -0,0 +1,227 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtField;
+
+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.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.Translator;
+
+public class TranslationIndex implements Serializable {
+        
+        private static final long serialVersionUID = 738687982126844179L;
+        
+        private Map<ClassEntry,ClassEntry> m_superclasses;
+        private Multimap<ClassEntry,FieldEntry> m_fieldEntries;
+        private Multimap<ClassEntry,BehaviorEntry> m_behaviorEntries;
+        
+        public TranslationIndex() {
+                m_superclasses = Maps.newHashMap();
+                m_fieldEntries = HashMultimap.create();
+                m_behaviorEntries = HashMultimap.create();
+        }
+        
+        public TranslationIndex(TranslationIndex other, Translator translator) {
+                
+                // translate the superclasses
+                m_superclasses = Maps.newHashMap();
+                for (Map.Entry<ClassEntry,ClassEntry> mapEntry : other.m_superclasses.entrySet()) {
+                        m_superclasses.put(
+                                translator.translateEntry(mapEntry.getKey()),
+                                translator.translateEntry(mapEntry.getValue())
+                        );
+                }
+                
+                // translate the fields
+                m_fieldEntries = HashMultimap.create();
+                for (Map.Entry<ClassEntry,FieldEntry> mapEntry : other.m_fieldEntries.entries()) {
+                        m_fieldEntries.put(
+                                translator.translateEntry(mapEntry.getKey()),
+                                translator.translateEntry(mapEntry.getValue())
+                        );
+                }
+                
+                m_behaviorEntries = HashMultimap.create();
+                for (Map.Entry<ClassEntry,BehaviorEntry> mapEntry : other.m_behaviorEntries.entries()) {
+                        m_behaviorEntries.put(
+                                translator.translateEntry(mapEntry.getKey()),
+                                translator.translateEntry(mapEntry.getValue())
+                        );
+                }
+        }
+        
+        public void indexClass(CtClass c) {
+                
+                ClassEntry classEntry = JavassistUtil.getClassEntry(c);
+                
+                // add the superclass
+                ClassEntry superclassEntry = JavassistUtil.getSuperclassEntry(c);
+                if (!isJre(classEntry) && superclassEntry != null && !isJre(superclassEntry)) {
+                        m_superclasses.put(classEntry, superclassEntry);
+                }
+                
+                // add fields
+                for (CtField field : c.getDeclaredFields()) {
+                        FieldEntry fieldEntry = JavassistUtil.getFieldEntry(field);
+                        m_fieldEntries.put(fieldEntry.getClassEntry(), fieldEntry);
+                }
+                
+                // add behaviors
+                for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                        BehaviorEntry behaviorEntry = JavassistUtil.getBehaviorEntry(behavior);
+                        m_behaviorEntries.put(behaviorEntry.getClassEntry(), behaviorEntry);
+                }
+        }
+        
+        public void renameClasses(Map<String,String> renames) {
+                EntryRenamer.renameClassesInMap(renames, m_superclasses);
+                EntryRenamer.renameClassesInMultimap(renames, m_fieldEntries);
+                EntryRenamer.renameClassesInMultimap(renames, m_behaviorEntries);
+        }
+        
+        public ClassEntry getSuperclass(ClassEntry classEntry) {
+                return m_superclasses.get(classEntry);
+        }
+        
+        public List<ClassEntry> getAncestry(ClassEntry classEntry) {
+                List<ClassEntry> ancestors = Lists.newArrayList();
+                while (classEntry != null) {
+                        classEntry = getSuperclass(classEntry);
+                        if (classEntry != null) {
+                                ancestors.add(classEntry);
+                        }
+                }
+                return ancestors;
+        }
+        
+        public List<ClassEntry> getSubclass(ClassEntry classEntry) {
+                // linear search is fast enough for now
+                List<ClassEntry> subclasses = Lists.newArrayList();
+                for (Map.Entry<ClassEntry,ClassEntry> entry : m_superclasses.entrySet()) {
+                        ClassEntry subclass = entry.getKey();
+                        ClassEntry superclass = entry.getValue();
+                        if (classEntry.equals(superclass)) {
+                                subclasses.add(subclass);
+                        }
+                }
+                return subclasses;
+        }
+        
+        public void getSubclassesRecursively(Set<ClassEntry> out, ClassEntry classEntry) {
+                for (ClassEntry subclassEntry : getSubclass(classEntry)) {
+                        out.add(subclassEntry);
+                        getSubclassesRecursively(out, subclassEntry);
+                }
+        }
+        
+        public void getSubclassNamesRecursively(Set<String> out, ClassEntry classEntry) {
+                for (ClassEntry subclassEntry : getSubclass(classEntry)) {
+                        out.add(subclassEntry.getName());
+                        getSubclassNamesRecursively(out, subclassEntry);
+                }
+        }
+        
+        public boolean entryExists(Entry entry) {
+                if (entry instanceof FieldEntry) {
+                        return fieldExists((FieldEntry)entry);
+                } else if (entry instanceof BehaviorEntry) {
+                        return behaviorExists((BehaviorEntry)entry);
+                } else if (entry instanceof ArgumentEntry) {
+                        return behaviorExists(((ArgumentEntry)entry).getBehaviorEntry());
+                }
+                throw new IllegalArgumentException("Cannot check existence for " + entry.getClass());
+        }
+        
+        public boolean fieldExists(FieldEntry fieldEntry) {
+                return m_fieldEntries.containsEntry(fieldEntry.getClassEntry(), fieldEntry);
+        }
+        
+        public boolean behaviorExists(BehaviorEntry behaviorEntry) {
+                return m_behaviorEntries.containsEntry(behaviorEntry.getClassEntry(), behaviorEntry);
+        }
+        
+        public ClassEntry resolveEntryClass(Entry entry) {
+                
+                if (entry instanceof ClassEntry) {
+                        return (ClassEntry)entry;
+                }
+                
+                // this entry could refer to a method on a class where the method is not actually implemented
+                // travel up the inheritance tree to find the closest implementation
+                while (!entryExists(entry)) {
+                        
+                        // is there a parent class?
+                        ClassEntry superclassEntry = getSuperclass(entry.getClassEntry());
+                        if (superclassEntry == null) {
+                                // this is probably a method from a class in a library
+                                // we can't trace the implementation up any higher unless we index the library
+                                return null;
+                        }
+                        
+                        // move up to the parent class
+                        entry = entry.cloneToNewClass(superclassEntry);
+                }
+                return entry.getClassEntry();
+        }
+        
+        private boolean isJre(ClassEntry classEntry) {
+                String packageName = classEntry.getPackageName();
+                return packageName != null && (packageName.startsWith("java") || packageName.startsWith("javax"));
+        }
+        
+        public void write(OutputStream out)
+        throws IOException {
+                GZIPOutputStream gzipout = new GZIPOutputStream(out);
+                ObjectOutputStream oout = new ObjectOutputStream(gzipout);
+                oout.writeObject(m_superclasses);
+                oout.writeObject(m_fieldEntries);
+                oout.writeObject(m_behaviorEntries);
+                gzipout.finish();
+        }
+        
+        @SuppressWarnings("unchecked")
+        public void read(InputStream in)
+        throws IOException {
+                try {
+                        ObjectInputStream oin = new ObjectInputStream(new GZIPInputStream(in));
+                        m_superclasses = (HashMap<ClassEntry,ClassEntry>)oin.readObject();
+                        m_fieldEntries = (HashMultimap<ClassEntry,FieldEntry>)oin.readObject();
+                        m_behaviorEntries = (HashMultimap<ClassEntry,BehaviorEntry>)oin.readObject();
+                } catch (ClassNotFoundException ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java
new file mode 100644
index 00000000..23f80899
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java
@@ -0,0 +1,512 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+
+import com.strobel.componentmodel.Key;
+import com.strobel.decompiler.languages.java.ast.Annotation;
+import com.strobel.decompiler.languages.java.ast.AnonymousObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayInitializerExpression;
+import com.strobel.decompiler.languages.java.ast.ArraySpecifier;
+import com.strobel.decompiler.languages.java.ast.AssertStatement;
+import com.strobel.decompiler.languages.java.ast.AssignmentExpression;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.BinaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.BlockStatement;
+import com.strobel.decompiler.languages.java.ast.BreakStatement;
+import com.strobel.decompiler.languages.java.ast.CaseLabel;
+import com.strobel.decompiler.languages.java.ast.CastExpression;
+import com.strobel.decompiler.languages.java.ast.CatchClause;
+import com.strobel.decompiler.languages.java.ast.ClassOfExpression;
+import com.strobel.decompiler.languages.java.ast.Comment;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+import com.strobel.decompiler.languages.java.ast.ComposedType;
+import com.strobel.decompiler.languages.java.ast.ConditionalExpression;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.ContinueStatement;
+import com.strobel.decompiler.languages.java.ast.DoWhileStatement;
+import com.strobel.decompiler.languages.java.ast.EmptyStatement;
+import com.strobel.decompiler.languages.java.ast.EnumValueDeclaration;
+import com.strobel.decompiler.languages.java.ast.ExpressionStatement;
+import com.strobel.decompiler.languages.java.ast.FieldDeclaration;
+import com.strobel.decompiler.languages.java.ast.ForEachStatement;
+import com.strobel.decompiler.languages.java.ast.ForStatement;
+import com.strobel.decompiler.languages.java.ast.GotoStatement;
+import com.strobel.decompiler.languages.java.ast.IAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.IdentifierExpression;
+import com.strobel.decompiler.languages.java.ast.IfElseStatement;
+import com.strobel.decompiler.languages.java.ast.ImportDeclaration;
+import com.strobel.decompiler.languages.java.ast.IndexerExpression;
+import com.strobel.decompiler.languages.java.ast.InstanceInitializer;
+import com.strobel.decompiler.languages.java.ast.InstanceOfExpression;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.JavaTokenNode;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.LabelStatement;
+import com.strobel.decompiler.languages.java.ast.LabeledStatement;
+import com.strobel.decompiler.languages.java.ast.LambdaExpression;
+import com.strobel.decompiler.languages.java.ast.LocalTypeDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.MethodGroupExpression;
+import com.strobel.decompiler.languages.java.ast.NewLineNode;
+import com.strobel.decompiler.languages.java.ast.NullReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.PackageDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParenthesizedExpression;
+import com.strobel.decompiler.languages.java.ast.PrimitiveExpression;
+import com.strobel.decompiler.languages.java.ast.ReturnStatement;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.SuperReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.SwitchSection;
+import com.strobel.decompiler.languages.java.ast.SwitchStatement;
+import com.strobel.decompiler.languages.java.ast.SynchronizedStatement;
+import com.strobel.decompiler.languages.java.ast.TextNode;
+import com.strobel.decompiler.languages.java.ast.ThisReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ThrowStatement;
+import com.strobel.decompiler.languages.java.ast.TryCatchStatement;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.UnaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.VariableDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.VariableInitializer;
+import com.strobel.decompiler.languages.java.ast.WhileStatement;
+import com.strobel.decompiler.languages.java.ast.WildcardType;
+import com.strobel.decompiler.patterns.Pattern;
+
+public class TreeDumpVisitor implements IAstVisitor<Void,Void> {
+        
+        private File m_file;
+        private Writer m_out;
+        
+        public TreeDumpVisitor(File file) {
+                m_file = file;
+                m_out = null;
+        }
+        
+        @Override
+        public Void visitCompilationUnit(CompilationUnit node, Void ignored) {
+                try {
+                        m_out = new FileWriter(m_file);
+                        recurse(node, ignored);
+                        m_out.close();
+                        return null;
+                } catch (IOException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private Void recurse(AstNode node, Void ignored) {
+                // show the tree
+                try {
+                        m_out.write(getIndent(node) + node.getClass().getSimpleName() + " " + getText(node) + " " + dumpUserData(node) + " " + node.getRegion() + "\n");
+                } catch (IOException ex) {
+                        throw new Error(ex);
+                }
+                
+                // recurse
+                for (final AstNode child : node.getChildren()) {
+                        child.acceptVisitor(this, ignored);
+                }
+                return null;
+        }
+        
+        private String getText(AstNode node) {
+                if (node instanceof Identifier) {
+                        return "\"" + ((Identifier)node).getName() + "\"";
+                }
+                return "";
+        }
+        
+        private String dumpUserData(AstNode node) {
+                StringBuilder buf = new StringBuilder();
+                for (Key<?> key : Keys.ALL_KEYS) {
+                        Object val = node.getUserData(key);
+                        if (val != null) {
+                                buf.append(String.format(" [%s=%s]", key, val));
+                        }
+                }
+                return buf.toString();
+        }
+        
+        private String getIndent(AstNode node) {
+                StringBuilder buf = new StringBuilder();
+                int depth = getDepth(node);
+                for (int i = 0; i < depth; i++) {
+                        buf.append("\t");
+                }
+                return buf.toString();
+        }
+        
+        private int getDepth(AstNode node) {
+                int depth = -1;
+                while (node != null) {
+                        depth++;
+                        node = node.getParent();
+                }
+                return depth;
+        }
+        
+        // OVERRIDES WE DON'T CARE ABOUT
+        
+        @Override
+        public Void visitInvocationExpression(InvocationExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitMemberReferenceExpression(MemberReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSimpleType(SimpleType node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitParameterDeclaration(ParameterDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitFieldDeclaration(FieldDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitTypeDeclaration(TypeDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitComment(Comment node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitPatternPlaceholder(AstNode node, Pattern pattern, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitTypeReference(TypeReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitJavaTokenNode(JavaTokenNode node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitIdentifier(Identifier node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitNullReferenceExpression(NullReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitThisReferenceExpression(ThisReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSuperReferenceExpression(SuperReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitClassOfExpression(ClassOfExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitBlockStatement(BlockStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitExpressionStatement(ExpressionStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitBreakStatement(BreakStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitContinueStatement(ContinueStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitDoWhileStatement(DoWhileStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitEmptyStatement(EmptyStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitIfElseStatement(IfElseStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitLabelStatement(LabelStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitLabeledStatement(LabeledStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitReturnStatement(ReturnStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSwitchStatement(SwitchStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSwitchSection(SwitchSection node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitCaseLabel(CaseLabel node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitThrowStatement(ThrowStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitCatchClause(CatchClause node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitAnnotation(Annotation node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitNewLine(NewLineNode node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitVariableDeclaration(VariableDeclarationStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitVariableInitializer(VariableInitializer node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitText(TextNode node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitImportDeclaration(ImportDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitInitializerBlock(InstanceInitializer node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitTypeParameterDeclaration(TypeParameterDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitPackageDeclaration(PackageDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitArraySpecifier(ArraySpecifier node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitComposedType(ComposedType node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitWhileStatement(WhileStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitPrimitiveExpression(PrimitiveExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitCastExpression(CastExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitBinaryOperatorExpression(BinaryOperatorExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitInstanceOfExpression(InstanceOfExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitIndexerExpression(IndexerExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitIdentifierExpression(IdentifierExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitUnaryOperatorExpression(UnaryOperatorExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitConditionalExpression(ConditionalExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitArrayInitializerExpression(ArrayInitializerExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitObjectCreationExpression(ObjectCreationExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitArrayCreationExpression(ArrayCreationExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitAssignmentExpression(AssignmentExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitForStatement(ForStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitForEachStatement(ForEachStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitTryCatchStatement(TryCatchStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitGotoStatement(GotoStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitParenthesizedExpression(ParenthesizedExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSynchronizedStatement(SynchronizedStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitAnonymousObjectCreationExpression(AnonymousObjectCreationExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitWildcardType(WildcardType node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitMethodGroupExpression(MethodGroupExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitEnumValueDeclaration(EnumValueDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitAssertStatement(AssertStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitLambdaExpression(LambdaExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitLocalTypeDeclarationStatement(LocalTypeDeclarationStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/CheckCastIterator.java b/src/cuchaz/enigma/bytecode/CheckCastIterator.java
new file mode 100644
index 00000000..52845573
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/CheckCastIterator.java
@@ -0,0 +1,127 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Iterator;
+
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.Opcode;
+import cuchaz.enigma.bytecode.CheckCastIterator.CheckCast;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class CheckCastIterator implements Iterator<CheckCast> {
+        
+        public static class CheckCast {
+                
+                public String className;
+                public MethodEntry prevMethodEntry;
+                
+                public CheckCast(String className, MethodEntry prevMethodEntry) {
+                        this.className = className;
+                        this.prevMethodEntry = prevMethodEntry;
+                }
+        }
+        
+        private ConstPool m_constants;
+        private CodeAttribute m_attribute;
+        private CodeIterator m_iter;
+        private CheckCast m_next;
+        
+        public CheckCastIterator(CodeAttribute codeAttribute) throws BadBytecode {
+                m_constants = codeAttribute.getConstPool();
+                m_attribute = codeAttribute;
+                m_iter = m_attribute.iterator();
+                
+                m_next = getNext();
+        }
+        
+        @Override
+        public boolean hasNext() {
+                return m_next != null;
+        }
+        
+        @Override
+        public CheckCast next() {
+                CheckCast out = m_next;
+                try {
+                        m_next = getNext();
+                } catch (BadBytecode ex) {
+                        throw new Error(ex);
+                }
+                return out;
+        }
+        
+        @Override
+        public void remove() {
+                throw new UnsupportedOperationException();
+        }
+        
+        private CheckCast getNext() throws BadBytecode {
+                int prevPos = 0;
+                while (m_iter.hasNext()) {
+                        int pos = m_iter.next();
+                        int opcode = m_iter.byteAt(pos);
+                        switch (opcode) {
+                                case Opcode.CHECKCAST:
+                                        
+                                        // get the type of this op code (next two bytes are a classinfo index)
+                                        MethodEntry prevMethodEntry = getMethodEntry(prevPos);
+                                        if (prevMethodEntry != null) {
+                                                return new CheckCast(m_constants.getClassInfo(m_iter.s16bitAt(pos + 1)), prevMethodEntry);
+                                        }
+                                break;
+                        }
+                        prevPos = pos;
+                }
+                return null;
+        }
+        
+        private MethodEntry getMethodEntry(int pos) {
+                switch (m_iter.byteAt(pos)) {
+                        case Opcode.INVOKEVIRTUAL:
+                        case Opcode.INVOKESTATIC:
+                        case Opcode.INVOKEDYNAMIC:
+                        case Opcode.INVOKESPECIAL: {
+                                int index = m_iter.s16bitAt(pos + 1);
+                                return new MethodEntry(
+                                        new ClassEntry(Descriptor.toJvmName(m_constants.getMethodrefClassName(index))),
+                                        m_constants.getMethodrefName(index),
+                                        new Signature(m_constants.getMethodrefType(index))
+                                );
+                        }
+                        
+                        case Opcode.INVOKEINTERFACE: {
+                                int index = m_iter.s16bitAt(pos + 1);
+                                return new MethodEntry(
+                                        new ClassEntry(Descriptor.toJvmName(m_constants.getInterfaceMethodrefClassName(index))),
+                                        m_constants.getInterfaceMethodrefName(index),
+                                        new Signature(m_constants.getInterfaceMethodrefType(index))
+                                );
+                        }
+                }
+                return null;
+        }
+        
+        public Iterable<CheckCast> casts() {
+                return new Iterable<CheckCast>() {
+                        @Override
+                        public Iterator<CheckCast> iterator() {
+                                return CheckCastIterator.this;
+                        }
+                };
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/ClassRenamer.java b/src/cuchaz/enigma/bytecode/ClassRenamer.java
new file mode 100644
index 00000000..a5fea926
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/ClassRenamer.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Map;
+import java.util.Set;
+
+import javassist.ClassMap;
+import javassist.CtClass;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.InnerClassesAttribute;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class ClassRenamer {
+        
+        public static void renameClasses(CtClass c, Map<ClassEntry,ClassEntry> map) {
+                
+                // build the map used by javassist
+                ClassMap nameMap = new ClassMap();
+                for (Map.Entry<ClassEntry,ClassEntry> entry : map.entrySet()) {
+                        nameMap.put(entry.getKey().getName(), entry.getValue().getName());
+                }
+                
+                c.replaceClassName(nameMap);
+                
+                // replace simple names in the InnerClasses attribute too
+                ConstPool constants = c.getClassFile().getConstPool();
+                InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag);
+                if (attr != null) {
+                        for (int i = 0; i < attr.tableLength(); i++) {
+                                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i)));
+                                if (attr.innerNameIndex(i) != 0) {
+                                        attr.setInnerNameIndex(i, constants.addUtf8Info(classEntry.getInnerClassName()));
+                                }
+                                
+                                /* DEBUG
+                                System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i)));
+                                */
+                        }
+                }
+        }
+        
+        public static Set<ClassEntry> getAllClassEntries(final CtClass c) {
+                
+                // get the classes that javassist knows about
+                final Set<ClassEntry> entries = Sets.newHashSet();
+                ClassMap map = new ClassMap() {
+                        @Override
+                        public Object get(Object obj) {
+                                if (obj instanceof String) {
+                                        String str = (String)obj;
+                                        
+                                        // javassist throws a lot of weird things at this map
+                                        // I either have to implement my on class scanner, or just try to filter out the weirdness
+                                        // I'm opting to filter out the weirdness for now
+                                        
+                                        // skip anything with generic arguments
+                                        if (str.indexOf('<') >= 0 || str.indexOf('>') >= 0 || str.indexOf(';') >= 0) {
+                                                return null;
+                                        }
+                                        
+                                        // convert path/to/class.inner to path/to/class$inner
+                                        str = str.replace('.', '$');
+                                        
+                                        // remember everything else
+                                        entries.add(new ClassEntry(str));
+                                }
+                                return null;
+                        }
+                        
+                        private static final long serialVersionUID = -202160293602070641L;
+                };
+                c.replaceClassName(map);
+                
+                return entries;
+        }
+        
+        public static void moveAllClassesOutOfDefaultPackage(CtClass c, String newPackageName) {
+                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
+                for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) {
+                        if (classEntry.isInDefaultPackage()) {
+                                map.put(classEntry, new ClassEntry(newPackageName + "/" + classEntry.getName()));
+                        }
+                }
+                ClassRenamer.renameClasses(c, map);
+        }
+        
+        public static void moveAllClassesIntoDefaultPackage(CtClass c, String oldPackageName) {
+                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
+                for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) {
+                        if (classEntry.getPackageName().equals(oldPackageName)) {
+                                map.put(classEntry, new ClassEntry(classEntry.getSimpleName()));
+                        }
+                }
+                ClassRenamer.renameClasses(c, map);
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/ClassTranslator.java b/src/cuchaz/enigma/bytecode/ClassTranslator.java
new file mode 100644
index 00000000..afd3a777
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -0,0 +1,144 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Map;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.SourceFileAttribute;
+
+import com.google.common.collect.Maps;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+import cuchaz.enigma.mapping.Translator;
+import cuchaz.enigma.mapping.Type;
+
+public class ClassTranslator {
+        
+        private Translator m_translator;
+        
+        public ClassTranslator(Translator translator) {
+                m_translator = translator;
+        }
+        
+        public void translate(CtClass c) {
+                
+                // NOTE: the order of these translations is very important
+                
+                // translate all the field and method references in the code by editing the constant pool
+                ConstPool constants = c.getClassFile().getConstPool();
+                ConstPoolEditor editor = new ConstPoolEditor(constants);
+                for (int i = 1; i < constants.getSize(); i++) {
+                        switch (constants.getTag(i)) {
+                                
+                                case ConstPool.CONST_Fieldref: {
+                                        
+                                        // translate the name
+                                        FieldEntry entry = new FieldEntry(
+                                                new ClassEntry(Descriptor.toJvmName(constants.getFieldrefClassName(i))),
+                                                constants.getFieldrefName(i)
+                                        );
+                                        FieldEntry translatedEntry = m_translator.translateEntry(entry);
+                                        
+                                        // translate the type
+                                        Type type = new Type(constants.getFieldrefType(i));
+                                        Type translatedType = m_translator.translateType(type);
+                                        
+                                        if (!entry.equals(translatedEntry) || !type.equals(translatedType)) {
+                                                editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedType.toString());
+                                        }
+                                }
+                                break;
+                                
+                                case ConstPool.CONST_Methodref:
+                                case ConstPool.CONST_InterfaceMethodref: {
+                                        
+                                        // translate the name and type
+                                        BehaviorEntry entry = BehaviorEntryFactory.create(
+                                                Descriptor.toJvmName(editor.getMemberrefClassname(i)),
+                                                editor.getMemberrefName(i),
+                                                editor.getMemberrefType(i)
+                                        );
+                                        BehaviorEntry translatedEntry = m_translator.translateEntry(entry);
+                                        
+                                        if (!entry.getName().equals(translatedEntry.getName()) || !entry.getSignature().equals(translatedEntry.getSignature())) {
+                                                editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getSignature().toString());
+                                        }
+                                }
+                                break;
+                        }
+                }
+                
+                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                
+                // translate all the fields
+                for (CtField field : c.getDeclaredFields()) {
+                        
+                        // translate the name
+                        FieldEntry entry = new FieldEntry(classEntry, field.getName());
+                        String translatedName = m_translator.translate(entry);
+                        if (translatedName != null) {
+                                field.setName(translatedName);
+                        }
+                        
+                        // translate the type
+                        Type translatedType = m_translator.translateType(new Type(field.getFieldInfo().getDescriptor()));
+                        field.getFieldInfo().setDescriptor(translatedType.toString());
+                }
+                
+                // translate all the methods and constructors
+                for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                        if (behavior instanceof CtMethod) {
+                                CtMethod method = (CtMethod)behavior;
+                                
+                                // translate the name
+                                MethodEntry entry = JavassistUtil.getMethodEntry(method);
+                                String translatedName = m_translator.translate(entry);
+                                if (translatedName != null) {
+                                        method.setName(translatedName);
+                                }
+                        }
+                        
+                        // translate the type
+                        Signature translatedSignature = m_translator.translateSignature(new Signature(behavior.getMethodInfo().getDescriptor()));
+                        behavior.getMethodInfo().setDescriptor(translatedSignature.toString());
+                }
+                
+                // translate all the class names referenced in the code
+                // the above code only changed method/field/reference names and types, but not the class names themselves
+                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
+                for (ClassEntry obfClassEntry : ClassRenamer.getAllClassEntries(c)) {
+                        ClassEntry deobfClassEntry = m_translator.translateEntry(obfClassEntry);
+                        if (!obfClassEntry.equals(deobfClassEntry)) {
+                                map.put(obfClassEntry, deobfClassEntry);
+                        }
+                }
+                ClassRenamer.renameClasses(c, map);
+                
+                // translate the source file attribute too
+                ClassEntry deobfClassEntry = map.get(classEntry);
+                if (deobfClassEntry != null) {
+                        String sourceFile = Descriptor.toJvmName(deobfClassEntry.getOuterClassName()) + ".java";
+                        c.getClassFile().addAttribute(new SourceFileAttribute(constants, sourceFile));
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/ConstPoolEditor.java b/src/cuchaz/enigma/bytecode/ConstPoolEditor.java
new file mode 100644
index 00000000..2dec3b76
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/ConstPoolEditor.java
@@ -0,0 +1,263 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import cuchaz.enigma.bytecode.accessors.ClassInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MemberRefInfoAccessor;
+
+public class ConstPoolEditor {
+        
+        private static Method m_getItem;
+        private static Method m_addItem;
+        private static Method m_addItem0;
+        private static Field m_items;
+        private static Field m_cache;
+        private static Field m_numItems;
+        private static Field m_objects;
+        private static Field m_elements;
+        private static Method m_methodWritePool;
+        private static Constructor<ConstPool> m_constructorPool;
+        
+        static {
+                try {
+                        m_getItem = ConstPool.class.getDeclaredMethod("getItem", int.class);
+                        m_getItem.setAccessible(true);
+                        
+                        m_addItem = ConstPool.class.getDeclaredMethod("addItem", Class.forName("javassist.bytecode.ConstInfo"));
+                        m_addItem.setAccessible(true);
+                        
+                        m_addItem0 = ConstPool.class.getDeclaredMethod("addItem0", Class.forName("javassist.bytecode.ConstInfo"));
+                        m_addItem0.setAccessible(true);
+                        
+                        m_items = ConstPool.class.getDeclaredField("items");
+                        m_items.setAccessible(true);
+                        
+                        m_cache = ConstPool.class.getDeclaredField("itemsCache");
+                        m_cache.setAccessible(true);
+                        
+                        m_numItems = ConstPool.class.getDeclaredField("numOfItems");
+                        m_numItems.setAccessible(true);
+                        
+                        m_objects = Class.forName("javassist.bytecode.LongVector").getDeclaredField("objects");
+                        m_objects.setAccessible(true);
+                        
+                        m_elements = Class.forName("javassist.bytecode.LongVector").getDeclaredField("elements");
+                        m_elements.setAccessible(true);
+                        
+                        m_methodWritePool = ConstPool.class.getDeclaredMethod("write", DataOutputStream.class);
+                        m_methodWritePool.setAccessible(true);
+                        
+                        m_constructorPool = ConstPool.class.getDeclaredConstructor(DataInputStream.class);
+                        m_constructorPool.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private ConstPool m_pool;
+        
+        public ConstPoolEditor(ConstPool pool) {
+                m_pool = pool;
+        }
+        
+        public void writePool(DataOutputStream out) {
+                try {
+                        m_methodWritePool.invoke(m_pool, out);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static ConstPool readPool(DataInputStream in) {
+                try {
+                        return m_constructorPool.newInstance(in);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public String getMemberrefClassname(int memberrefIndex) {
+                return Descriptor.toJvmName(m_pool.getClassInfo(m_pool.getMemberClass(memberrefIndex)));
+        }
+        
+        public String getMemberrefName(int memberrefIndex) {
+                return m_pool.getUtf8Info(m_pool.getNameAndTypeName(m_pool.getMemberNameAndType(memberrefIndex)));
+        }
+        
+        public String getMemberrefType(int memberrefIndex) {
+                return m_pool.getUtf8Info(m_pool.getNameAndTypeDescriptor(m_pool.getMemberNameAndType(memberrefIndex)));
+        }
+        
+        public ConstInfoAccessor getItem(int index) {
+                try {
+                        Object entry = m_getItem.invoke(m_pool, index);
+                        if (entry == null) {
+                                return null;
+                        }
+                        return new ConstInfoAccessor(entry);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int addItem(Object item) {
+                try {
+                        return (Integer)m_addItem.invoke(m_pool, item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int addItemForceNew(Object item) {
+                try {
+                        return (Integer)m_addItem0.invoke(m_pool, item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        @SuppressWarnings("rawtypes")
+        public void removeLastItem() {
+                try {
+                        // remove the item from the cache
+                        HashMap cache = getCache();
+                        if (cache != null) {
+                                Object item = getItem(m_pool.getSize() - 1);
+                                cache.remove(item);
+                        }
+                        
+                        // remove the actual item
+                        // based off of LongVector.addElement()
+                        Object items = m_items.get(m_pool);
+                        Object[][] objects = (Object[][])m_objects.get(items);
+                        int numElements = (Integer)m_elements.get(items) - 1;
+                        int nth = numElements >> 7;
+                        int offset = numElements & (128 - 1);
+                        objects[nth][offset] = null;
+                        
+                        // decrement the number of items
+                        m_elements.set(items, numElements);
+                        m_numItems.set(m_pool, (Integer)m_numItems.get(m_pool) - 1);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        @SuppressWarnings("rawtypes")
+        public HashMap getCache() {
+                try {
+                        return (HashMap)m_cache.get(m_pool);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        public void changeMemberrefNameAndType(int memberrefIndex, String newName, String newType) {
+                // NOTE: when changing values, we always need to copy-on-write
+                try {
+                        // get the memberref item
+                        Object item = getItem(memberrefIndex).getItem();
+                        
+                        // update the cache
+                        HashMap cache = getCache();
+                        if (cache != null) {
+                                cache.remove(item);
+                        }
+                        
+                        new MemberRefInfoAccessor(item).setNameAndTypeIndex(m_pool.addNameAndTypeInfo(newName, newType));
+                        
+                        // update the cache
+                        if (cache != null) {
+                                cache.put(item, item);
+                        }
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+                
+                // make sure the change worked
+                assert (newName.equals(getMemberrefName(memberrefIndex)));
+                assert (newType.equals(getMemberrefType(memberrefIndex)));
+        }
+        
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        public void changeClassName(int classNameIndex, String newName) {
+                // NOTE: when changing values, we always need to copy-on-write
+                try {
+                        // get the class item
+                        Object item = getItem(classNameIndex).getItem();
+                        
+                        // update the cache
+                        HashMap cache = getCache();
+                        if (cache != null) {
+                                cache.remove(item);
+                        }
+                        
+                        // add the new name and repoint the name-and-type to it
+                        new ClassInfoAccessor(item).setNameIndex(m_pool.addUtf8Info(newName));
+                        
+                        // update the cache
+                        if (cache != null) {
+                                cache.put(item, item);
+                        }
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static ConstPool newConstPool() {
+                // const pool expects the name of a class to initialize itself
+                // but we want an empty pool
+                // so give it a bogus name, and then clear the entries afterwards
+                ConstPool pool = new ConstPool("a");
+                
+                ConstPoolEditor editor = new ConstPoolEditor(pool);
+                int size = pool.getSize();
+                for (int i = 0; i < size - 1; i++) {
+                        editor.removeLastItem();
+                }
+                
+                // make sure the pool is actually empty
+                // although, in this case "empty" means one thing in it
+                // the JVM spec says index 0 should be reserved
+                assert (pool.getSize() == 1);
+                assert (editor.getItem(0) == null);
+                assert (editor.getItem(1) == null);
+                assert (editor.getItem(2) == null);
+                assert (editor.getItem(3) == null);
+                
+                // also, clear the cache
+                editor.getCache().clear();
+                
+                return pool;
+        }
+        
+        public String dump() {
+                StringBuilder buf = new StringBuilder();
+                for (int i = 1; i < m_pool.getSize(); i++) {
+                        buf.append(String.format("%4d", i));
+                        buf.append("   ");
+                        buf.append(getItem(i).toString());
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/InfoType.java b/src/cuchaz/enigma/bytecode/InfoType.java
new file mode 100644
index 00000000..deaf6232
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/InfoType.java
@@ -0,0 +1,317 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+import cuchaz.enigma.bytecode.accessors.ClassInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.InvokeDynamicInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MemberRefInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MethodHandleInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MethodTypeInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.NameAndTypeInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.StringInfoAccessor;
+
+public enum InfoType {
+        
+        Utf8Info( 1, 0 ),
+        IntegerInfo( 3, 0 ),
+        FloatInfo( 4, 0 ),
+        LongInfo( 5, 0 ),
+        DoubleInfo( 6, 0 ),
+        ClassInfo( 7, 1 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getNameIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor(entry.getItem());
+                        accessor.setNameIndex(remapIndex(map, accessor.getNameIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor(entry.getItem());
+                        ConstInfoAccessor nameEntry = pool.getItem(accessor.getNameIndex());
+                        return nameEntry != null && nameEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        StringInfo( 8, 1 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        StringInfoAccessor accessor = new StringInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getStringIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        StringInfoAccessor accessor = new StringInfoAccessor(entry.getItem());
+                        accessor.setStringIndex(remapIndex(map, accessor.getStringIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        StringInfoAccessor accessor = new StringInfoAccessor(entry.getItem());
+                        ConstInfoAccessor stringEntry = pool.getItem(accessor.getStringIndex());
+                        return stringEntry != null && stringEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        FieldRefInfo( 9, 2 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getClassIndex());
+                        gatherIndexTree(indices, editor, accessor.getNameAndTypeIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor(entry.getItem());
+                        accessor.setClassIndex(remapIndex(map, accessor.getClassIndex()));
+                        accessor.setNameAndTypeIndex(remapIndex(map, accessor.getNameAndTypeIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor(entry.getItem());
+                        ConstInfoAccessor classEntry = pool.getItem(accessor.getClassIndex());
+                        ConstInfoAccessor nameAndTypeEntry = pool.getItem(accessor.getNameAndTypeIndex());
+                        return classEntry != null && classEntry.getTag() == ClassInfo.getTag() && nameAndTypeEntry != null && nameAndTypeEntry.getTag() == NameAndTypeInfo.getTag();
+                }
+        },
+        // same as FieldRefInfo
+        MethodRefInfo( 10, 2 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        FieldRefInfo.gatherIndexTree(indices, editor, entry);
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        FieldRefInfo.remapIndices(map, entry);
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        return FieldRefInfo.subIndicesAreValid(entry, pool);
+                }
+        },
+        // same as FieldRefInfo
+        InterfaceMethodRefInfo( 11, 2 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        FieldRefInfo.gatherIndexTree(indices, editor, entry);
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        FieldRefInfo.remapIndices(map, entry);
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        return FieldRefInfo.subIndicesAreValid(entry, pool);
+                }
+        },
+        NameAndTypeInfo( 12, 1 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getNameIndex());
+                        gatherIndexTree(indices, editor, accessor.getTypeIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor(entry.getItem());
+                        accessor.setNameIndex(remapIndex(map, accessor.getNameIndex()));
+                        accessor.setTypeIndex(remapIndex(map, accessor.getTypeIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor(entry.getItem());
+                        ConstInfoAccessor nameEntry = pool.getItem(accessor.getNameIndex());
+                        ConstInfoAccessor typeEntry = pool.getItem(accessor.getTypeIndex());
+                        return nameEntry != null && nameEntry.getTag() == Utf8Info.getTag() && typeEntry != null && typeEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        MethodHandleInfo( 15, 3 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getTypeIndex());
+                        gatherIndexTree(indices, editor, accessor.getMethodRefIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor(entry.getItem());
+                        accessor.setTypeIndex(remapIndex(map, accessor.getTypeIndex()));
+                        accessor.setMethodRefIndex(remapIndex(map, accessor.getMethodRefIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor(entry.getItem());
+                        ConstInfoAccessor typeEntry = pool.getItem(accessor.getTypeIndex());
+                        ConstInfoAccessor methodRefEntry = pool.getItem(accessor.getMethodRefIndex());
+                        return typeEntry != null && typeEntry.getTag() == Utf8Info.getTag() && methodRefEntry != null && methodRefEntry.getTag() == MethodRefInfo.getTag();
+                }
+        },
+        MethodTypeInfo( 16, 1 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getTypeIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor(entry.getItem());
+                        accessor.setTypeIndex(remapIndex(map, accessor.getTypeIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor(entry.getItem());
+                        ConstInfoAccessor typeEntry = pool.getItem(accessor.getTypeIndex());
+                        return typeEntry != null && typeEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        InvokeDynamicInfo( 18, 2 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getBootstrapIndex());
+                        gatherIndexTree(indices, editor, accessor.getNameAndTypeIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor(entry.getItem());
+                        accessor.setBootstrapIndex(remapIndex(map, accessor.getBootstrapIndex()));
+                        accessor.setNameAndTypeIndex(remapIndex(map, accessor.getNameAndTypeIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor(entry.getItem());
+                        ConstInfoAccessor bootstrapEntry = pool.getItem(accessor.getBootstrapIndex());
+                        ConstInfoAccessor nameAndTypeEntry = pool.getItem(accessor.getNameAndTypeIndex());
+                        return bootstrapEntry != null && bootstrapEntry.getTag() == Utf8Info.getTag() && nameAndTypeEntry != null && nameAndTypeEntry.getTag() == NameAndTypeInfo.getTag();
+                }
+        };
+        
+        private static Map<Integer,InfoType> m_types;
+        
+        static {
+                m_types = Maps.newTreeMap();
+                for (InfoType type : values()) {
+                        m_types.put(type.getTag(), type);
+                }
+        }
+        
+        private int m_tag;
+        private int m_level;
+        
+        private InfoType(int tag, int level) {
+                m_tag = tag;
+                m_level = level;
+        }
+        
+        public int getTag() {
+                return m_tag;
+        }
+        
+        public int getLevel() {
+                return m_level;
+        }
+        
+        public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                // by default, do nothing
+        }
+        
+        public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                // by default, do nothing
+        }
+        
+        public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                // by default, everything is good
+                return true;
+        }
+        
+        public boolean selfIndexIsValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                ConstInfoAccessor entryCheck = pool.getItem(entry.getIndex());
+                if (entryCheck == null) {
+                        return false;
+                }
+                return entryCheck.getItem().equals(entry.getItem());
+        }
+        
+        public static InfoType getByTag(int tag) {
+                return m_types.get(tag);
+        }
+        
+        public static List<InfoType> getByLevel(int level) {
+                List<InfoType> types = Lists.newArrayList();
+                for (InfoType type : values()) {
+                        if (type.getLevel() == level) {
+                                types.add(type);
+                        }
+                }
+                return types;
+        }
+        
+        public static List<InfoType> getSortedByLevel() {
+                List<InfoType> types = Lists.newArrayList();
+                types.addAll(getByLevel(0));
+                types.addAll(getByLevel(1));
+                types.addAll(getByLevel(2));
+                types.addAll(getByLevel(3));
+                return types;
+        }
+        
+        public static void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, int index) {
+                // add own index
+                indices.add(index);
+                
+                // recurse
+                ConstInfoAccessor entry = editor.getItem(index);
+                entry.getType().gatherIndexTree(indices, editor, entry);
+        }
+        
+        private static int remapIndex(Map<Integer,Integer> map, int index) {
+                Integer newIndex = map.get(index);
+                if (newIndex == null) {
+                        newIndex = index;
+                }
+                return newIndex;
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/InnerClassWriter.java b/src/cuchaz/enigma/bytecode/InnerClassWriter.java
new file mode 100644
index 00000000..817500b7
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/InnerClassWriter.java
@@ -0,0 +1,102 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Collection;
+
+import javassist.CtClass;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.EnclosingMethodAttribute;
+import javassist.bytecode.InnerClassesAttribute;
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class InnerClassWriter {
+        
+        private JarIndex m_jarIndex;
+        
+        public InnerClassWriter(JarIndex jarIndex) {
+                m_jarIndex = jarIndex;
+        }
+        
+        public void write(CtClass c) {
+                
+                // is this an inner or outer class?
+                String obfInnerClassName = new ClassEntry(Descriptor.toJvmName(c.getName())).getSimpleName();
+                String obfOuterClassName = m_jarIndex.getOuterClass(obfInnerClassName);
+                if (obfOuterClassName == null) {
+                        // this is an outer class
+                        obfOuterClassName = Descriptor.toJvmName(c.getName());
+                } else {
+                        // this is an inner class, rename it to outer$inner
+                        ClassEntry obfClassEntry = new ClassEntry(obfOuterClassName + "$" + obfInnerClassName);
+                        c.setName(obfClassEntry.getName());
+                        
+                        BehaviorEntry caller = m_jarIndex.getAnonymousClassCaller(obfInnerClassName);
+                        if (caller != null) {
+                                // write the enclosing method attribute
+                                if (caller.getName().equals("<clinit>")) {
+                                        c.getClassFile().addAttribute(new EnclosingMethodAttribute(c.getClassFile().getConstPool(), caller.getClassName()));
+                                } else {
+                                        c.getClassFile().addAttribute(new EnclosingMethodAttribute(c.getClassFile().getConstPool(), caller.getClassName(), caller.getName(), caller.getSignature().toString()));
+                                }
+                        }
+                }
+                
+                // write the inner classes if needed
+                Collection<String> obfInnerClassNames = m_jarIndex.getInnerClasses(obfOuterClassName);
+                if (obfInnerClassNames != null && !obfInnerClassNames.isEmpty()) {
+                        writeInnerClasses(c, obfOuterClassName, obfInnerClassNames);
+                }
+        }
+        
+        private void writeInnerClasses(CtClass c, String obfOuterClassName, Collection<String> obfInnerClassNames) {
+                InnerClassesAttribute attr = new InnerClassesAttribute(c.getClassFile().getConstPool());
+                c.getClassFile().addAttribute(attr);
+                for (String obfInnerClassName : obfInnerClassNames) {
+                        // get the new inner class name
+                        ClassEntry obfClassEntry = new ClassEntry(obfOuterClassName + "$" + obfInnerClassName);
+                        
+                        // here's what the JVM spec says about the InnerClasses attribute
+                        // append( inner, outer of inner if inner is member of outer 0 ow, name after $ if inner not anonymous 0 ow, flags );
+                        
+                        // update the attribute with this inner class
+                        ConstPool constPool = c.getClassFile().getConstPool();
+                        int innerClassIndex = constPool.addClassInfo(obfClassEntry.getName());
+                        int outerClassIndex = 0;
+                        int innerClassSimpleNameIndex = 0;
+                        if (!m_jarIndex.isAnonymousClass(obfInnerClassName)) {
+                                outerClassIndex = constPool.addClassInfo(obfClassEntry.getOuterClassName());
+                                innerClassSimpleNameIndex = constPool.addUtf8Info(obfClassEntry.getInnerClassName());
+                        }
+                        
+                        attr.append(innerClassIndex, outerClassIndex, innerClassSimpleNameIndex, c.getClassFile().getAccessFlags() & ~AccessFlag.SUPER);
+                        
+                        /* DEBUG 
+                        System.out.println(String.format("\tOBF: %s -> ATTR: %s,%s,%s (replace %s with %s)",
+                                obfClassEntry,
+                                attr.outerClass(attr.tableLength() - 1),
+                                attr.innerClass(attr.tableLength() - 1),
+                                attr.innerName(attr.tableLength() - 1),
+                                Constants.NonePackage + "/" + obfInnerClassName,
+                                obfClassEntry.getName()
+                        ));
+                        */
+                        
+                        // make sure the outer class references only the new inner class names
+                        c.replaceClassName(Constants.NonePackage + "/" + obfInnerClassName, obfClassEntry.getName());
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/MethodParameterWriter.java b/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
new file mode 100644
index 00000000..5d4ca1ad
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.Translator;
+
+public class MethodParameterWriter {
+        
+        private Translator m_translator;
+        
+        public MethodParameterWriter(Translator translator) {
+                m_translator = translator;
+        }
+        
+        public void writeMethodArguments(CtClass c) {
+                
+                // Procyon will read method arguments from the "MethodParameters" attribute, so write those
+                for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                        BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(behavior);
+
+                        // get the number of arguments
+                        int numParams = behaviorEntry.getSignature().getArgumentTypes().size();
+                        if (numParams <= 0) {
+                                continue;
+                        }
+                        
+                        // get the list of argument names
+                        List<String> names = new ArrayList<String>(numParams);
+                        for (int i = 0; i < numParams; i++) {
+                                names.add(m_translator.translate(new ArgumentEntry(behaviorEntry, i, "")));
+                        }
+                        
+                        // save the mappings to the class
+                        MethodParametersAttribute.updateClass(behavior.getMethodInfo(), names);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
new file mode 100644
index 00000000..bf959564
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import javassist.bytecode.AttributeInfo;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.MethodInfo;
+
+public class MethodParametersAttribute extends AttributeInfo {
+        
+        private MethodParametersAttribute(ConstPool pool, List<Integer> parameterNameIndices) {
+                super(pool, "MethodParameters", writeStruct(parameterNameIndices));
+        }
+        
+        public static void updateClass(MethodInfo info, List<String> names) {
+                // add the names to the class const pool
+                ConstPool constPool = info.getConstPool();
+                List<Integer> parameterNameIndices = new ArrayList<Integer>();
+                for (String name : names) {
+                        if (name != null) {
+                                parameterNameIndices.add(constPool.addUtf8Info(name));
+                        } else {
+                                parameterNameIndices.add(0);
+                        }
+                }
+                
+                // add the attribute to the method
+                info.addAttribute(new MethodParametersAttribute(constPool, parameterNameIndices));
+        }
+        
+        private static byte[] writeStruct(List<Integer> parameterNameIndices) {
+                // JVM 8 Spec says the struct looks like this:
+                // http://cr.openjdk.java.net/~mr/se/8/java-se-8-fr-spec-01/java-se-8-jvms-fr-diffs.pdf
+                // uint8 num_params
+                // for each param:
+                // uint16 name_index -> points to UTF8 entry in constant pool, or 0 for no entry
+                // uint16 access_flags -> don't care, just set to 0
+                
+                ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                DataOutputStream out = new DataOutputStream(buf);
+                
+                // NOTE: java hates unsigned integers, so we have to be careful here
+                // the writeShort(), writeByte() methods will read 16,8 low-order bits from the int argument
+                // as long as the int argument is in range of the unsigned short/byte type, it will be written as an unsigned short/byte
+                // if the int is out of range, the byte stream won't look the way we want and weird things will happen
+                final int SIZEOF_UINT8 = 1;
+                final int SIZEOF_UINT16 = 2;
+                final int MAX_UINT8 = (1 << 8) - 1;
+                final int MAX_UINT16 = (1 << 16) - 1;
+                
+                try {
+                        assert (parameterNameIndices.size() >= 0 && parameterNameIndices.size() <= MAX_UINT8);
+                        out.writeByte(parameterNameIndices.size());
+                        
+                        for (Integer index : parameterNameIndices) {
+                                assert (index >= 0 && index <= MAX_UINT16);
+                                out.writeShort(index);
+                                
+                                // just write 0 for the access flags
+                                out.writeShort(0);
+                        }
+                        
+                        out.close();
+                        byte[] data = buf.toByteArray();
+                        assert (data.length == SIZEOF_UINT8 + parameterNameIndices.size() * (SIZEOF_UINT16 + SIZEOF_UINT16));
+                        return data;
+                } catch (IOException ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
new file mode 100644
index 00000000..d76f0567
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class ClassInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_nameIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.ClassInfo");
+                        m_nameIndex = m_class.getDeclaredField("name");
+                        m_nameIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public ClassInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getNameIndex() {
+                try {
+                        return (Integer)m_nameIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setNameIndex(int val) {
+                try {
+                        m_nameIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
new file mode 100644
index 00000000..d00c1021
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
@@ -0,0 +1,156 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import cuchaz.enigma.bytecode.InfoType;
+
+public class ConstInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_index;
+        private static Method m_getTag;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.ConstInfo");
+                        m_index = m_class.getDeclaredField("index");
+                        m_index.setAccessible(true);
+                        m_getTag = m_class.getMethod("getTag");
+                        m_getTag.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private Object m_item;
+        
+        public ConstInfoAccessor(Object item) {
+                if (item == null) {
+                        throw new IllegalArgumentException("item cannot be null!");
+                }
+                m_item = item;
+        }
+        
+        public ConstInfoAccessor(DataInputStream in) throws IOException {
+                try {
+                        // read the entry
+                        String className = in.readUTF();
+                        int oldIndex = in.readInt();
+                        
+                        // NOTE: ConstInfo instances write a type id (a "tag"), but they don't read it back
+                        // so we have to read it here
+                        in.readByte();
+                        
+                        Constructor<?> constructor = Class.forName(className).getConstructor(DataInputStream.class, int.class);
+                        constructor.setAccessible(true);
+                        m_item = constructor.newInstance(in, oldIndex);
+                } catch (IOException ex) {
+                        throw ex;
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public Object getItem() {
+                return m_item;
+        }
+        
+        public int getIndex() {
+                try {
+                        return (Integer)m_index.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setIndex(int val) {
+                try {
+                        m_index.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getTag() {
+                try {
+                        return (Integer)m_getTag.invoke(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public ConstInfoAccessor copy() {
+                return new ConstInfoAccessor(copyItem());
+        }
+        
+        public Object copyItem() {
+                // I don't know of a simpler way to copy one of these silly things...
+                try {
+                        // serialize the item
+                        ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                        DataOutputStream out = new DataOutputStream(buf);
+                        write(out);
+                        
+                        // deserialize the item
+                        DataInputStream in = new DataInputStream(new ByteArrayInputStream(buf.toByteArray()));
+                        Object item = new ConstInfoAccessor(in).getItem();
+                        in.close();
+                        
+                        return item;
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void write(DataOutputStream out) throws IOException {
+                try {
+                        out.writeUTF(m_item.getClass().getName());
+                        out.writeInt(getIndex());
+                        
+                        Method method = m_item.getClass().getMethod("write", DataOutputStream.class);
+                        method.setAccessible(true);
+                        method.invoke(m_item, out);
+                } catch (IOException ex) {
+                        throw ex;
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        @Override
+        public String toString() {
+                try {
+                        ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                        PrintWriter out = new PrintWriter(buf);
+                        Method print = m_item.getClass().getMethod("print", PrintWriter.class);
+                        print.setAccessible(true);
+                        print.invoke(m_item, out);
+                        out.close();
+                        return buf.toString().replace("\n", "");
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public InfoType getType() {
+                return InfoType.getByTag(getTag());
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
new file mode 100644
index 00000000..0d780ea6
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class InvokeDynamicInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_bootstrapIndex;
+        private static Field m_nameAndTypeIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.InvokeDynamicInfo");
+                        m_bootstrapIndex = m_class.getDeclaredField("bootstrap");
+                        m_bootstrapIndex.setAccessible(true);
+                        m_nameAndTypeIndex = m_class.getDeclaredField("nameAndType");
+                        m_nameAndTypeIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public InvokeDynamicInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getBootstrapIndex() {
+                try {
+                        return (Integer)m_bootstrapIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setBootstrapIndex(int val) {
+                try {
+                        m_bootstrapIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getNameAndTypeIndex() {
+                try {
+                        return (Integer)m_nameAndTypeIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setNameAndTypeIndex(int val) {
+                try {
+                        m_nameAndTypeIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
new file mode 100644
index 00000000..9fe945f7
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MemberRefInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_classIndex;
+        private static Field m_nameAndTypeIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.MemberrefInfo");
+                        m_classIndex = m_class.getDeclaredField("classIndex");
+                        m_classIndex.setAccessible(true);
+                        m_nameAndTypeIndex = m_class.getDeclaredField("nameAndTypeIndex");
+                        m_nameAndTypeIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public MemberRefInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getClassIndex() {
+                try {
+                        return (Integer)m_classIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setClassIndex(int val) {
+                try {
+                        m_classIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getNameAndTypeIndex() {
+                try {
+                        return (Integer)m_nameAndTypeIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setNameAndTypeIndex(int val) {
+                try {
+                        m_nameAndTypeIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
new file mode 100644
index 00000000..4c95b226
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MethodHandleInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_kindIndex;
+        private static Field m_indexIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.MethodHandleInfo");
+                        m_kindIndex = m_class.getDeclaredField("refKind");
+                        m_kindIndex.setAccessible(true);
+                        m_indexIndex = m_class.getDeclaredField("refIndex");
+                        m_indexIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public MethodHandleInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getTypeIndex() {
+                try {
+                        return (Integer)m_kindIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setTypeIndex(int val) {
+                try {
+                        m_kindIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getMethodRefIndex() {
+                try {
+                        return (Integer)m_indexIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setMethodRefIndex(int val) {
+                try {
+                        m_indexIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
new file mode 100644
index 00000000..e1511179
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MethodTypeInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_descriptorIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.MethodTypeInfo");
+                        m_descriptorIndex = m_class.getDeclaredField("descriptor");
+                        m_descriptorIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public MethodTypeInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getTypeIndex() {
+                try {
+                        return (Integer)m_descriptorIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setTypeIndex(int val) {
+                try {
+                        m_descriptorIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
new file mode 100644
index 00000000..6e82f3e9
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class NameAndTypeInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_nameIndex;
+        private static Field m_typeIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.NameAndTypeInfo");
+                        m_nameIndex = m_class.getDeclaredField("memberName");
+                        m_nameIndex.setAccessible(true);
+                        m_typeIndex = m_class.getDeclaredField("typeDescriptor");
+                        m_typeIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public NameAndTypeInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getNameIndex() {
+                try {
+                        return (Integer)m_nameIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setNameIndex(int val) {
+                try {
+                        m_nameIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getTypeIndex() {
+                try {
+                        return (Integer)m_typeIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setTypeIndex(int val) {
+                try {
+                        m_typeIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
new file mode 100644
index 00000000..6665ffe4
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class StringInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_stringIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.StringInfo");
+                        m_stringIndex = m_class.getDeclaredField("string");
+                        m_stringIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public StringInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getStringIndex() {
+                try {
+                        return (Integer)m_stringIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setStringIndex(int val) {
+                try {
+                        m_stringIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
new file mode 100644
index 00000000..2abf60b4
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+public class Utf8InfoAccessor {
+        
+        private static Class<?> m_class;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.Utf8Info");
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+}
diff --git a/src/cuchaz/enigma/convert/ClassIdentity.java b/src/cuchaz/enigma/convert/ClassIdentity.java
new file mode 100644
index 00000000..1be61239
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassIdentity.java
@@ -0,0 +1,411 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Map;
+
+import javassist.CannotCompileException;
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.Opcode;
+import javassist.expr.ConstructorCall;
+import javassist.expr.ExprEditor;
+import javassist.expr.FieldAccess;
+import javassist.expr.MethodCall;
+import javassist.expr.NewExpr;
+
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multiset;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.Util;
+import cuchaz.enigma.analysis.ClassImplementationsTreeNode;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.bytecode.ConstPoolEditor;
+import cuchaz.enigma.bytecode.InfoType;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.convert.ClassNamer.SidedClassNamer;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassNameReplacer;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.Signature;
+
+public class ClassIdentity {
+        
+        private ClassEntry m_classEntry;
+        private SidedClassNamer m_namer;
+        private Multiset<String> m_fields;
+        private Multiset<String> m_methods;
+        private Multiset<String> m_constructors;
+        private String m_staticInitializer;
+        private String m_extends;
+        private Multiset<String> m_implements;
+        private Multiset<String> m_implementations;
+        private Multiset<String> m_references;
+        
+        public ClassIdentity(CtClass c, SidedClassNamer namer, JarIndex index, boolean useReferences) {
+                m_namer = namer;
+                
+                // stuff from the bytecode
+                
+                m_classEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                m_fields = HashMultiset.create();
+                for (CtField field : c.getDeclaredFields()) {
+                        m_fields.add(scrubSignature(field.getSignature()));
+                }
+                m_methods = HashMultiset.create();
+                for (CtMethod method : c.getDeclaredMethods()) {
+                        m_methods.add(scrubSignature(method.getSignature()) + "0x" + getBehaviorSignature(method));
+                }
+                m_constructors = HashMultiset.create();
+                for (CtConstructor constructor : c.getDeclaredConstructors()) {
+                        m_constructors.add(scrubSignature(constructor.getSignature()) + "0x" + getBehaviorSignature(constructor));
+                }
+                m_staticInitializer = "";
+                if (c.getClassInitializer() != null) {
+                        m_staticInitializer = getBehaviorSignature(c.getClassInitializer());
+                }
+                m_extends = "";
+                if (c.getClassFile().getSuperclass() != null) {
+                        m_extends = scrubClassName(c.getClassFile().getSuperclass());
+                }
+                m_implements = HashMultiset.create();
+                for (String interfaceName : c.getClassFile().getInterfaces()) {
+                        m_implements.add(scrubClassName(interfaceName));
+                }
+                
+                // stuff from the jar index
+                
+                m_implementations = HashMultiset.create();
+                ClassImplementationsTreeNode implementationsNode = index.getClassImplementations(null, m_classEntry);
+                if (implementationsNode != null) {
+                        @SuppressWarnings("unchecked")
+                        Enumeration<ClassImplementationsTreeNode> implementations = implementationsNode.children();
+                        while (implementations.hasMoreElements()) {
+                                ClassImplementationsTreeNode node = implementations.nextElement();
+                                m_implementations.add(scrubClassName(node.getClassEntry().getName()));
+                        }
+                }
+                
+                m_references = HashMultiset.create();
+                if (useReferences) {
+                        for (CtField field : c.getDeclaredFields()) {
+                                FieldEntry fieldEntry = new FieldEntry(m_classEntry, field.getName());
+                                for (EntryReference<FieldEntry,BehaviorEntry> reference : index.getFieldReferences(fieldEntry)) {
+                                        addReference(reference);
+                                }
+                        }
+                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                BehaviorEntry behaviorEntry = JavassistUtil.getBehaviorEntry(behavior);
+                                for (EntryReference<BehaviorEntry,BehaviorEntry> reference : index.getBehaviorReferences(behaviorEntry)) {
+                                        addReference(reference);
+                                }
+                        }
+                }
+        }
+        
+        private void addReference(EntryReference<? extends Entry,BehaviorEntry> reference) {
+                if (reference.context.getSignature() != null) {
+                        m_references.add(String.format("%s_%s", scrubClassName(reference.context.getClassName()), scrubSignature(reference.context.getSignature())));
+                } else {
+                        m_references.add(String.format("%s_<clinit>", scrubClassName(reference.context.getClassName())));
+                }
+        }
+        
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("class: ");
+                buf.append(m_classEntry.getName());
+                buf.append(" ");
+                buf.append(hashCode());
+                buf.append("\n");
+                for (String field : m_fields) {
+                        buf.append("\tfield ");
+                        buf.append(field);
+                        buf.append("\n");
+                }
+                for (String method : m_methods) {
+                        buf.append("\tmethod ");
+                        buf.append(method);
+                        buf.append("\n");
+                }
+                for (String constructor : m_constructors) {
+                        buf.append("\tconstructor ");
+                        buf.append(constructor);
+                        buf.append("\n");
+                }
+                if (m_staticInitializer.length() > 0) {
+                        buf.append("\tinitializer ");
+                        buf.append(m_staticInitializer);
+                        buf.append("\n");
+                }
+                if (m_extends.length() > 0) {
+                        buf.append("\textends ");
+                        buf.append(m_extends);
+                        buf.append("\n");
+                }
+                for (String interfaceName : m_implements) {
+                        buf.append("\timplements ");
+                        buf.append(interfaceName);
+                        buf.append("\n");
+                }
+                for (String implementation : m_implementations) {
+                        buf.append("\timplemented by ");
+                        buf.append(implementation);
+                        buf.append("\n");
+                }
+                for (String reference : m_references) {
+                        buf.append("\treference ");
+                        buf.append(reference);
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+        
+        private String scrubClassName(String className) {
+                return scrubSignature("L" + Descriptor.toJvmName(className) + ";");
+        }
+        
+        private String scrubSignature(String signature) {
+                return scrubSignature(new Signature(signature));
+        }
+        
+        private String scrubSignature(Signature signature) {
+                
+                return new Signature(signature, new ClassNameReplacer() {
+                        
+                        private Map<String,String> m_classNames = Maps.newHashMap();
+                        
+                        @Override
+                        public String replace(String className) {
+                                
+                                // classes not in the none package can be passed through
+                                ClassEntry classEntry = new ClassEntry(className);
+                                if (!classEntry.getPackageName().equals(Constants.NonePackage)) {
+                                        return className;
+                                }
+                                
+                                // is this class ourself?
+                                if (className.equals(m_classEntry.getName())) {
+                                        return "CSelf";
+                                }
+                                
+                                // try the namer
+                                if (m_namer != null) {
+                                        String newName = m_namer.getName(className);
+                                        if (newName != null) {
+                                                return newName;
+                                        }
+                                }
+                                
+                                // otherwise, use local naming
+                                if (!m_classNames.containsKey(className)) {
+                                        m_classNames.put(className, getNewClassName());
+                                }
+                                return m_classNames.get(className);
+                        }
+                        
+                        private String getNewClassName() {
+                                return String.format("C%03d", m_classNames.size());
+                        }
+                }).toString();
+        }
+        
+        private boolean isClassMatchedUniquely(String className) {
+                return m_namer != null && m_namer.getName(Descriptor.toJvmName(className)) != null;
+        }
+        
+        private String getBehaviorSignature(CtBehavior behavior) {
+                try {
+                        // does this method have an implementation?
+                        if (behavior.getMethodInfo().getCodeAttribute() == null) {
+                                return "(none)";
+                        }
+                        
+                        // compute the hash from the opcodes
+                        ConstPool constants = behavior.getMethodInfo().getConstPool();
+                        final MessageDigest digest = MessageDigest.getInstance("MD5");
+                        CodeIterator iter = behavior.getMethodInfo().getCodeAttribute().iterator();
+                        while (iter.hasNext()) {
+                                int pos = iter.next();
+                                
+                                // update the hash with the opcode
+                                int opcode = iter.byteAt(pos);
+                                digest.update((byte)opcode);
+                                
+                                switch (opcode) {
+                                        case Opcode.LDC: {
+                                                int constIndex = iter.byteAt(pos + 1);
+                                                updateHashWithConstant(digest, constants, constIndex);
+                                        }
+                                        break;
+                                        
+                                        case Opcode.LDC_W:
+                                        case Opcode.LDC2_W: {
+                                                int constIndex = (iter.byteAt(pos + 1) << 8) | iter.byteAt(pos + 2);
+                                                updateHashWithConstant(digest, constants, constIndex);
+                                        }
+                                        break;
+                                }
+                        }
+                        
+                        // update hash with method and field accesses
+                        behavior.instrument(new ExprEditor() {
+                                @Override
+                                public void edit(MethodCall call) {
+                                        updateHashWithString(digest, scrubClassName(call.getClassName()));
+                                        updateHashWithString(digest, scrubSignature(call.getSignature()));
+                                        if (isClassMatchedUniquely(call.getClassName())) {
+                                                updateHashWithString(digest, call.getMethodName());
+                                        }
+                                }
+                                
+                                @Override
+                                public void edit(FieldAccess access) {
+                                        updateHashWithString(digest, scrubClassName(access.getClassName()));
+                                        updateHashWithString(digest, scrubSignature(access.getSignature()));
+                                        if (isClassMatchedUniquely(access.getClassName())) {
+                                                updateHashWithString(digest, access.getFieldName());
+                                        }
+                                }
+                                
+                                @Override
+                                public void edit(ConstructorCall call) {
+                                        updateHashWithString(digest, scrubClassName(call.getClassName()));
+                                        updateHashWithString(digest, scrubSignature(call.getSignature()));
+                                }
+                                
+                                @Override
+                                public void edit(NewExpr expr) {
+                                        updateHashWithString(digest, scrubClassName(expr.getClassName()));
+                                }
+                        });
+                        
+                        // convert the hash to a hex string
+                        return toHex(digest.digest());
+                } catch (BadBytecode | NoSuchAlgorithmException | CannotCompileException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private void updateHashWithConstant(MessageDigest digest, ConstPool constants, int index) {
+                ConstPoolEditor editor = new ConstPoolEditor(constants);
+                ConstInfoAccessor item = editor.getItem(index);
+                if (item.getType() == InfoType.StringInfo) {
+                        updateHashWithString(digest, constants.getStringInfo(index));
+                }
+                // TODO: other constants
+        }
+        
+        private void updateHashWithString(MessageDigest digest, String val) {
+                try {
+                        digest.update(val.getBytes("UTF8"));
+                } catch (UnsupportedEncodingException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private String toHex(byte[] bytes) {
+                // function taken from:
+                // http://stackoverflow.com/questions/9655181/convert-from-byte-array-to-hex-string-in-java
+                final char[] hexArray = "0123456789ABCDEF".toCharArray();
+                char[] hexChars = new char[bytes.length * 2];
+                for (int j = 0; j < bytes.length; j++) {
+                        int v = bytes[j] & 0xFF;
+                        hexChars[j * 2] = hexArray[v >>> 4];
+                        hexChars[j * 2 + 1] = hexArray[v & 0x0F];
+                }
+                return new String(hexChars);
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ClassIdentity) {
+                        return equals((ClassIdentity)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ClassIdentity other) {
+                return m_fields.equals(other.m_fields)
+                        && m_methods.equals(other.m_methods)
+                        && m_constructors.equals(other.m_constructors)
+                        && m_staticInitializer.equals(other.m_staticInitializer)
+                        && m_extends.equals(other.m_extends)
+                        && m_implements.equals(other.m_implements)
+                        && m_implementations.equals(other.m_implementations)
+                        && m_references.equals(other.m_references);
+        }
+        
+        @Override
+        public int hashCode() {
+                List<Object> objs = Lists.newArrayList();
+                objs.addAll(m_fields);
+                objs.addAll(m_methods);
+                objs.addAll(m_constructors);
+                objs.add(m_staticInitializer);
+                objs.add(m_extends);
+                objs.addAll(m_implements);
+                objs.addAll(m_implementations);
+                objs.addAll(m_references);
+                return Util.combineHashesOrdered(objs);
+        }
+        
+        public int getMatchScore(ClassIdentity other) {
+                return getNumMatches(m_fields, other.m_fields) 
+                        + getNumMatches(m_methods, other.m_methods)
+                        + getNumMatches(m_constructors, other.m_constructors);
+        }
+        
+        public int getMaxMatchScore() {
+                return m_fields.size() + m_methods.size() + m_constructors.size();
+        }
+        
+        public boolean matches(CtClass c) {
+                // just compare declaration counts
+                return m_fields.size() == c.getDeclaredFields().length
+                        && m_methods.size() == c.getDeclaredMethods().length
+                        && m_constructors.size() == c.getDeclaredConstructors().length;
+        }
+        
+        private int getNumMatches(Multiset<String> a, Multiset<String> b) {
+                int numMatches = 0;
+                for (String val : a) {
+                        if (b.contains(val)) {
+                                numMatches++;
+                        }
+                }
+                return numMatches;
+        }
+}
diff --git a/src/cuchaz/enigma/convert/ClassMatcher.java b/src/cuchaz/enigma/convert/ClassMatcher.java
new file mode 100644
index 00000000..ccf6b787
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassMatcher.java
@@ -0,0 +1,406 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.jar.JarFile;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.TranslatingTypeLoader;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.convert.ClassNamer.SidedClassNamer;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassMapping;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.MappingParseException;
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsReader;
+import cuchaz.enigma.mapping.MappingsWriter;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.MethodMapping;
+
+public class ClassMatcher {
+        
+        public static void main(String[] args) throws IOException, MappingParseException {
+                // TEMP
+                JarFile sourceJar = new JarFile(new File("input/1.8-pre3.jar"));
+                JarFile destJar = new JarFile(new File("input/1.8.jar"));
+                File inMappingsFile = new File("../Enigma Mappings/1.8-pre3.mappings");
+                File outMappingsFile = new File("../Enigma Mappings/1.8.mappings");
+                
+                // define a matching to use when the automated system cannot find a match
+                Map<String,String> fallbackMatching = Maps.newHashMap();
+                fallbackMatching.put("none/ayb", "none/ayf");
+                fallbackMatching.put("none/ayd", "none/ayd");
+                fallbackMatching.put("none/bgk", "unknown/bgk");
+                
+                // do the conversion
+                Mappings mappings = new MappingsReader().read(new FileReader(inMappingsFile));
+                convertMappings(sourceJar, destJar, mappings, fallbackMatching);
+                
+                // write out the converted mappings
+                FileWriter writer = new FileWriter(outMappingsFile);
+                new MappingsWriter().write(writer, mappings);
+                writer.close();
+                System.out.println("Wrote converted mappings to:\n\t" + outMappingsFile.getAbsolutePath());
+        }
+        
+        private static void convertMappings(JarFile sourceJar, JarFile destJar, Mappings mappings, Map<String,String> fallbackMatching) {
+                // index jars
+                System.out.println("Indexing source jar...");
+                JarIndex sourceIndex = new JarIndex();
+                sourceIndex.indexJar(sourceJar, false);
+                System.out.println("Indexing dest jar...");
+                JarIndex destIndex = new JarIndex();
+                destIndex.indexJar(destJar, false);
+                TranslatingTypeLoader sourceLoader = new TranslatingTypeLoader(sourceJar, sourceIndex);
+                TranslatingTypeLoader destLoader = new TranslatingTypeLoader(destJar, destIndex);
+                
+                // compute the matching
+                ClassMatching matching = computeMatching(sourceIndex, sourceLoader, destIndex, destLoader);
+                Map<String,Map.Entry<ClassIdentity,List<ClassIdentity>>> matchingIndex = matching.getIndex();
+                
+                // get all the obf class names used in the mappings
+                Set<String> usedClassNames = mappings.getAllObfClassNames();
+                Set<String> allClassNames = Sets.newHashSet();
+                for (ClassEntry classEntry : sourceIndex.getObfClassEntries()) {
+                        allClassNames.add(classEntry.getName());
+                }
+                usedClassNames.retainAll(allClassNames);
+                System.out.println("Used " + usedClassNames.size() + " classes in the mappings");
+                
+                // probabilistically match the non-uniquely-matched source classes
+                for (Map.Entry<ClassIdentity,List<ClassIdentity>> entry : matchingIndex.values()) {
+                        ClassIdentity sourceClass = entry.getKey();
+                        List<ClassIdentity> destClasses = entry.getValue();
+                        
+                        // skip classes that are uniquely matched
+                        if (destClasses.size() == 1) {
+                                continue;
+                        }
+                        
+                        // skip classes that aren't used in the mappings
+                        if (!usedClassNames.contains(sourceClass.getClassEntry().getName())) {
+                                continue;
+                        }
+                        
+                        System.out.println("No exact match for source class " + sourceClass.getClassEntry());
+                        
+                        // find the closest classes
+                        Multimap<Integer,ClassIdentity> scoredMatches = ArrayListMultimap.create();
+                        for (ClassIdentity c : destClasses) {
+                                scoredMatches.put(sourceClass.getMatchScore(c), c);
+                        }
+                        List<Integer> scores = new ArrayList<Integer>(scoredMatches.keySet());
+                        Collections.sort(scores, Collections.reverseOrder());
+                        printScoredMatches(sourceClass.getMaxMatchScore(), scores, scoredMatches);
+                        
+                        // does the best match have a non-zero score and the same name?
+                        int bestScore = scores.get(0);
+                        Collection<ClassIdentity> bestMatches = scoredMatches.get(bestScore);
+                        if (bestScore > 0 && bestMatches.size() == 1) {
+                                ClassIdentity bestMatch = bestMatches.iterator().next();
+                                if (bestMatch.getClassEntry().equals(sourceClass.getClassEntry())) {
+                                        // use it
+                                        System.out.println("\tAutomatically choosing likely match: " + bestMatch.getClassEntry().getName());
+                                        destClasses.clear();
+                                        destClasses.add(bestMatch);
+                                }
+                        }
+                }
+                
+                // group the matching into unique and non-unique matches
+                BiMap<String,String> matchedClassNames = HashBiMap.create();
+                Set<String> unmatchedSourceClassNames = Sets.newHashSet();
+                for (String className : usedClassNames) {
+                        // is there a match for this class?
+                        Map.Entry<ClassIdentity,List<ClassIdentity>> entry = matchingIndex.get(className);
+                        ClassIdentity sourceClass = entry.getKey();
+                        List<ClassIdentity> matches = entry.getValue();
+                        
+                        if (matches.size() == 1) {
+                                // unique match! We're good to go!
+                                matchedClassNames.put(sourceClass.getClassEntry().getName(), matches.get(0).getClassEntry().getName());
+                        } else {
+                                // no match, check the fallback matching
+                                String fallbackMatch = fallbackMatching.get(className);
+                                if (fallbackMatch != null) {
+                                        matchedClassNames.put(sourceClass.getClassEntry().getName(), fallbackMatch);
+                                } else {
+                                        unmatchedSourceClassNames.add(className);
+                                }
+                        }
+                }
+                
+                // report unmatched classes
+                if (!unmatchedSourceClassNames.isEmpty()) {
+                        System.err.println("ERROR: there were unmatched classes!");
+                        for (String className : unmatchedSourceClassNames) {
+                                System.err.println("\t" + className);
+                        }
+                        return;
+                }
+                
+                // get the class name changes from the matched class names
+                Map<String,String> classChanges = Maps.newHashMap();
+                for (Map.Entry<String,String> entry : matchedClassNames.entrySet()) {
+                        if (!entry.getKey().equals(entry.getValue())) {
+                                classChanges.put(entry.getKey(), entry.getValue());
+                                System.out.println(String.format("Class change: %s -> %s", entry.getKey(), entry.getValue()));
+                                /* DEBUG
+                                System.out.println(String.format("\n%s\n%s",
+                                        new ClassIdentity(sourceLoader.loadClass(entry.getKey()), null, sourceIndex, false, false),
+                                        new ClassIdentity( destLoader.loadClass(entry.getValue()), null, destIndex, false, false)
+                                ));
+                                */
+                        }
+                }
+                
+                // sort the changes so classes are renamed in the correct order
+                // ie. if we have the mappings a->b, b->c, we have to apply b->c before a->b
+                LinkedHashMap<String,String> orderedClassChanges = Maps.newLinkedHashMap();
+                int numChangesLeft = classChanges.size();
+                while (!classChanges.isEmpty()) {
+                        Iterator<Map.Entry<String,String>> iter = classChanges.entrySet().iterator();
+                        while (iter.hasNext()) {
+                                Map.Entry<String,String> entry = iter.next();
+                                if (classChanges.get(entry.getValue()) == null) {
+                                        orderedClassChanges.put(entry.getKey(), entry.getValue());
+                                        iter.remove();
+                                }
+                        }
+                        
+                        // did we remove any changes?
+                        if (numChangesLeft - classChanges.size() > 0) {
+                                // keep going
+                                numChangesLeft = classChanges.size();
+                        } else {
+                                // can't sort anymore. There must be a loop
+                                break;
+                        }
+                }
+                if (classChanges.size() > 0) {
+                        throw new Error(String.format("Unable to sort %d/%d class changes!", classChanges.size(), matchedClassNames.size()));
+                }
+                
+                // convert the mappings in the correct class order
+                for (Map.Entry<String,String> entry : orderedClassChanges.entrySet()) {
+                        mappings.renameObfClass(entry.getKey(), entry.getValue());
+                }
+                
+                // check the method matches
+                System.out.println("Checking methods...");
+                for (ClassMapping classMapping : mappings.classes()) {
+                        ClassEntry classEntry = new ClassEntry(classMapping.getObfName());
+                        for (MethodMapping methodMapping : classMapping.methods()) {
+                                
+                                // skip constructors
+                                if (methodMapping.getObfName().equals("<init>")) {
+                                        continue;
+                                }
+                                
+                                MethodEntry methodEntry = new MethodEntry(
+                                        classEntry,
+                                        methodMapping.getObfName(),
+                                        methodMapping.getObfSignature()
+                                );
+                                if (!destIndex.containsObfBehavior(methodEntry)) {
+                                        System.err.println("WARNING: method doesn't match: " + methodEntry);
+                                        
+                                        // show the available methods
+                                        System.err.println("\tAvailable dest methods:");
+                                        CtClass c = destLoader.loadClass(classMapping.getObfName());
+                                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                                System.err.println("\t\t" + JavassistUtil.getBehaviorEntry(behavior));
+                                        }
+                                        
+                                        System.err.println("\tAvailable source methods:");
+                                        c = sourceLoader.loadClass(matchedClassNames.inverse().get(classMapping.getObfName()));
+                                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                                System.err.println("\t\t" + JavassistUtil.getBehaviorEntry(behavior));
+                                        }
+                                }
+                        }
+                }
+                
+                System.out.println("Done!");
+        }
+        
+        public static ClassMatching computeMatching(JarIndex sourceIndex, TranslatingTypeLoader sourceLoader, JarIndex destIndex, TranslatingTypeLoader destLoader) {
+                
+                System.out.println("Matching classes...");
+                
+                ClassMatching matching = null;
+                for (boolean useReferences : Arrays.asList(false, true)) {
+                        int numMatches = 0;
+                        do {
+                                SidedClassNamer sourceNamer = null;
+                                SidedClassNamer destNamer = null;
+                                if (matching != null) {
+                                        // build a class namer
+                                        ClassNamer namer = new ClassNamer(matching.getUniqueMatches());
+                                        sourceNamer = namer.getSourceNamer();
+                                        destNamer = namer.getDestNamer();
+                                        
+                                        // note the number of matches
+                                        numMatches = matching.getUniqueMatches().size();
+                                }
+                                
+                                // get the entries left to match
+                                Set<ClassEntry> sourceClassEntries = Sets.newHashSet();
+                                Set<ClassEntry> destClassEntries = Sets.newHashSet();
+                                if (matching == null) {
+                                        sourceClassEntries.addAll(sourceIndex.getObfClassEntries());
+                                        destClassEntries.addAll(destIndex.getObfClassEntries());
+                                        matching = new ClassMatching();
+                                } else {
+                                        for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : matching.getAmbiguousMatches().entrySet()) {
+                                                for (ClassIdentity c : entry.getKey()) {
+                                                        sourceClassEntries.add(c.getClassEntry());
+                                                        matching.removeSource(c);
+                                                }
+                                                for (ClassIdentity c : entry.getValue()) {
+                                                        destClassEntries.add(c.getClassEntry());
+                                                        matching.removeDest(c);
+                                                }
+                                        }
+                                        for (ClassIdentity c : matching.getUnmatchedSourceClasses()) {
+                                                sourceClassEntries.add(c.getClassEntry());
+                                                matching.removeSource(c);
+                                        }
+                                        for (ClassIdentity c : matching.getUnmatchedDestClasses()) {
+                                                destClassEntries.add(c.getClassEntry());
+                                                matching.removeDest(c);
+                                        }
+                                }
+                                
+                                // compute a matching for the classes
+                                for (ClassEntry classEntry : sourceClassEntries) {
+                                        CtClass c = sourceLoader.loadClass(classEntry.getName());
+                                        ClassIdentity sourceClass = new ClassIdentity(c, sourceNamer, sourceIndex, useReferences);
+                                        matching.addSource(sourceClass);
+                                }
+                                for (ClassEntry classEntry : destClassEntries) {
+                                        CtClass c = destLoader.loadClass(classEntry.getName());
+                                        ClassIdentity destClass = new ClassIdentity(c, destNamer, destIndex, useReferences);
+                                        matching.matchDestClass(destClass);
+                                }
+                                
+                                // TEMP
+                                System.out.println(matching);
+                        } while (matching.getUniqueMatches().size() - numMatches > 0);
+                }
+                
+                // check the class matches
+                System.out.println("Checking class matches...");
+                ClassNamer namer = new ClassNamer(matching.getUniqueMatches());
+                SidedClassNamer sourceNamer = namer.getSourceNamer();
+                SidedClassNamer destNamer = namer.getDestNamer();
+                for (Map.Entry<ClassIdentity,ClassIdentity> entry : matching.getUniqueMatches().entrySet()) {
+                        
+                        // check source
+                        ClassIdentity sourceClass = entry.getKey();
+                        CtClass sourceC = sourceLoader.loadClass(sourceClass.getClassEntry().getName());
+                        assert (sourceC != null) : "Unable to load source class " + sourceClass.getClassEntry();
+                        assert (sourceClass.matches(sourceC)) : "Source " + sourceClass + " doesn't match " + new ClassIdentity(sourceC, sourceNamer, sourceIndex, false);
+                        
+                        // check dest
+                        ClassIdentity destClass = entry.getValue();
+                        CtClass destC = destLoader.loadClass(destClass.getClassEntry().getName());
+                        assert (destC != null) : "Unable to load dest class " + destClass.getClassEntry();
+                        assert (destClass.matches(destC)) : "Dest " + destClass + " doesn't match " + new ClassIdentity(destC, destNamer, destIndex, false);
+                }
+                
+                // warn about the ambiguous matchings
+                List<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>> ambiguousMatches = new ArrayList<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>>(matching.getAmbiguousMatches().entrySet());
+                Collections.sort(ambiguousMatches, new Comparator<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>>() {
+                        @Override
+                        public int compare(Map.Entry<List<ClassIdentity>,List<ClassIdentity>> a, Map.Entry<List<ClassIdentity>,List<ClassIdentity>> b) {
+                                String aName = a.getKey().get(0).getClassEntry().getName();
+                                String bName = b.getKey().get(0).getClassEntry().getName();
+                                return aName.compareTo(bName);
+                        }
+                });
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : ambiguousMatches) {
+                        System.out.println("Ambiguous matching:");
+                        System.out.println("\tSource: " + getClassNames(entry.getKey()));
+                        System.out.println("\tDest:   " + getClassNames(entry.getValue()));
+                }
+                
+                /* DEBUG
+                Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry = ambiguousMatches.get( 7 );
+                for (ClassIdentity c : entry.getKey()) {
+                        System.out.println(c);
+                }
+                for(ClassIdentity c : entry.getKey()) {
+                        System.out.println(decompile(sourceLoader, c.getClassEntry())); 
+                }
+                */
+                
+                return matching;
+        }
+        
+        private static void printScoredMatches(int maxScore, List<Integer> scores, Multimap<Integer,ClassIdentity> scoredMatches) {
+                int numScoredMatchesShown = 0;
+                for (int score : scores) {
+                        for (ClassIdentity scoredMatch : scoredMatches.get(score)) {
+                                System.out.println(String.format("\tScore: %3d %3.0f%%   %s", score, 100.0 * score / maxScore, scoredMatch.getClassEntry().getName()));
+                                if (numScoredMatchesShown++ > 10) {
+                                        return;
+                                }
+                        }
+                }
+        }
+        
+        private static List<String> getClassNames(Collection<ClassIdentity> classes) {
+                List<String> out = Lists.newArrayList();
+                for (ClassIdentity c : classes) {
+                        out.add(c.getClassEntry().getName());
+                }
+                Collections.sort(out);
+                return out;
+        }
+        
+        /* DEBUG
+        private static String decompile(TranslatingTypeLoader loader, ClassEntry classEntry) {
+                PlainTextOutput output = new PlainTextOutput();
+                DecompilerSettings settings = DecompilerSettings.javaDefaults();
+                settings.setForceExplicitImports(true);
+                settings.setShowSyntheticMembers(true);
+                settings.setTypeLoader(loader);
+                Decompiler.decompile(classEntry.getName(), output, settings);
+                return output.toString();
+        }
+        */
+}
diff --git a/src/cuchaz/enigma/convert/ClassMatching.java b/src/cuchaz/enigma/convert/ClassMatching.java
new file mode 100644
index 00000000..53b6f7f4
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassMatching.java
@@ -0,0 +1,173 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+
+public class ClassMatching {
+        
+        private Multimap<ClassIdentity,ClassIdentity> m_sourceClasses;
+        private Multimap<ClassIdentity,ClassIdentity> m_matchedDestClasses;
+        private List<ClassIdentity> m_unmatchedDestClasses;
+        
+        public ClassMatching() {
+                m_sourceClasses = ArrayListMultimap.create();
+                m_matchedDestClasses = ArrayListMultimap.create();
+                m_unmatchedDestClasses = Lists.newArrayList();
+        }
+        
+        public void addSource(ClassIdentity c) {
+                m_sourceClasses.put(c, c);
+        }
+        
+        public void matchDestClass(ClassIdentity destClass) {
+                Collection<ClassIdentity> matchedSourceClasses = m_sourceClasses.get(destClass);
+                if (matchedSourceClasses.isEmpty()) {
+                        // no match
+                        m_unmatchedDestClasses.add(destClass);
+                } else {
+                        // found a match
+                        m_matchedDestClasses.put(destClass, destClass);
+                        
+                        // DEBUG
+                        ClassIdentity sourceClass = matchedSourceClasses.iterator().next();
+                        assert (sourceClass.hashCode() == destClass.hashCode());
+                        assert (sourceClass.equals(destClass));
+                }
+        }
+        
+        public void removeSource(ClassIdentity sourceClass) {
+                m_sourceClasses.remove(sourceClass, sourceClass);
+        }
+        
+        public void removeDest(ClassIdentity destClass) {
+                m_matchedDestClasses.remove(destClass, destClass);
+                m_unmatchedDestClasses.remove(destClass);
+        }
+        
+        public List<ClassIdentity> getSourceClasses() {
+                return new ArrayList<ClassIdentity>(m_sourceClasses.values());
+        }
+        
+        public List<ClassIdentity> getDestClasses() {
+                List<ClassIdentity> classes = Lists.newArrayList();
+                classes.addAll(m_matchedDestClasses.values());
+                classes.addAll(m_unmatchedDestClasses);
+                return classes;
+        }
+        
+        public BiMap<ClassIdentity,ClassIdentity> getUniqueMatches() {
+                BiMap<ClassIdentity,ClassIdentity> uniqueMatches = HashBiMap.create();
+                for (ClassIdentity sourceClass : m_sourceClasses.keySet()) {
+                        Collection<ClassIdentity> matchedSourceClasses = m_sourceClasses.get(sourceClass);
+                        Collection<ClassIdentity> matchedDestClasses = m_matchedDestClasses.get(sourceClass);
+                        if (matchedSourceClasses.size() == 1 && matchedDestClasses.size() == 1) {
+                                ClassIdentity matchedSourceClass = matchedSourceClasses.iterator().next();
+                                ClassIdentity matchedDestClass = matchedDestClasses.iterator().next();
+                                uniqueMatches.put(matchedSourceClass, matchedDestClass);
+                        }
+                }
+                return uniqueMatches;
+        }
+        
+        public BiMap<List<ClassIdentity>,List<ClassIdentity>> getAmbiguousMatches() {
+                BiMap<List<ClassIdentity>,List<ClassIdentity>> ambiguousMatches = HashBiMap.create();
+                for (ClassIdentity sourceClass : m_sourceClasses.keySet()) {
+                        Collection<ClassIdentity> matchedSourceClasses = m_sourceClasses.get(sourceClass);
+                        Collection<ClassIdentity> matchedDestClasses = m_matchedDestClasses.get(sourceClass);
+                        if (matchedSourceClasses.size() > 1 && matchedDestClasses.size() > 1) {
+                                ambiguousMatches.put(
+                                        new ArrayList<ClassIdentity>(matchedSourceClasses),
+                                        new ArrayList<ClassIdentity>(matchedDestClasses)
+                                );
+                        }
+                }
+                return ambiguousMatches;
+        }
+        
+        public int getNumAmbiguousSourceMatches() {
+                int num = 0;
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : getAmbiguousMatches().entrySet()) {
+                        num += entry.getKey().size();
+                }
+                return num;
+        }
+        
+        public int getNumAmbiguousDestMatches() {
+                int num = 0;
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : getAmbiguousMatches().entrySet()) {
+                        num += entry.getValue().size();
+                }
+                return num;
+        }
+        
+        public List<ClassIdentity> getUnmatchedSourceClasses() {
+                List<ClassIdentity> classes = Lists.newArrayList();
+                for (ClassIdentity sourceClass : getSourceClasses()) {
+                        if (m_matchedDestClasses.get(sourceClass).isEmpty()) {
+                                classes.add(sourceClass);
+                        }
+                }
+                return classes;
+        }
+        
+        public List<ClassIdentity> getUnmatchedDestClasses() {
+                return new ArrayList<ClassIdentity>(m_unmatchedDestClasses);
+        }
+        
+        public Map<String,Map.Entry<ClassIdentity,List<ClassIdentity>>> getIndex() {
+                Map<String,Map.Entry<ClassIdentity,List<ClassIdentity>>> conversion = Maps.newHashMap();
+                for (Map.Entry<ClassIdentity,ClassIdentity> entry : getUniqueMatches().entrySet()) {
+                        conversion.put(
+                                entry.getKey().getClassEntry().getName(),
+                                new AbstractMap.SimpleEntry<ClassIdentity,List<ClassIdentity>>(entry.getKey(), Arrays.asList(entry.getValue()))
+                        );
+                }
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : getAmbiguousMatches().entrySet()) {
+                        for (ClassIdentity sourceClass : entry.getKey()) {
+                                conversion.put(
+                                        sourceClass.getClassEntry().getName(),
+                                        new AbstractMap.SimpleEntry<ClassIdentity,List<ClassIdentity>>(sourceClass, entry.getValue())
+                                );
+                        }
+                }
+                for (ClassIdentity sourceClass : getUnmatchedSourceClasses()) {
+                        conversion.put(
+                                sourceClass.getClassEntry().getName(),
+                                new AbstractMap.SimpleEntry<ClassIdentity,List<ClassIdentity>>(sourceClass, getUnmatchedDestClasses())
+                        );
+                }
+                return conversion;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append(String.format("%12s%8s%8s\n", "", "Source", "Dest"));
+                buf.append(String.format("%12s%8d%8d\n", "Classes", getSourceClasses().size(), getDestClasses().size()));
+                buf.append(String.format("%12s%8d%8d\n", "Unique", getUniqueMatches().size(), getUniqueMatches().size()));
+                buf.append(String.format("%12s%8d%8d\n", "Ambiguous", getNumAmbiguousSourceMatches(), getNumAmbiguousDestMatches()));
+                buf.append(String.format("%12s%8d%8d\n", "Unmatched", getUnmatchedSourceClasses().size(), getUnmatchedDestClasses().size()));
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/convert/ClassNamer.java b/src/cuchaz/enigma/convert/ClassNamer.java
new file mode 100644
index 00000000..1b6e81c8
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassNamer.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.util.Map;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.Maps;
+
+public class ClassNamer {
+        
+        public interface SidedClassNamer {
+                String getName(String name);
+        }
+        
+        private Map<String,String> m_sourceNames;
+        private Map<String,String> m_destNames;
+        
+        public ClassNamer(BiMap<ClassIdentity,ClassIdentity> mappings) {
+                // convert the identity mappings to name maps
+                m_sourceNames = Maps.newHashMap();
+                m_destNames = Maps.newHashMap();
+                int i = 0;
+                for (Map.Entry<ClassIdentity,ClassIdentity> entry : mappings.entrySet()) {
+                        String name = String.format("M%04d", i++);
+                        m_sourceNames.put(entry.getKey().getClassEntry().getName(), name);
+                        m_destNames.put(entry.getValue().getClassEntry().getName(), name);
+                }
+        }
+        
+        public String getSourceName(String name) {
+                return m_sourceNames.get(name);
+        }
+        
+        public String getDestName(String name) {
+                return m_destNames.get(name);
+        }
+        
+        public SidedClassNamer getSourceNamer() {
+                return new SidedClassNamer() {
+                        @Override
+                        public String getName(String name) {
+                                return getSourceName(name);
+                        }
+                };
+        }
+        
+        public SidedClassNamer getDestNamer() {
+                return new SidedClassNamer() {
+                        @Override
+                        public String getName(String name) {
+                                return getDestName(name);
+                        }
+                };
+        }
+}
diff --git a/src/cuchaz/enigma/gui/AboutDialog.java b/src/cuchaz/enigma/gui/AboutDialog.java
new file mode 100644
index 00000000..2476b564
--- /dev/null
+++ b/src/cuchaz/enigma/gui/AboutDialog.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.Cursor;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.IOException;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.WindowConstants;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.Util;
+
+public class AboutDialog {
+        
+        public static void show(JFrame parent) {
+                // init frame
+                final JFrame frame = new JFrame(Constants.Name + " - About");
+                final Container pane = frame.getContentPane();
+                pane.setLayout(new FlowLayout());
+                
+                // load the content
+                try {
+                        String html = Util.readResourceToString("/about.html");
+                        html = String.format(html, Constants.Name, Constants.Version);
+                        JLabel label = new JLabel(html);
+                        label.setHorizontalAlignment(JLabel.CENTER);
+                        pane.add(label);
+                } catch (IOException ex) {
+                        throw new Error(ex);
+                }
+                
+                // show the link
+                String html = "<html><a href=\"%s\">%s</a></html>";
+                html = String.format(html, Constants.Url, Constants.Url);
+                JButton link = new JButton(html);
+                link.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent event) {
+                                Util.openUrl(Constants.Url);
+                        }
+                });
+                link.setBorderPainted(false);
+                link.setOpaque(false);
+                link.setBackground(Color.WHITE);
+                link.setCursor(new Cursor(Cursor.HAND_CURSOR));
+                link.setFocusable(false);
+                JPanel linkPanel = new JPanel();
+                linkPanel.add(link);
+                pane.add(linkPanel);
+                
+                // show ok button
+                JButton okButton = new JButton("Ok");
+                pane.add(okButton);
+                okButton.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent arg0) {
+                                frame.dispose();
+                        }
+                });
+                
+                // show the frame
+                pane.doLayout();
+                frame.setSize(400, 220);
+                frame.setResizable(false);
+                frame.setLocationRelativeTo(parent);
+                frame.setVisible(true);
+                frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/BoxHighlightPainter.java b/src/cuchaz/enigma/gui/BoxHighlightPainter.java
new file mode 100644
index 00000000..db7c85b4
--- /dev/null
+++ b/src/cuchaz/enigma/gui/BoxHighlightPainter.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+import java.awt.Shape;
+
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Highlighter;
+import javax.swing.text.JTextComponent;
+
+public abstract class BoxHighlightPainter implements Highlighter.HighlightPainter {
+        
+        private Color m_fillColor;
+        private Color m_borderColor;
+        
+        protected BoxHighlightPainter(Color fillColor, Color borderColor) {
+                m_fillColor = fillColor;
+                m_borderColor = borderColor;
+        }
+        
+        @Override
+        public void paint(Graphics g, int start, int end, Shape shape, JTextComponent text) {
+                Rectangle bounds = getBounds(text, start, end);
+                
+                // fill the area
+                if (m_fillColor != null) {
+                        g.setColor(m_fillColor);
+                        g.fillRoundRect(bounds.x, bounds.y, bounds.width, bounds.height, 4, 4);
+                }
+                
+                // draw a box around the area
+                g.setColor(m_borderColor);
+                g.drawRoundRect(bounds.x, bounds.y, bounds.width, bounds.height, 4, 4);
+        }
+        
+        protected static Rectangle getBounds(JTextComponent text, int start, int end) {
+                try {
+                        // determine the bounds of the text
+                        Rectangle bounds = text.modelToView(start).union(text.modelToView(end));
+                        
+                        // adjust the box so it looks nice
+                        bounds.x -= 2;
+                        bounds.width += 2;
+                        bounds.y += 1;
+                        bounds.height -= 2;
+                        
+                        return bounds;
+                } catch (BadLocationException ex) {
+                        // don't care... just return something
+                        return new Rectangle(0, 0, 0, 0);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/gui/BrowserCaret.java b/src/cuchaz/enigma/gui/BrowserCaret.java
new file mode 100644
index 00000000..acee4833
--- /dev/null
+++ b/src/cuchaz/enigma/gui/BrowserCaret.java
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Graphics;
+import java.awt.Shape;
+
+import javax.swing.text.DefaultCaret;
+import javax.swing.text.Highlighter;
+import javax.swing.text.JTextComponent;
+
+public class BrowserCaret extends DefaultCaret {
+        
+        private static final long serialVersionUID = 1158977422507969940L;
+        
+        private static final Highlighter.HighlightPainter m_selectionPainter = new Highlighter.HighlightPainter() {
+                @Override
+                public void paint(Graphics g, int p0, int p1, Shape bounds, JTextComponent c) {
+                        // don't paint anything
+                }
+        };
+        
+        @Override
+        public boolean isSelectionVisible() {
+                return false;
+        }
+        
+        @Override
+        public boolean isVisible() {
+                return true;
+        }
+        
+        @Override
+        public Highlighter.HighlightPainter getSelectionPainter() {
+                return m_selectionPainter;
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ClassListCellRenderer.java b/src/cuchaz/enigma/gui/ClassListCellRenderer.java
new file mode 100644
index 00000000..d0f01e6a
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassListCellRenderer.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Component;
+
+import javassist.bytecode.Descriptor;
+
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.ListCellRenderer;
+
+public class ClassListCellRenderer implements ListCellRenderer<String> {
+        
+        private DefaultListCellRenderer m_defaultRenderer;
+        
+        public ClassListCellRenderer() {
+                m_defaultRenderer = new DefaultListCellRenderer();
+        }
+        
+        @Override
+        public Component getListCellRendererComponent(JList<? extends String> list, String className, int index, boolean isSelected, boolean hasFocus) {
+                JLabel label = (JLabel)m_defaultRenderer.getListCellRendererComponent(list, className, index, isSelected, hasFocus);
+                label.setText(Descriptor.toJavaName(className));
+                return label;
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ClassSelector.java b/src/cuchaz/enigma/gui/ClassSelector.java
new file mode 100644
index 00000000..654bfbed
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassSelector.java
@@ -0,0 +1,164 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class ClassSelector extends JTree {
+        
+        private static final long serialVersionUID = -7632046902384775977L;
+        
+        public interface ClassSelectionListener {
+                void onSelectClass(ClassEntry classEntry);
+        }
+        
+        public static Comparator<ClassEntry> ObfuscatedClassEntryComparator;
+        public static Comparator<ClassEntry> DeobfuscatedClassEntryComparator;
+        
+        static {
+                ObfuscatedClassEntryComparator = new Comparator<ClassEntry>() {
+                        @Override
+                        public int compare(ClassEntry a, ClassEntry b) {
+                                if (a.getName().length() != b.getName().length()) {
+                                        return a.getName().length() - b.getName().length();
+                                }
+                                return a.getName().compareTo(b.getName());
+                        }
+                };
+                
+                DeobfuscatedClassEntryComparator = new Comparator<ClassEntry>() {
+                        @Override
+                        public int compare(ClassEntry a, ClassEntry b) {
+                                return a.getName().compareTo(b.getName());
+                        }
+                };
+        }
+        
+        private ClassSelectionListener m_listener;
+        private Comparator<ClassEntry> m_comparator;
+        
+        public ClassSelector(Comparator<ClassEntry> comparator) {
+                m_comparator = comparator;
+                
+                // configure the tree control
+                setRootVisible(false);
+                setShowsRootHandles(false);
+                setModel(null);
+                
+                // hook events
+                addMouseListener(new MouseAdapter() {
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (m_listener != null && event.getClickCount() == 2) {
+                                        // get the selected node
+                                        TreePath path = getSelectionPath();
+                                        if (path != null && path.getLastPathComponent() instanceof ClassSelectorClassNode) {
+                                                ClassSelectorClassNode node = (ClassSelectorClassNode)path.getLastPathComponent();
+                                                m_listener.onSelectClass(node.getClassEntry());
+                                        }
+                                }
+                        }
+                });
+                
+                // init defaults
+                m_listener = null;
+        }
+        
+        public void setListener(ClassSelectionListener val) {
+                m_listener = val;
+        }
+        
+        public void setClasses(Collection<ClassEntry> classEntries) {
+                if (classEntries == null) {
+                        setModel(null);
+                        return;
+                }
+                
+                // build the package names
+                Map<String,ClassSelectorPackageNode> packages = Maps.newHashMap();
+                for (ClassEntry classEntry : classEntries) {
+                        packages.put(classEntry.getPackageName(), null);
+                }
+                
+                // sort the packages
+                List<String> sortedPackageNames = Lists.newArrayList(packages.keySet());
+                Collections.sort(sortedPackageNames, new Comparator<String>() {
+                        @Override
+                        public int compare(String a, String b) {
+                                // I can never keep this rule straight when writing these damn things...
+                                // a < b => -1, a == b => 0, a > b => +1
+                                
+                                String[] aparts = a.split("/");
+                                String[] bparts = b.split("/");
+                                for (int i = 0; true; i++) {
+                                        if (i >= aparts.length) {
+                                                return -1;
+                                        } else if (i >= bparts.length) {
+                                                return 1;
+                                        }
+                                        
+                                        int result = aparts[i].compareTo(bparts[i]);
+                                        if (result != 0) {
+                                                return result;
+                                        }
+                                }
+                        }
+                });
+                
+                // create the root node and the package nodes
+                DefaultMutableTreeNode root = new DefaultMutableTreeNode();
+                for (String packageName : sortedPackageNames) {
+                        ClassSelectorPackageNode node = new ClassSelectorPackageNode(packageName);
+                        packages.put(packageName, node);
+                        root.add(node);
+                }
+                
+                // put the classes into packages
+                Multimap<String,ClassEntry> packagedClassEntries = ArrayListMultimap.create();
+                for (ClassEntry classEntry : classEntries) {
+                        packagedClassEntries.put(classEntry.getPackageName(), classEntry);
+                }
+                
+                // build the class nodes
+                for (String packageName : packagedClassEntries.keySet()) {
+                        // sort the class entries
+                        List<ClassEntry> classEntriesInPackage = Lists.newArrayList(packagedClassEntries.get(packageName));
+                        Collections.sort(classEntriesInPackage, m_comparator);
+                        
+                        // create the nodes in order
+                        for (ClassEntry classEntry : classEntriesInPackage) {
+                                ClassSelectorPackageNode node = packages.get(packageName);
+                                node.add(new ClassSelectorClassNode(classEntry));
+                        }
+                }
+                
+                // finally, update the tree control
+                setModel(new DefaultTreeModel(root));
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ClassSelectorClassNode.java b/src/cuchaz/enigma/gui/ClassSelectorClassNode.java
new file mode 100644
index 00000000..66e931b4
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassSelectorClassNode.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class ClassSelectorClassNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = -8956754339813257380L;
+        
+        private ClassEntry m_classEntry;
+        
+        public ClassSelectorClassNode(ClassEntry classEntry) {
+                m_classEntry = classEntry;
+        }
+        
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String toString() {
+                return m_classEntry.getSimpleName();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ClassSelectorPackageNode.java b/src/cuchaz/enigma/gui/ClassSelectorPackageNode.java
new file mode 100644
index 00000000..451d3809
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassSelectorPackageNode.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+public class ClassSelectorPackageNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = -3730868701219548043L;
+        
+        private String m_packageName;
+        
+        public ClassSelectorPackageNode(String packageName) {
+                m_packageName = packageName;
+        }
+        
+        public String getPackageName() {
+                return m_packageName;
+        }
+        
+        @Override
+        public String toString() {
+                return m_packageName;
+        }
+}
diff --git a/src/cuchaz/enigma/gui/CrashDialog.java b/src/cuchaz/enigma/gui/CrashDialog.java
new file mode 100644
index 00000000..360091ab
--- /dev/null
+++ b/src/cuchaz/enigma/gui/CrashDialog.java
@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.WindowConstants;
+
+import cuchaz.enigma.Constants;
+
+public class CrashDialog {
+        
+        private static CrashDialog m_instance = null;
+        
+        private JFrame m_frame;
+        private JTextArea m_text;
+        
+        private CrashDialog(JFrame parent) {
+                // init frame
+                m_frame = new JFrame(Constants.Name + " - Crash Report");
+                final Container pane = m_frame.getContentPane();
+                pane.setLayout(new BorderLayout());
+                
+                JLabel label = new JLabel(Constants.Name + " has crashed! =(");
+                label.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+                pane.add(label, BorderLayout.NORTH);
+                
+                // report panel
+                m_text = new JTextArea();
+                m_text.setTabSize(2);
+                pane.add(new JScrollPane(m_text), BorderLayout.CENTER);
+                
+                // buttons panel
+                JPanel buttonsPanel = new JPanel();
+                FlowLayout buttonsLayout = new FlowLayout();
+                buttonsLayout.setAlignment(FlowLayout.RIGHT);
+                buttonsPanel.setLayout(buttonsLayout);
+                buttonsPanel.add(GuiTricks.unboldLabel(new JLabel("If you choose exit, you will lose any unsaved work.")));
+                JButton ignoreButton = new JButton("Ignore");
+                ignoreButton.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent event) {
+                                // close (hide) the dialog
+                                m_frame.setVisible(false);
+                        }
+                });
+                buttonsPanel.add(ignoreButton);
+                JButton exitButton = new JButton("Exit");
+                exitButton.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent event) {
+                                // exit enigma
+                                System.exit(1);
+                        }
+                });
+                buttonsPanel.add(exitButton);
+                pane.add(buttonsPanel, BorderLayout.SOUTH);
+                
+                // show the frame
+                m_frame.setSize(600, 400);
+                m_frame.setLocationRelativeTo(parent);
+                m_frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        }
+        
+        public static void init(JFrame parent) {
+                m_instance = new CrashDialog(parent);
+        }
+        
+        public static void show(Throwable ex) {
+                // get the error report
+                StringWriter buf = new StringWriter();
+                ex.printStackTrace(new PrintWriter(buf));
+                String report = buf.toString();
+                
+                // show it!
+                m_instance.m_text.setText(report);
+                m_instance.m_frame.doLayout();
+                m_instance.m_frame.setVisible(true);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/DeobfuscatedHighlightPainter.java b/src/cuchaz/enigma/gui/DeobfuscatedHighlightPainter.java
new file mode 100644
index 00000000..26a31639
--- /dev/null
+++ b/src/cuchaz/enigma/gui/DeobfuscatedHighlightPainter.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+
+public class DeobfuscatedHighlightPainter extends BoxHighlightPainter {
+        
+        public DeobfuscatedHighlightPainter() {
+                // green ish
+                super(new Color(220, 255, 220), new Color(80, 160, 80));
+        }
+}
diff --git a/src/cuchaz/enigma/gui/Gui.java b/src/cuchaz/enigma/gui/Gui.java
new file mode 100644
index 00000000..ca39c42a
--- /dev/null
+++ b/src/cuchaz/enigma/gui/Gui.java
@@ -0,0 +1,1165 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+import java.awt.Rectangle;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.File;
+import java.io.IOException;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Vector;
+import java.util.jar.JarFile;
+
+import javax.swing.BorderFactory;
+import javax.swing.JEditorPane;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextField;
+import javax.swing.JTree;
+import javax.swing.KeyStroke;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingUtilities;
+import javax.swing.Timer;
+import javax.swing.WindowConstants;
+import javax.swing.event.CaretEvent;
+import javax.swing.event.CaretListener;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Highlighter;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreeNode;
+import javax.swing.tree.TreePath;
+
+import jsyntaxpane.DefaultSyntaxKit;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.analysis.BehaviorReferenceTreeNode;
+import cuchaz.enigma.analysis.ClassImplementationsTreeNode;
+import cuchaz.enigma.analysis.ClassInheritanceTreeNode;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.FieldReferenceTreeNode;
+import cuchaz.enigma.analysis.MethodImplementationsTreeNode;
+import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
+import cuchaz.enigma.analysis.ReferenceTreeNode;
+import cuchaz.enigma.analysis.Token;
+import cuchaz.enigma.gui.ClassSelector.ClassSelectionListener;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.IllegalNameException;
+import cuchaz.enigma.mapping.MappingParseException;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class Gui {
+        
+        private GuiController m_controller;
+        
+        // controls
+        private JFrame m_frame;
+        private ClassSelector m_obfClasses;
+        private ClassSelector m_deobfClasses;
+        private JEditorPane m_editor;
+        private JPanel m_classesPanel;
+        private JSplitPane m_splitClasses;
+        private JPanel m_infoPanel;
+        private ObfuscatedHighlightPainter m_obfuscatedHighlightPainter;
+        private DeobfuscatedHighlightPainter m_deobfuscatedHighlightPainter;
+        private OtherHighlightPainter m_otherHighlightPainter;
+        private SelectionHighlightPainter m_selectionHighlightPainter;
+        private JTree m_inheritanceTree;
+        private JTree m_implementationsTree;
+        private JTree m_callsTree;
+        private JList<Token> m_tokens;
+        private JTabbedPane m_tabs;
+        
+        // dynamic menu items
+        private JMenuItem m_closeJarMenu;
+        private JMenuItem m_openMappingsMenu;
+        private JMenuItem m_saveMappingsMenu;
+        private JMenuItem m_saveMappingsAsMenu;
+        private JMenuItem m_closeMappingsMenu;
+        private JMenuItem m_renameMenu;
+        private JMenuItem m_showInheritanceMenu;
+        private JMenuItem m_openEntryMenu;
+        private JMenuItem m_openPreviousMenu;
+        private JMenuItem m_showCallsMenu;
+        private JMenuItem m_showImplementationsMenu;
+        private JMenuItem m_toggleMappingMenu;
+        private JMenuItem m_exportSourceMenu;
+        private JMenuItem m_exportJarMenu;
+        
+        // state
+        private EntryReference<Entry,Entry> m_reference;
+        private JFileChooser m_jarFileChooser;
+        private JFileChooser m_mappingsFileChooser;
+        private JFileChooser m_exportSourceFileChooser;
+        private JFileChooser m_exportJarFileChooser;
+        
+        public Gui() {
+                
+                // init frame
+                m_frame = new JFrame(Constants.Name);
+                final Container pane = m_frame.getContentPane();
+                pane.setLayout(new BorderLayout());
+                
+                if (Boolean.parseBoolean(System.getProperty("enigma.catchExceptions", "true"))) {
+                        // install a global exception handler to the event thread
+                        CrashDialog.init(m_frame);
+                        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+                                @Override
+                                public void uncaughtException(Thread thread, Throwable ex) {
+                                        ex.printStackTrace(System.err);
+                                        CrashDialog.show(ex);
+                                }
+                        });
+                }
+                
+                m_controller = new GuiController(this);
+                
+                // init file choosers
+                m_jarFileChooser = new JFileChooser();
+                m_mappingsFileChooser = new JFileChooser();
+                m_exportSourceFileChooser = new JFileChooser();
+                m_exportSourceFileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+                m_exportJarFileChooser = new JFileChooser();
+                
+                // init obfuscated classes list
+                m_obfClasses = new ClassSelector(ClassSelector.ObfuscatedClassEntryComparator);
+                m_obfClasses.setListener(new ClassSelectionListener() {
+                        @Override
+                        public void onSelectClass(ClassEntry classEntry) {
+                                navigateTo(classEntry);
+                        }
+                });
+                JScrollPane obfScroller = new JScrollPane(m_obfClasses);
+                JPanel obfPanel = new JPanel();
+                obfPanel.setLayout(new BorderLayout());
+                obfPanel.add(new JLabel("Obfuscated Classes"), BorderLayout.NORTH);
+                obfPanel.add(obfScroller, BorderLayout.CENTER);
+                
+                // init deobfuscated classes list
+                m_deobfClasses = new ClassSelector(ClassSelector.DeobfuscatedClassEntryComparator);
+                m_deobfClasses.setListener(new ClassSelectionListener() {
+                        @Override
+                        public void onSelectClass(ClassEntry classEntry) {
+                                navigateTo(classEntry);
+                        }
+                });
+                JScrollPane deobfScroller = new JScrollPane(m_deobfClasses);
+                JPanel deobfPanel = new JPanel();
+                deobfPanel.setLayout(new BorderLayout());
+                deobfPanel.add(new JLabel("De-obfuscated Classes"), BorderLayout.NORTH);
+                deobfPanel.add(deobfScroller, BorderLayout.CENTER);
+                
+                // set up classes panel (don't add the splitter yet)
+                m_splitClasses = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true, obfPanel, deobfPanel);
+                m_splitClasses.setResizeWeight(0.3);
+                m_classesPanel = new JPanel();
+                m_classesPanel.setLayout(new BorderLayout());
+                m_classesPanel.setPreferredSize(new Dimension(250, 0));
+                
+                // init info panel
+                m_infoPanel = new JPanel();
+                m_infoPanel.setLayout(new GridLayout(4, 1, 0, 0));
+                m_infoPanel.setPreferredSize(new Dimension(0, 100));
+                m_infoPanel.setBorder(BorderFactory.createTitledBorder("Identifier Info"));
+                clearReference();
+                
+                // init editor
+                DefaultSyntaxKit.initKit();
+                m_obfuscatedHighlightPainter = new ObfuscatedHighlightPainter();
+                m_deobfuscatedHighlightPainter = new DeobfuscatedHighlightPainter();
+                m_otherHighlightPainter = new OtherHighlightPainter();
+                m_selectionHighlightPainter = new SelectionHighlightPainter();
+                m_editor = new JEditorPane();
+                m_editor.setEditable(false);
+                m_editor.setCaret(new BrowserCaret());
+                JScrollPane sourceScroller = new JScrollPane(m_editor);
+                m_editor.setContentType("text/java");
+                m_editor.addCaretListener(new CaretListener() {
+                        @Override
+                        public void caretUpdate(CaretEvent event) {
+                                onCaretMove(event.getDot());
+                        }
+                });
+                m_editor.addKeyListener(new KeyAdapter() {
+                        @Override
+                        public void keyPressed(KeyEvent event) {
+                                switch (event.getKeyCode()) {
+                                        case KeyEvent.VK_R:
+                                                m_renameMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_I:
+                                                m_showInheritanceMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_M:
+                                                m_showImplementationsMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_N:
+                                                m_openEntryMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_P:
+                                                m_openPreviousMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_C:
+                                                m_showCallsMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_T:
+                                                m_toggleMappingMenu.doClick();
+                                        break;
+                                }
+                        }
+                });
+                
+                // turn off token highlighting (it's wrong most of the time anyway...)
+                DefaultSyntaxKit kit = (DefaultSyntaxKit)m_editor.getEditorKit();
+                kit.toggleComponent(m_editor, "jsyntaxpane.components.TokenMarker");
+                
+                // init editor popup menu
+                JPopupMenu popupMenu = new JPopupMenu();
+                m_editor.setComponentPopupMenu(popupMenu);
+                {
+                        JMenuItem menu = new JMenuItem("Rename");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        startRename();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_renameMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Show Inheritance");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        showInheritance();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_showInheritanceMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Show Implementations");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        showImplementations();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_showImplementationsMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Show Calls");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        showCalls();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_showCallsMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Go to Declaration");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        navigateTo(m_reference.entry);
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_openEntryMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Go to previous");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        m_controller.openPreviousReference();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_openPreviousMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Mark as deobfuscated");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        toggleMapping();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_toggleMappingMenu = menu;
+                }
+                
+                // init inheritance panel
+                m_inheritanceTree = new JTree();
+                m_inheritanceTree.setModel(null);
+                m_inheritanceTree.addMouseListener(new MouseAdapter() {
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (event.getClickCount() == 2) {
+                                        // get the selected node
+                                        TreePath path = m_inheritanceTree.getSelectionPath();
+                                        if (path == null) {
+                                                return;
+                                        }
+                                        
+                                        Object node = path.getLastPathComponent();
+                                        if (node instanceof ClassInheritanceTreeNode) {
+                                                ClassInheritanceTreeNode classNode = (ClassInheritanceTreeNode)node;
+                                                navigateTo(new ClassEntry(classNode.getObfClassName()));
+                                        } else if (node instanceof MethodInheritanceTreeNode) {
+                                                MethodInheritanceTreeNode methodNode = (MethodInheritanceTreeNode)node;
+                                                if (methodNode.isImplemented()) {
+                                                        navigateTo(methodNode.getMethodEntry());
+                                                }
+                                        }
+                                }
+                        }
+                });
+                JPanel inheritancePanel = new JPanel();
+                inheritancePanel.setLayout(new BorderLayout());
+                inheritancePanel.add(new JScrollPane(m_inheritanceTree));
+                
+                // init implementations panel
+                m_implementationsTree = new JTree();
+                m_implementationsTree.setModel(null);
+                m_implementationsTree.addMouseListener(new MouseAdapter() {
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (event.getClickCount() == 2) {
+                                        // get the selected node
+                                        TreePath path = m_implementationsTree.getSelectionPath();
+                                        if (path == null) {
+                                                return;
+                                        }
+                                        
+                                        Object node = path.getLastPathComponent();
+                                        if (node instanceof ClassImplementationsTreeNode) {
+                                                ClassImplementationsTreeNode classNode = (ClassImplementationsTreeNode)node;
+                                                navigateTo(classNode.getClassEntry());
+                                        } else if (node instanceof MethodImplementationsTreeNode) {
+                                                MethodImplementationsTreeNode methodNode = (MethodImplementationsTreeNode)node;
+                                                navigateTo(methodNode.getMethodEntry());
+                                        }
+                                }
+                        }
+                });
+                JPanel implementationsPanel = new JPanel();
+                implementationsPanel.setLayout(new BorderLayout());
+                implementationsPanel.add(new JScrollPane(m_implementationsTree));
+                
+                // init call panel
+                m_callsTree = new JTree();
+                m_callsTree.setModel(null);
+                m_callsTree.addMouseListener(new MouseAdapter() {
+                        @SuppressWarnings("unchecked")
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (event.getClickCount() == 2) {
+                                        // get the selected node
+                                        TreePath path = m_callsTree.getSelectionPath();
+                                        if (path == null) {
+                                                return;
+                                        }
+                                        
+                                        Object node = path.getLastPathComponent();
+                                        if (node instanceof ReferenceTreeNode) {
+                                                ReferenceTreeNode<Entry,Entry> referenceNode = ((ReferenceTreeNode<Entry,Entry>)node);
+                                                if (referenceNode.getReference() != null) {
+                                                        navigateTo(referenceNode.getReference());
+                                                } else {
+                                                        navigateTo(referenceNode.getEntry());
+                                                }
+                                        }
+                                }
+                        }
+                });
+                m_tokens = new JList<Token>();
+                m_tokens.setCellRenderer(new TokenListCellRenderer(m_controller));
+                m_tokens.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+                m_tokens.setLayoutOrientation(JList.VERTICAL);
+                m_tokens.addMouseListener(new MouseAdapter() {
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (event.getClickCount() == 2) {
+                                        Token selected = m_tokens.getSelectedValue();
+                                        if (selected != null) {
+                                                showToken(selected);
+                                        }
+                                }
+                        }
+                });
+                m_tokens.setPreferredSize(new Dimension(0, 200));
+                m_tokens.setMinimumSize(new Dimension(0, 200));
+                JSplitPane callPanel = new JSplitPane(
+                        JSplitPane.VERTICAL_SPLIT,
+                        true,
+                        new JScrollPane(m_callsTree),
+                        new JScrollPane(m_tokens)
+                );
+                callPanel.setResizeWeight(1); // let the top side take all the slack
+                callPanel.resetToPreferredSizes();
+                
+                // layout controls
+                JPanel centerPanel = new JPanel();
+                centerPanel.setLayout(new BorderLayout());
+                centerPanel.add(m_infoPanel, BorderLayout.NORTH);
+                centerPanel.add(sourceScroller, BorderLayout.CENTER);
+                m_tabs = new JTabbedPane();
+                m_tabs.setPreferredSize(new Dimension(250, 0));
+                m_tabs.addTab("Inheritance", inheritancePanel);
+                m_tabs.addTab("Implementations", implementationsPanel);
+                m_tabs.addTab("Call Graph", callPanel);
+                JSplitPane splitRight = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, centerPanel, m_tabs);
+                splitRight.setResizeWeight(1); // let the left side take all the slack
+                splitRight.resetToPreferredSizes();
+                JSplitPane splitCenter = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, m_classesPanel, splitRight);
+                splitCenter.setResizeWeight(0); // let the right side take all the slack
+                pane.add(splitCenter, BorderLayout.CENTER);
+                
+                // init menus
+                JMenuBar menuBar = new JMenuBar();
+                m_frame.setJMenuBar(menuBar);
+                {
+                        JMenu menu = new JMenu("File");
+                        menuBar.add(menu);
+                        {
+                                JMenuItem item = new JMenuItem("Open Jar...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_jarFileChooser.showOpenDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        // load the jar in a separate thread
+                                                        new Thread() {
+                                                                @Override
+                                                                public void run() {
+                                                                        try {
+                                                                                m_controller.openJar(new JarFile(m_jarFileChooser.getSelectedFile()));
+                                                                        } catch (IOException ex) {
+                                                                                throw new Error(ex);
+                                                                        }
+                                                                }
+                                                        }.start();
+                                                }
+                                        }
+                                });
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Close Jar");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                m_controller.closeJar();
+                                        }
+                                });
+                                m_closeJarMenu = item;
+                        }
+                        menu.addSeparator();
+                        {
+                                JMenuItem item = new JMenuItem("Open Mappings...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_mappingsFileChooser.showOpenDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        try {
+                                                                m_controller.openMappings(m_mappingsFileChooser.getSelectedFile());
+                                                        } catch (IOException ex) {
+                                                                throw new Error(ex);
+                                                        } catch (MappingParseException ex) {
+                                                                JOptionPane.showMessageDialog(m_frame, ex.getMessage());
+                                                        }
+                                                }
+                                        }
+                                });
+                                m_openMappingsMenu = item;
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Save Mappings");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                try {
+                                                        m_controller.saveMappings(m_mappingsFileChooser.getSelectedFile());
+                                                } catch (IOException ex) {
+                                                        throw new Error(ex);
+                                                }
+                                        }
+                                });
+                                item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK));
+                                m_saveMappingsMenu = item;
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Save Mappings As...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_mappingsFileChooser.showSaveDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        try {
+                                                                m_controller.saveMappings(m_mappingsFileChooser.getSelectedFile());
+                                                                m_saveMappingsMenu.setEnabled(true);
+                                                        } catch (IOException ex) {
+                                                                throw new Error(ex);
+                                                        }
+                                                }
+                                        }
+                                });
+                                item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK));
+                                m_saveMappingsAsMenu = item;
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Close Mappings");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                m_controller.closeMappings();
+                                        }
+                                });
+                                m_closeMappingsMenu = item;
+                        }
+                        menu.addSeparator();
+                        {
+                                JMenuItem item = new JMenuItem("Export Source...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_exportSourceFileChooser.showSaveDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        m_controller.exportSource(m_exportSourceFileChooser.getSelectedFile());
+                                                }
+                                        }
+                                });
+                                m_exportSourceMenu = item;
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Export Jar...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_exportJarFileChooser.showSaveDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        m_controller.exportJar(m_exportJarFileChooser.getSelectedFile());
+                                                }
+                                        }
+                                });
+                                m_exportJarMenu = item;
+                        }
+                        menu.addSeparator();
+                        {
+                                JMenuItem item = new JMenuItem("Exit");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                close();
+                                        }
+                                });
+                        }
+                }
+                {
+                        JMenu menu = new JMenu("Help");
+                        menuBar.add(menu);
+                        {
+                                JMenuItem item = new JMenuItem("About");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                AboutDialog.show(m_frame);
+                                        }
+                                });
+                        }
+                }
+                
+                // init state
+                onCloseJar();
+                
+                m_frame.addWindowListener(new WindowAdapter() {
+                        @Override
+                        public void windowClosing(WindowEvent event) {
+                                close();
+                        }
+                });
+                
+                // show the frame
+                pane.doLayout();
+                m_frame.setSize(1024, 576);
+                m_frame.setMinimumSize(new Dimension(640, 480));
+                m_frame.setVisible(true);
+                m_frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        }
+        
+        public JFrame getFrame() {
+                return m_frame;
+        }
+        
+        public GuiController getController() {
+                return m_controller;
+        }
+        
+        public void onStartOpenJar() {
+                m_classesPanel.removeAll();
+                JPanel panel = new JPanel();
+                panel.setLayout(new FlowLayout());
+                panel.add(new JLabel("Loading..."));
+                m_classesPanel.add(panel);
+                redraw();
+        }
+        
+        public void onFinishOpenJar(String jarName) {
+                // update gui
+                m_frame.setTitle(Constants.Name + " - " + jarName);
+                m_classesPanel.removeAll();
+                m_classesPanel.add(m_splitClasses);
+                setSource(null);
+                
+                // update menu
+                m_closeJarMenu.setEnabled(true);
+                m_openMappingsMenu.setEnabled(true);
+                m_saveMappingsMenu.setEnabled(false);
+                m_saveMappingsAsMenu.setEnabled(true);
+                m_closeMappingsMenu.setEnabled(true);
+                m_exportSourceMenu.setEnabled(true);
+                m_exportJarMenu.setEnabled(true);
+                
+                redraw();
+        }
+        
+        public void onCloseJar() {
+                // update gui
+                m_frame.setTitle(Constants.Name);
+                setObfClasses(null);
+                setDeobfClasses(null);
+                setSource(null);
+                m_classesPanel.removeAll();
+                
+                // update menu
+                m_closeJarMenu.setEnabled(false);
+                m_openMappingsMenu.setEnabled(false);
+                m_saveMappingsMenu.setEnabled(false);
+                m_saveMappingsAsMenu.setEnabled(false);
+                m_closeMappingsMenu.setEnabled(false);
+                m_exportSourceMenu.setEnabled(false);
+                m_exportJarMenu.setEnabled(false);
+                
+                redraw();
+        }
+        
+        public void setObfClasses(Collection<ClassEntry> obfClasses) {
+                m_obfClasses.setClasses(obfClasses);
+        }
+        
+        public void setDeobfClasses(Collection<ClassEntry> deobfClasses) {
+                m_deobfClasses.setClasses(deobfClasses);
+        }
+        
+        public void setMappingsFile(File file) {
+                m_mappingsFileChooser.setSelectedFile(file);
+                m_saveMappingsMenu.setEnabled(file != null);
+        }
+        
+        public void setSource(String source) {
+                m_editor.getHighlighter().removeAllHighlights();
+                m_editor.setText(source);
+        }
+        
+        public void showToken(final Token token) {
+                if (token == null) {
+                        throw new IllegalArgumentException("Token cannot be null!");
+                }
+                
+                // set the caret position to the token
+                m_editor.setCaretPosition(token.start);
+                m_editor.grabFocus();
+                
+                try {
+                        // make sure the token is visible in the scroll window
+                        Rectangle start = m_editor.modelToView(token.start);
+                        Rectangle end = m_editor.modelToView(token.end);
+                        final Rectangle show = start.union(end);
+                        show.grow(start.width * 10, start.height * 6);
+                        SwingUtilities.invokeLater(new Runnable() {
+                                @Override
+                                public void run() {
+                                        m_editor.scrollRectToVisible(show);
+                                }
+                        });
+                } catch (BadLocationException ex) {
+                        throw new Error(ex);
+                }
+                
+                // highlight the token momentarily
+                final Timer timer = new Timer(200, new ActionListener() {
+                        private int m_counter = 0;
+                        private Object m_highlight = null;
+                        
+                        @Override
+                        public void actionPerformed(ActionEvent event) {
+                                if (m_counter % 2 == 0) {
+                                        try {
+                                                m_highlight = m_editor.getHighlighter().addHighlight(token.start, token.end, m_selectionHighlightPainter);
+                                        } catch (BadLocationException ex) {
+                                                // don't care
+                                        }
+                                } else if (m_highlight != null) {
+                                        m_editor.getHighlighter().removeHighlight(m_highlight);
+                                }
+                                
+                                if (m_counter++ > 6) {
+                                        Timer timer = (Timer)event.getSource();
+                                        timer.stop();
+                                }
+                        }
+                });
+                timer.start();
+                
+                redraw();
+        }
+        
+        public void showTokens(Collection<Token> tokens) {
+                Vector<Token> sortedTokens = new Vector<Token>(tokens);
+                Collections.sort(sortedTokens);
+                if (sortedTokens.size() > 1) {
+                        // sort the tokens and update the tokens panel
+                        m_tokens.setListData(sortedTokens);
+                        m_tokens.setSelectedIndex(0);
+                } else {
+                        m_tokens.setListData(new Vector<Token>());
+                }
+                
+                // show the first token
+                showToken(sortedTokens.get(0));
+        }
+        
+        public void setHighlightedTokens(Iterable<Token> obfuscatedTokens, Iterable<Token> deobfuscatedTokens, Iterable<Token> otherTokens) {
+                
+                // remove any old highlighters
+                m_editor.getHighlighter().removeAllHighlights();
+                
+                // color things based on the index
+                if (obfuscatedTokens != null) {
+                        setHighlightedTokens(obfuscatedTokens, m_obfuscatedHighlightPainter);
+                }
+                if (deobfuscatedTokens != null) {
+                        setHighlightedTokens(deobfuscatedTokens, m_deobfuscatedHighlightPainter);
+                }
+                if (otherTokens != null) {
+                        setHighlightedTokens(otherTokens, m_otherHighlightPainter);
+                }
+                
+                redraw();
+        }
+        
+        private void setHighlightedTokens(Iterable<Token> tokens, Highlighter.HighlightPainter painter) {
+                for (Token token : tokens) {
+                        try {
+                                m_editor.getHighlighter().addHighlight(token.start, token.end, painter);
+                        } catch (BadLocationException ex) {
+                                throw new IllegalArgumentException(ex);
+                        }
+                }
+        }
+        
+        private void clearReference() {
+                m_infoPanel.removeAll();
+                JLabel label = new JLabel("No identifier selected");
+                GuiTricks.unboldLabel(label);
+                label.setHorizontalAlignment(JLabel.CENTER);
+                m_infoPanel.add(label);
+                
+                redraw();
+        }
+        
+        private void showReference(EntryReference<Entry,Entry> reference) {
+                if (reference == null) {
+                        clearReference();
+                        return;
+                }
+                
+                m_reference = reference;
+                
+                m_infoPanel.removeAll();
+                if (reference.entry instanceof ClassEntry) {
+                        showClassEntry((ClassEntry)m_reference.entry);
+                } else if (m_reference.entry instanceof FieldEntry) {
+                        showFieldEntry((FieldEntry)m_reference.entry);
+                } else if (m_reference.entry instanceof MethodEntry) {
+                        showMethodEntry((MethodEntry)m_reference.entry);
+                } else if (m_reference.entry instanceof ConstructorEntry) {
+                        showConstructorEntry((ConstructorEntry)m_reference.entry);
+                } else if (m_reference.entry instanceof ArgumentEntry) {
+                        showArgumentEntry((ArgumentEntry)m_reference.entry);
+                } else {
+                        throw new Error("Unknown entry type: " + m_reference.entry.getClass().getName());
+                }
+                
+                redraw();
+        }
+        
+        private void showClassEntry(ClassEntry entry) {
+                addNameValue(m_infoPanel, "Class", entry.getName());
+        }
+        
+        private void showFieldEntry(FieldEntry entry) {
+                addNameValue(m_infoPanel, "Field", entry.getName());
+                addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
+        }
+        
+        private void showMethodEntry(MethodEntry entry) {
+                addNameValue(m_infoPanel, "Method", entry.getName());
+                addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
+                addNameValue(m_infoPanel, "Signature", entry.getSignature().toString());
+        }
+        
+        private void showConstructorEntry(ConstructorEntry entry) {
+                addNameValue(m_infoPanel, "Constructor", entry.getClassEntry().getName());
+                addNameValue(m_infoPanel, "Signature", entry.getSignature().toString());
+        }
+        
+        private void showArgumentEntry(ArgumentEntry entry) {
+                addNameValue(m_infoPanel, "Argument", entry.getName());
+                addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
+                addNameValue(m_infoPanel, "Method", entry.getBehaviorEntry().getName());
+                addNameValue(m_infoPanel, "Index", Integer.toString(entry.getIndex()));
+        }
+        
+        private void addNameValue(JPanel container, String name, String value) {
+                JPanel panel = new JPanel();
+                panel.setLayout(new FlowLayout(FlowLayout.LEFT, 6, 0));
+                container.add(panel);
+                
+                JLabel label = new JLabel(name + ":", JLabel.RIGHT);
+                label.setPreferredSize(new Dimension(100, label.getPreferredSize().height));
+                panel.add(label);
+                
+                panel.add(GuiTricks.unboldLabel(new JLabel(value, JLabel.LEFT)));
+        }
+        
+        private void onCaretMove(int pos) {
+                
+                Token token = m_controller.getToken(pos);
+                boolean isToken = token != null;
+                
+                m_reference = m_controller.getDeobfReference(token);
+                boolean isClassEntry = isToken && m_reference.entry instanceof ClassEntry;
+                boolean isFieldEntry = isToken && m_reference.entry instanceof FieldEntry;
+                boolean isMethodEntry = isToken && m_reference.entry instanceof MethodEntry;
+                boolean isConstructorEntry = isToken && m_reference.entry instanceof ConstructorEntry;
+                boolean isInJar = isToken && m_controller.entryIsInJar(m_reference.entry);
+                boolean isRenameable = isToken && m_controller.referenceIsRenameable(m_reference);
+                
+                if (isToken) {
+                        showReference(m_reference);
+                } else {
+                        clearReference();
+                }
+                
+                m_renameMenu.setEnabled(isRenameable && isToken);
+                m_showInheritanceMenu.setEnabled(isClassEntry || isMethodEntry || isConstructorEntry);
+                m_showImplementationsMenu.setEnabled(isClassEntry || isMethodEntry);
+                m_showCallsMenu.setEnabled(isClassEntry || isFieldEntry || isMethodEntry || isConstructorEntry);
+                m_openEntryMenu.setEnabled(isInJar && (isClassEntry || isFieldEntry || isMethodEntry || isConstructorEntry));
+                m_openPreviousMenu.setEnabled(m_controller.hasPreviousLocation());
+                m_toggleMappingMenu.setEnabled(isRenameable && isToken);
+                
+                if (isToken && m_controller.entryHasDeobfuscatedName(m_reference.entry)) {
+                        m_toggleMappingMenu.setText("Reset to obfuscated");
+                } else {
+                        m_toggleMappingMenu.setText("Mark as deobfuscated");
+                }
+        }
+        
+        private void navigateTo(Entry entry) {
+                if (!m_controller.entryIsInJar(entry)) {
+                        // entry is not in the jar. Ignore it
+                        return;
+                }
+                if (m_reference != null) {
+                        m_controller.savePreviousReference(m_reference);
+                }
+                m_controller.openDeclaration(entry);
+        }
+        
+        private void navigateTo(EntryReference<Entry,Entry> reference) {
+                if (!m_controller.entryIsInJar(reference.getLocationClassEntry())) {
+                        // reference is not in the jar. Ignore it
+                        return;
+                }
+                if (m_reference != null) {
+                        m_controller.savePreviousReference(m_reference);
+                }
+                m_controller.openReference(reference);
+        }
+        
+        private void startRename() {
+                
+                // init the text box
+                final JTextField text = new JTextField();
+                text.setText(m_reference.getNamableName());
+                text.setPreferredSize(new Dimension(360, text.getPreferredSize().height));
+                text.addKeyListener(new KeyAdapter() {
+                        @Override
+                        public void keyPressed(KeyEvent event) {
+                                switch (event.getKeyCode()) {
+                                        case KeyEvent.VK_ENTER:
+                                                finishRename(text, true);
+                                        break;
+                                        
+                                        case KeyEvent.VK_ESCAPE:
+                                                finishRename(text, false);
+                                        break;
+                                }
+                        }
+                });
+                
+                // find the label with the name and replace it with the text box
+                JPanel panel = (JPanel)m_infoPanel.getComponent(0);
+                panel.remove(panel.getComponentCount() - 1);
+                panel.add(text);
+                text.grabFocus();
+                text.selectAll();
+                
+                redraw();
+        }
+        
+        private void finishRename(JTextField text, boolean saveName) {
+                String newName = text.getText();
+                if (saveName && newName != null && newName.length() > 0) {
+                        try {
+                                m_controller.rename(m_reference, newName);
+                        } catch (IllegalNameException ex) {
+                                text.setBorder(BorderFactory.createLineBorder(Color.red, 1));
+                                text.setToolTipText(ex.getReason());
+                                GuiTricks.showToolTipNow(text);
+                        }
+                        return;
+                }
+                
+                // abort the rename
+                JPanel panel = (JPanel)m_infoPanel.getComponent(0);
+                panel.remove(panel.getComponentCount() - 1);
+                panel.add(GuiTricks.unboldLabel(new JLabel(m_reference.getNamableName(), JLabel.LEFT)));
+                
+                m_editor.grabFocus();
+                
+                redraw();
+        }
+        
+        private void showInheritance() {
+                
+                if (m_reference == null) {
+                        return;
+                }
+                
+                m_inheritanceTree.setModel(null);
+                
+                if (m_reference.entry instanceof ClassEntry) {
+                        // get the class inheritance
+                        ClassInheritanceTreeNode classNode = m_controller.getClassInheritance((ClassEntry)m_reference.entry);
+                        
+                        // show the tree at the root
+                        TreePath path = getPathToRoot(classNode);
+                        m_inheritanceTree.setModel(new DefaultTreeModel((TreeNode)path.getPathComponent(0)));
+                        m_inheritanceTree.expandPath(path);
+                        m_inheritanceTree.setSelectionRow(m_inheritanceTree.getRowForPath(path));
+                } else if (m_reference.entry instanceof MethodEntry) {
+                        // get the method inheritance
+                        MethodInheritanceTreeNode classNode = m_controller.getMethodInheritance((MethodEntry)m_reference.entry);
+                        
+                        // show the tree at the root
+                        TreePath path = getPathToRoot(classNode);
+                        m_inheritanceTree.setModel(new DefaultTreeModel((TreeNode)path.getPathComponent(0)));
+                        m_inheritanceTree.expandPath(path);
+                        m_inheritanceTree.setSelectionRow(m_inheritanceTree.getRowForPath(path));
+                }
+                
+                m_tabs.setSelectedIndex(0);
+                redraw();
+        }
+        
+        private void showImplementations() {
+                
+                if (m_reference == null) {
+                        return;
+                }
+                
+                m_implementationsTree.setModel(null);
+                
+                if (m_reference.entry instanceof ClassEntry) {
+                        // get the class implementations
+                        ClassImplementationsTreeNode node = m_controller.getClassImplementations((ClassEntry)m_reference.entry);
+                        if (node != null) {
+                                // show the tree at the root
+                                TreePath path = getPathToRoot(node);
+                                m_implementationsTree.setModel(new DefaultTreeModel((TreeNode)path.getPathComponent(0)));
+                                m_implementationsTree.expandPath(path);
+                                m_implementationsTree.setSelectionRow(m_implementationsTree.getRowForPath(path));
+                        }
+                } else if (m_reference.entry instanceof MethodEntry) {
+                        // get the method implementations
+                        MethodImplementationsTreeNode node = m_controller.getMethodImplementations((MethodEntry)m_reference.entry);
+                        if (node != null) {
+                                // show the tree at the root
+                                TreePath path = getPathToRoot(node);
+                                m_implementationsTree.setModel(new DefaultTreeModel((TreeNode)path.getPathComponent(0)));
+                                m_implementationsTree.expandPath(path);
+                                m_implementationsTree.setSelectionRow(m_implementationsTree.getRowForPath(path));
+                        }
+                }
+                
+                m_tabs.setSelectedIndex(1);
+                redraw();
+        }
+        
+        private void showCalls() {
+                
+                if (m_reference == null) {
+                        return;
+                }
+                
+                if (m_reference.entry instanceof ClassEntry) {
+                        // look for calls to the default constructor
+                        // TODO: get a list of all the constructors and find calls to all of them
+                        BehaviorReferenceTreeNode node = m_controller.getMethodReferences(new ConstructorEntry((ClassEntry)m_reference.entry, new Signature("()V")));
+                        m_callsTree.setModel(new DefaultTreeModel(node));
+                } else if (m_reference.entry instanceof FieldEntry) {
+                        FieldReferenceTreeNode node = m_controller.getFieldReferences((FieldEntry)m_reference.entry);
+                        m_callsTree.setModel(new DefaultTreeModel(node));
+                } else if (m_reference.entry instanceof MethodEntry) {
+                        BehaviorReferenceTreeNode node = m_controller.getMethodReferences((MethodEntry)m_reference.entry);
+                        m_callsTree.setModel(new DefaultTreeModel(node));
+                } else if (m_reference.entry instanceof ConstructorEntry) {
+                        BehaviorReferenceTreeNode node = m_controller.getMethodReferences((ConstructorEntry)m_reference.entry);
+                        m_callsTree.setModel(new DefaultTreeModel(node));
+                }
+                
+                m_tabs.setSelectedIndex(2);
+                redraw();
+        }
+        
+        private void toggleMapping() {
+                if (m_controller.entryHasDeobfuscatedName(m_reference.entry)) {
+                        m_controller.removeMapping(m_reference);
+                } else {
+                        m_controller.markAsDeobfuscated(m_reference);
+                }
+        }
+        
+        private TreePath getPathToRoot(TreeNode node) {
+                List<TreeNode> nodes = Lists.newArrayList();
+                TreeNode n = node;
+                do {
+                        nodes.add(n);
+                        n = n.getParent();
+                } while (n != null);
+                Collections.reverse(nodes);
+                return new TreePath(nodes.toArray());
+        }
+        
+        private void close() {
+                if (!m_controller.isDirty()) {
+                        // everything is saved, we can exit safely
+                        m_frame.dispose();
+                } else {
+                        // ask to save before closing
+                        String[] options = { "Save and exit", "Discard changes", "Cancel" };
+                        int response = JOptionPane.showOptionDialog(m_frame, "Your mappings have not been saved yet. Do you want to save?", "Save your changes?", JOptionPane.YES_NO_CANCEL_OPTION,
+                                        JOptionPane.QUESTION_MESSAGE, null, options, options[2]);
+                        switch (response) {
+                                case JOptionPane.YES_OPTION: // save and exit
+                                        if (m_mappingsFileChooser.getSelectedFile() != null || m_mappingsFileChooser.showSaveDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                try {
+                                                        m_controller.saveMappings(m_mappingsFileChooser.getSelectedFile());
+                                                        m_frame.dispose();
+                                                } catch (IOException ex) {
+                                                        throw new Error(ex);
+                                                }
+                                        }
+                                break;
+                                
+                                case JOptionPane.NO_OPTION:
+                                        // don't save, exit
+                                        m_frame.dispose();
+                                break;
+                        
+                                // cancel means do nothing
+                        }
+                }
+        }
+        
+        private void redraw() {
+                m_frame.validate();
+                m_frame.repaint();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java
new file mode 100644
index 00000000..61fea9c0
--- /dev/null
+++ b/src/cuchaz/enigma/gui/GuiController.java
@@ -0,0 +1,355 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.List;
+import java.util.jar.JarFile;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Queues;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+
+import cuchaz.enigma.Deobfuscator;
+import cuchaz.enigma.Deobfuscator.ProgressListener;
+import cuchaz.enigma.analysis.BehaviorReferenceTreeNode;
+import cuchaz.enigma.analysis.ClassImplementationsTreeNode;
+import cuchaz.enigma.analysis.ClassInheritanceTreeNode;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.FieldReferenceTreeNode;
+import cuchaz.enigma.analysis.MethodImplementationsTreeNode;
+import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
+import cuchaz.enigma.analysis.SourceIndex;
+import cuchaz.enigma.analysis.Token;
+import cuchaz.enigma.gui.ProgressDialog.ProgressRunnable;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MappingParseException;
+import cuchaz.enigma.mapping.MappingsReader;
+import cuchaz.enigma.mapping.MappingsWriter;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.TranslationDirection;
+
+public class GuiController {
+        
+        private Deobfuscator m_deobfuscator;
+        private Gui m_gui;
+        private SourceIndex m_index;
+        private ClassEntry m_currentObfClass;
+        private boolean m_isDirty;
+        private Deque<EntryReference<Entry,Entry>> m_referenceStack;
+        
+        public GuiController(Gui gui) {
+                m_gui = gui;
+                m_deobfuscator = null;
+                m_index = null;
+                m_currentObfClass = null;
+                m_isDirty = false;
+                m_referenceStack = Queues.newArrayDeque();
+        }
+        
+        public boolean isDirty() {
+                return m_isDirty;
+        }
+        
+        public void openJar(final JarFile jar) throws IOException {
+                m_gui.onStartOpenJar();
+                m_deobfuscator = new Deobfuscator(jar);
+                m_gui.onFinishOpenJar(m_deobfuscator.getJarName());
+                refreshClasses();
+        }
+        
+        public void closeJar() {
+                m_deobfuscator = null;
+                m_gui.onCloseJar();
+        }
+        
+        public void openMappings(File file) throws IOException, MappingParseException {
+                FileReader in = new FileReader(file);
+                m_deobfuscator.setMappings(new MappingsReader().read(in));
+                in.close();
+                m_isDirty = false;
+                m_gui.setMappingsFile(file);
+                refreshClasses();
+                refreshCurrentClass();
+        }
+        
+        public void saveMappings(File file) throws IOException {
+                FileWriter out = new FileWriter(file);
+                new MappingsWriter().write(out, m_deobfuscator.getMappings());
+                out.close();
+                m_isDirty = false;
+        }
+        
+        public void closeMappings() {
+                m_deobfuscator.setMappings(null);
+                m_gui.setMappingsFile(null);
+                refreshClasses();
+                refreshCurrentClass();
+        }
+        
+        public void exportSource(final File dirOut) {
+                ProgressDialog.runInThread(m_gui.getFrame(), new ProgressRunnable() {
+                        @Override
+                        public void run(ProgressListener progress) throws Exception {
+                                m_deobfuscator.writeSources(dirOut, progress);
+                        }
+                });
+        }
+        
+        public void exportJar(final File fileOut) {
+                ProgressDialog.runInThread(m_gui.getFrame(), new ProgressRunnable() {
+                        @Override
+                        public void run(ProgressListener progress) {
+                                m_deobfuscator.writeJar(fileOut, progress);
+                        }
+                });
+        }
+        
+        public Token getToken(int pos) {
+                if (m_index == null) {
+                        return null;
+                }
+                return m_index.getReferenceToken(pos);
+        }
+        
+        public EntryReference<Entry,Entry> getDeobfReference(Token token) {
+                if (m_index == null) {
+                        return null;
+                }
+                return m_index.getDeobfReference(token);
+        }
+        
+        public ReadableToken getReadableToken(Token token) {
+                if (m_index == null) {
+                        return null;
+                }
+                return new ReadableToken(
+                        m_index.getLineNumber(token.start),
+                        m_index.getColumnNumber(token.start),
+                        m_index.getColumnNumber(token.end)
+                );
+        }
+        
+        public boolean entryHasDeobfuscatedName(Entry deobfEntry) {
+                return m_deobfuscator.hasDeobfuscatedName(m_deobfuscator.obfuscateEntry(deobfEntry));
+        }
+        
+        public boolean entryIsInJar(Entry deobfEntry) {
+                return m_deobfuscator.isObfuscatedIdentifier(m_deobfuscator.obfuscateEntry(deobfEntry));
+        }
+        
+        public boolean referenceIsRenameable(EntryReference<Entry,Entry> deobfReference) {
+                return m_deobfuscator.isRenameable(m_deobfuscator.obfuscateReference(deobfReference));
+        }
+        
+        public ClassInheritanceTreeNode getClassInheritance(ClassEntry deobfClassEntry) {
+                ClassEntry obfClassEntry = m_deobfuscator.obfuscateEntry(deobfClassEntry);
+                ClassInheritanceTreeNode rootNode = m_deobfuscator.getJarIndex().getClassInheritance(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfClassEntry
+                );
+                return ClassInheritanceTreeNode.findNode(rootNode, obfClassEntry);
+        }
+        
+        public ClassImplementationsTreeNode getClassImplementations(ClassEntry deobfClassEntry) {
+                ClassEntry obfClassEntry = m_deobfuscator.obfuscateEntry(deobfClassEntry);
+                return m_deobfuscator.getJarIndex().getClassImplementations(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfClassEntry
+                );
+        }
+        
+        public MethodInheritanceTreeNode getMethodInheritance(MethodEntry deobfMethodEntry) {
+                MethodEntry obfMethodEntry = m_deobfuscator.obfuscateEntry(deobfMethodEntry);
+                MethodInheritanceTreeNode rootNode = m_deobfuscator.getJarIndex().getMethodInheritance(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfMethodEntry
+                );
+                return MethodInheritanceTreeNode.findNode(rootNode, obfMethodEntry);
+        }
+        
+        public MethodImplementationsTreeNode getMethodImplementations(MethodEntry deobfMethodEntry) {
+                MethodEntry obfMethodEntry = m_deobfuscator.obfuscateEntry(deobfMethodEntry);
+                MethodImplementationsTreeNode rootNode = m_deobfuscator.getJarIndex().getMethodImplementations(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfMethodEntry
+                );
+                if (rootNode == null) {
+                        return null;
+                }
+                return MethodImplementationsTreeNode.findNode(rootNode, obfMethodEntry);
+        }
+        
+        public FieldReferenceTreeNode getFieldReferences(FieldEntry deobfFieldEntry) {
+                FieldEntry obfFieldEntry = m_deobfuscator.obfuscateEntry(deobfFieldEntry);
+                FieldReferenceTreeNode rootNode = new FieldReferenceTreeNode(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfFieldEntry
+                );
+                rootNode.load(m_deobfuscator.getJarIndex(), true);
+                return rootNode;
+        }
+        
+        public BehaviorReferenceTreeNode getMethodReferences(BehaviorEntry deobfBehaviorEntry) {
+                BehaviorEntry obfBehaviorEntry = m_deobfuscator.obfuscateEntry(deobfBehaviorEntry);
+                BehaviorReferenceTreeNode rootNode = new BehaviorReferenceTreeNode(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfBehaviorEntry
+                );
+                rootNode.load(m_deobfuscator.getJarIndex(), true);
+                return rootNode;
+        }
+        
+        public void rename(EntryReference<Entry,Entry> deobfReference, String newName) {
+                EntryReference<Entry,Entry> obfReference = m_deobfuscator.obfuscateReference(deobfReference);
+                m_deobfuscator.rename(obfReference.getNameableEntry(), newName);
+                m_isDirty = true;
+                refreshClasses();
+                refreshCurrentClass(obfReference);
+        }
+        
+        public void removeMapping(EntryReference<Entry,Entry> deobfReference) {
+                EntryReference<Entry,Entry> obfReference = m_deobfuscator.obfuscateReference(deobfReference);
+                m_deobfuscator.removeMapping(obfReference.getNameableEntry());
+                m_isDirty = true;
+                refreshClasses();
+                refreshCurrentClass(obfReference);
+        }
+        
+        public void markAsDeobfuscated(EntryReference<Entry,Entry> deobfReference) {
+                EntryReference<Entry,Entry> obfReference = m_deobfuscator.obfuscateReference(deobfReference);
+                m_deobfuscator.markAsDeobfuscated(obfReference.getNameableEntry());
+                m_isDirty = true;
+                refreshClasses();
+                refreshCurrentClass(obfReference);
+        }
+        
+        public void openDeclaration(Entry deobfEntry) {
+                if (deobfEntry == null) {
+                        throw new IllegalArgumentException("Entry cannot be null!");
+                }
+                openReference(new EntryReference<Entry,Entry>(deobfEntry, deobfEntry.getName()));
+        }
+        
+        public void openReference(EntryReference<Entry,Entry> deobfReference) {
+                if (deobfReference == null) {
+                        throw new IllegalArgumentException("Reference cannot be null!");
+                }
+                
+                // get the reference target class
+                EntryReference<Entry,Entry> obfReference = m_deobfuscator.obfuscateReference(deobfReference);
+                ClassEntry obfClassEntry = obfReference.getLocationClassEntry().getOuterClassEntry();
+                if (!m_deobfuscator.isObfuscatedIdentifier(obfClassEntry)) {
+                        throw new IllegalArgumentException("Obfuscated class " + obfClassEntry + " was not found in the jar!");
+                }
+                if (m_currentObfClass == null || !m_currentObfClass.equals(obfClassEntry)) {
+                        // deobfuscate the class, then navigate to the reference
+                        m_currentObfClass = obfClassEntry;
+                        deobfuscate(m_currentObfClass, obfReference);
+                } else {
+                        showReference(obfReference);
+                }
+        }
+        
+        private void showReference(EntryReference<Entry,Entry> obfReference) {
+                EntryReference<Entry,Entry> deobfReference = m_deobfuscator.deobfuscateReference(obfReference);
+                Collection<Token> tokens = m_index.getReferenceTokens(deobfReference);
+                if (tokens.isEmpty()) {
+                        // DEBUG
+                        System.err.println(String.format("WARNING: no tokens found for %s in %s", deobfReference, m_currentObfClass));
+                } else {
+                        m_gui.showTokens(tokens);
+                }
+        }
+        
+        public void savePreviousReference(EntryReference<Entry,Entry> deobfReference) {
+                m_referenceStack.push(m_deobfuscator.obfuscateReference(deobfReference));
+        }
+        
+        public void openPreviousReference() {
+                if (hasPreviousLocation()) {
+                        openReference(m_deobfuscator.deobfuscateReference(m_referenceStack.pop()));
+                }
+        }
+        
+        public boolean hasPreviousLocation() {
+                return !m_referenceStack.isEmpty();
+        }
+        
+        private void refreshClasses() {
+                List<ClassEntry> obfClasses = Lists.newArrayList();
+                List<ClassEntry> deobfClasses = Lists.newArrayList();
+                m_deobfuscator.getSeparatedClasses(obfClasses, deobfClasses);
+                m_gui.setObfClasses(obfClasses);
+                m_gui.setDeobfClasses(deobfClasses);
+        }
+        
+        private void refreshCurrentClass() {
+                refreshCurrentClass(null);
+        }
+        
+        private void refreshCurrentClass(EntryReference<Entry,Entry> obfReference) {
+                if (m_currentObfClass != null) {
+                        deobfuscate(m_currentObfClass, obfReference);
+                }
+        }
+        
+        private void deobfuscate(final ClassEntry classEntry, final EntryReference<Entry,Entry> obfReference) {
+                
+                m_gui.setSource("(deobfuscating...)");
+                
+                // run the deobfuscator in a separate thread so we don't block the GUI event queue
+                new Thread() {
+                        @Override
+                        public void run() {
+                                // decompile,deobfuscate the bytecode
+                                CompilationUnit sourceTree = m_deobfuscator.getSourceTree(classEntry.getClassName());
+                                if (sourceTree == null) {
+                                        // decompilation of this class is not supported
+                                        m_gui.setSource("Unable to find class: " + classEntry);
+                                        return;
+                                }
+                                String source = m_deobfuscator.getSource(sourceTree);
+                                m_index = m_deobfuscator.getSourceIndex(sourceTree, source);
+                                m_gui.setSource(m_index.getSource());
+                                if (obfReference != null) {
+                                        showReference(obfReference);
+                                }
+                                
+                                // set the highlighted tokens
+                                List<Token> obfuscatedTokens = Lists.newArrayList();
+                                List<Token> deobfuscatedTokens = Lists.newArrayList();
+                                List<Token> otherTokens = Lists.newArrayList();
+                                for (Token token : m_index.referenceTokens()) {
+                                        EntryReference<Entry,Entry> reference = m_index.getDeobfReference(token);
+                                        if (referenceIsRenameable(reference)) {
+                                                if (entryHasDeobfuscatedName(reference.getNameableEntry())) {
+                                                        deobfuscatedTokens.add(token);
+                                                } else {
+                                                        obfuscatedTokens.add(token);
+                                                }
+                                        } else {
+                                                otherTokens.add(token);
+                                        }
+                                }
+                                m_gui.setHighlightedTokens(obfuscatedTokens, deobfuscatedTokens, otherTokens);
+                        }
+                }.start();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/GuiTricks.java b/src/cuchaz/enigma/gui/GuiTricks.java
new file mode 100644
index 00000000..df9e2215
--- /dev/null
+++ b/src/cuchaz/enigma/gui/GuiTricks.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Font;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.ToolTipManager;
+
+public class GuiTricks {
+        
+        public static JLabel unboldLabel(JLabel label) {
+                Font font = label.getFont();
+                label.setFont(font.deriveFont(font.getStyle() & ~Font.BOLD));
+                return label;
+        }
+        
+        public static void showToolTipNow(JComponent component) {
+                // HACKHACK: trick the tooltip manager into showing the tooltip right now
+                ToolTipManager manager = ToolTipManager.sharedInstance();
+                int oldDelay = manager.getInitialDelay();
+                manager.setInitialDelay(0);
+                manager.mouseMoved(new MouseEvent(component, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(), 0, 0, 0, 0, false));
+                manager.setInitialDelay(oldDelay);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ObfuscatedHighlightPainter.java b/src/cuchaz/enigma/gui/ObfuscatedHighlightPainter.java
new file mode 100644
index 00000000..177835f4
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ObfuscatedHighlightPainter.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+
+public class ObfuscatedHighlightPainter extends BoxHighlightPainter {
+        
+        public ObfuscatedHighlightPainter() {
+                // red ish
+                super(new Color(255, 220, 220), new Color(160, 80, 80));
+        }
+}
diff --git a/src/cuchaz/enigma/gui/OtherHighlightPainter.java b/src/cuchaz/enigma/gui/OtherHighlightPainter.java
new file mode 100644
index 00000000..4e9c8709
--- /dev/null
+++ b/src/cuchaz/enigma/gui/OtherHighlightPainter.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+
+public class OtherHighlightPainter extends BoxHighlightPainter {
+        
+        public OtherHighlightPainter() {
+                // grey
+                super(null, new Color(180, 180, 180));
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ProgressDialog.java b/src/cuchaz/enigma/gui/ProgressDialog.java
new file mode 100644
index 00000000..b864fdbf
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ProgressDialog.java
@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+
+import javax.swing.BorderFactory;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JProgressBar;
+import javax.swing.WindowConstants;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.Deobfuscator.ProgressListener;
+
+public class ProgressDialog implements ProgressListener, AutoCloseable {
+        
+        private JFrame m_frame;
+        private JLabel m_title;
+        private JLabel m_text;
+        private JProgressBar m_progress;
+        
+        public ProgressDialog(JFrame parent) {
+                
+                // init frame
+                m_frame = new JFrame(Constants.Name + " - Operation in progress");
+                final Container pane = m_frame.getContentPane();
+                FlowLayout layout = new FlowLayout();
+                layout.setAlignment(FlowLayout.LEFT);
+                pane.setLayout(layout);
+                
+                m_title = new JLabel();
+                pane.add(m_title);
+                
+                // set up the progress bar
+                JPanel panel = new JPanel();
+                pane.add(panel);
+                panel.setLayout(new BorderLayout());
+                m_text = GuiTricks.unboldLabel(new JLabel());
+                m_progress = new JProgressBar();
+                m_text.setBorder(BorderFactory.createEmptyBorder(0, 0, 10, 0));
+                panel.add(m_text, BorderLayout.NORTH);
+                panel.add(m_progress, BorderLayout.CENTER);
+                panel.setPreferredSize(new Dimension(360, 50));
+                
+                // show the frame
+                pane.doLayout();
+                m_frame.setSize(400, 120);
+                m_frame.setResizable(false);
+                m_frame.setLocationRelativeTo(parent);
+                m_frame.setVisible(true);
+                m_frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        }
+        
+        public void close() {
+                m_frame.dispose();
+        }
+        
+        @Override
+        public void init(int totalWork, String title) {
+                m_title.setText(title);
+                m_progress.setMinimum(0);
+                m_progress.setMaximum(totalWork);
+                m_progress.setValue(0);
+        }
+        
+        @Override
+        public void onProgress(int numDone, String message) {
+                m_text.setText(message);
+                m_progress.setValue(numDone);
+                
+                // update the frame
+                m_frame.validate();
+                m_frame.repaint();
+        }
+        
+        public static interface ProgressRunnable {
+                void run(ProgressListener listener) throws Exception;
+        }
+        
+        public static void runInThread(final JFrame parent, final ProgressRunnable runnable) {
+                new Thread() {
+                        @Override
+                        public void run() {
+                                try (ProgressDialog progress = new ProgressDialog(parent)) {
+                                        runnable.run(progress);
+                                } catch (Exception ex) {
+                                        throw new Error(ex);
+                                }
+                        }
+                }.start();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ReadableToken.java b/src/cuchaz/enigma/gui/ReadableToken.java
new file mode 100644
index 00000000..66bcbc2a
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ReadableToken.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+public class ReadableToken {
+        
+        public int line;
+        public int startColumn;
+        public int endColumn;
+        
+        public ReadableToken(int line, int startColumn, int endColumn) {
+                this.line = line;
+                this.startColumn = startColumn;
+                this.endColumn = endColumn;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("line ");
+                buf.append(line);
+                buf.append(" columns ");
+                buf.append(startColumn);
+                buf.append("-");
+                buf.append(endColumn);
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/RenameListener.java b/src/cuchaz/enigma/gui/RenameListener.java
new file mode 100644
index 00000000..abeda0ce
--- /dev/null
+++ b/src/cuchaz/enigma/gui/RenameListener.java
@@ -0,0 +1,17 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import cuchaz.enigma.mapping.Entry;
+
+public interface RenameListener {
+        void rename(Entry obfEntry, String newName);
+}
diff --git a/src/cuchaz/enigma/gui/SelectionHighlightPainter.java b/src/cuchaz/enigma/gui/SelectionHighlightPainter.java
new file mode 100644
index 00000000..5e189d2e
--- /dev/null
+++ b/src/cuchaz/enigma/gui/SelectionHighlightPainter.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.Shape;
+
+import javax.swing.text.Highlighter;
+import javax.swing.text.JTextComponent;
+
+public class SelectionHighlightPainter implements Highlighter.HighlightPainter {
+        
+        @Override
+        public void paint(Graphics g, int start, int end, Shape shape, JTextComponent text) {
+                // draw a thick border
+                Graphics2D g2d = (Graphics2D)g;
+                Rectangle bounds = BoxHighlightPainter.getBounds(text, start, end);
+                g2d.setColor(Color.black);
+                g2d.setStroke(new BasicStroke(2.0f));
+                g2d.drawRoundRect(bounds.x, bounds.y, bounds.width, bounds.height, 4, 4);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/TokenListCellRenderer.java b/src/cuchaz/enigma/gui/TokenListCellRenderer.java
new file mode 100644
index 00000000..a49be37b
--- /dev/null
+++ b/src/cuchaz/enigma/gui/TokenListCellRenderer.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Component;
+
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.ListCellRenderer;
+
+import cuchaz.enigma.analysis.Token;
+
+public class TokenListCellRenderer implements ListCellRenderer<Token> {
+        
+        private GuiController m_controller;
+        private DefaultListCellRenderer m_defaultRenderer;
+        
+        public TokenListCellRenderer(GuiController controller) {
+                m_controller = controller;
+                m_defaultRenderer = new DefaultListCellRenderer();
+        }
+        
+        @Override
+        public Component getListCellRendererComponent(JList<? extends Token> list, Token token, int index, boolean isSelected, boolean hasFocus) {
+                JLabel label = (JLabel)m_defaultRenderer.getListCellRendererComponent(list, token, index, isSelected, hasFocus);
+                label.setText(m_controller.getReadableToken(token).toString());
+                return label;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ArgumentEntry.java b/src/cuchaz/enigma/mapping/ArgumentEntry.java
new file mode 100644
index 00000000..aa222652
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ArgumentEntry.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class ArgumentEntry implements Entry, Serializable {
+        
+        private static final long serialVersionUID = 4472172468162696006L;
+        
+        private BehaviorEntry m_behaviorEntry;
+        private int m_index;
+        private String m_name;
+        
+        public ArgumentEntry(BehaviorEntry behaviorEntry, int index, String name) {
+                if (behaviorEntry == null) {
+                        throw new IllegalArgumentException("Behavior cannot be null!");
+                }
+                if (index < 0) {
+                        throw new IllegalArgumentException("Index must be non-negative!");
+                }
+                if (name == null) {
+                        throw new IllegalArgumentException("Argument name cannot be null!");
+                }
+                
+                m_behaviorEntry = behaviorEntry;
+                m_index = index;
+                m_name = name;
+        }
+        
+        public ArgumentEntry(ArgumentEntry other) {
+                m_behaviorEntry = (BehaviorEntry)m_behaviorEntry.cloneToNewClass(getClassEntry());
+                m_index = other.m_index;
+                m_name = other.m_name;
+        }
+        
+        public ArgumentEntry(ArgumentEntry other, String newClassName) {
+                m_behaviorEntry = (BehaviorEntry)other.m_behaviorEntry.cloneToNewClass(new ClassEntry(newClassName));
+                m_index = other.m_index;
+                m_name = other.m_name;
+        }
+        
+        public BehaviorEntry getBehaviorEntry() {
+                return m_behaviorEntry;
+        }
+        
+        public int getIndex() {
+                return m_index;
+        }
+        
+        @Override
+        public String getName() {
+                return m_name;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return m_behaviorEntry.getClassEntry();
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_behaviorEntry.getClassName();
+        }
+        
+        @Override
+        public ArgumentEntry cloneToNewClass(ClassEntry classEntry) {
+                return new ArgumentEntry(this, classEntry.getName());
+        }
+        
+        public String getMethodName() {
+                return m_behaviorEntry.getName();
+        }
+        
+        public Signature getMethodSignature() {
+                return m_behaviorEntry.getSignature();
+        }
+        
+        @Override
+        public int hashCode() {
+                return Util.combineHashesOrdered(
+                        m_behaviorEntry,
+                        Integer.valueOf(m_index).hashCode(),
+                        m_name.hashCode()
+                );
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ArgumentEntry) {
+                        return equals((ArgumentEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ArgumentEntry other) {
+                return m_behaviorEntry.equals(other.m_behaviorEntry)
+                        && m_index == other.m_index
+                        && m_name.equals(other.m_name);
+        }
+        
+        @Override
+        public String toString() {
+                return m_behaviorEntry.toString() + "(" + m_index + ":" + m_name + ")";
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ArgumentMapping.java b/src/cuchaz/enigma/mapping/ArgumentMapping.java
new file mode 100644
index 00000000..f4d8e774
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ArgumentMapping.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+public class ArgumentMapping implements Serializable, Comparable<ArgumentMapping> {
+        
+        private static final long serialVersionUID = 8610742471440861315L;
+        
+        private int m_index;
+        private String m_name;
+        
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public ArgumentMapping(int index, String name) {
+                m_index = index;
+                m_name = NameValidator.validateArgumentName(name);
+        }
+        
+        public int getIndex() {
+                return m_index;
+        }
+        
+        public String getName() {
+                return m_name;
+        }
+        
+        public void setName(String val) {
+                m_name = NameValidator.validateArgumentName(val);
+        }
+        
+        @Override
+        public int compareTo(ArgumentMapping other) {
+                return Integer.compare(m_index, other.m_index);
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/BehaviorEntry.java b/src/cuchaz/enigma/mapping/BehaviorEntry.java
new file mode 100644
index 00000000..535788f2
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/BehaviorEntry.java
@@ -0,0 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public interface BehaviorEntry extends Entry {
+        Signature getSignature();
+}
diff --git a/src/cuchaz/enigma/mapping/BehaviorEntryFactory.java b/src/cuchaz/enigma/mapping/BehaviorEntryFactory.java
new file mode 100644
index 00000000..61e501b7
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/BehaviorEntryFactory.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import javassist.CtBehavior;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+import javassist.bytecode.Descriptor;
+
+public class BehaviorEntryFactory {
+        
+        public static BehaviorEntry create(String className, String name, String signature) {
+                return create(new ClassEntry(className), name, signature);
+        }
+        
+        public static BehaviorEntry create(ClassEntry classEntry, String name, String signature) {
+                if (name.equals("<init>")) {
+                        return new ConstructorEntry(classEntry, new Signature(signature));
+                } else if (name.equals("<clinit>")) {
+                        return new ConstructorEntry(classEntry);
+                } else {
+                        return new MethodEntry(classEntry, name, new Signature(signature));
+                }
+        }
+        
+        public static BehaviorEntry create(CtBehavior behavior) {
+                String className = Descriptor.toJvmName(behavior.getDeclaringClass().getName());
+                if (behavior instanceof CtMethod) {
+                        return create(className, behavior.getName(), behavior.getSignature());
+                } else if (behavior instanceof CtConstructor) {
+                        CtConstructor constructor = (CtConstructor)behavior;
+                        if (constructor.isClassInitializer()) {
+                                return create(className, "<clinit>", null);
+                        } else {
+                                return create(className, "<init>", constructor.getSignature());
+                        }
+                } else {
+                        throw new IllegalArgumentException("Unable to create BehaviorEntry from " + behavior);
+                }
+        }
+        
+        public static BehaviorEntry createObf(ClassEntry classEntry, MethodMapping methodMapping) {
+                return create(classEntry, methodMapping.getObfName(), methodMapping.getObfSignature().toString());
+        }
+        
+        public static BehaviorEntry createDeobf(ClassEntry classEntry, MethodMapping methodMapping) {
+                return create(classEntry, methodMapping.getDeobfName(), methodMapping.getObfSignature().toString());
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ClassEntry.java b/src/cuchaz/enigma/mapping/ClassEntry.java
new file mode 100644
index 00000000..cf410012
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ClassEntry.java
@@ -0,0 +1,123 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+public class ClassEntry implements Entry, Serializable {
+        
+        private static final long serialVersionUID = 4235460580973955811L;
+        
+        private String m_name;
+        
+        public ClassEntry(String className) {
+                if (className == null) {
+                        throw new IllegalArgumentException("Class name cannot be null!");
+                }
+                if (className.indexOf('.') >= 0) {
+                        throw new IllegalArgumentException("Class name must be in JVM format. ie, path/to/package/class$inner : " + className);
+                }
+                
+                m_name = className;
+                
+                if (isInnerClass() && getInnerClassName().indexOf('/') >= 0) {
+                        throw new IllegalArgumentException("Inner class must not have a package: " + className);
+                }
+        }
+        
+        public ClassEntry(ClassEntry other) {
+                m_name = other.m_name;
+        }
+        
+        @Override
+        public String getName() {
+                return m_name;
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_name;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return this;
+        }
+        
+        @Override
+        public ClassEntry cloneToNewClass(ClassEntry classEntry) {
+                return classEntry;
+        }
+        
+        @Override
+        public int hashCode() {
+                return m_name.hashCode();
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ClassEntry) {
+                        return equals((ClassEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ClassEntry other) {
+                return m_name.equals(other.m_name);
+        }
+        
+        @Override
+        public String toString() {
+                return m_name;
+        }
+        
+        public boolean isInnerClass() {
+                return m_name.lastIndexOf('$') >= 0;
+        }
+        
+        public String getOuterClassName() {
+                if (isInnerClass()) {
+                        return m_name.substring(0, m_name.lastIndexOf('$'));
+                }
+                return m_name;
+        }
+        
+        public String getInnerClassName() {
+                if (!isInnerClass()) {
+                        throw new Error("This is not an inner class!");
+                }
+                return m_name.substring(m_name.lastIndexOf('$') + 1);
+        }
+        
+        public ClassEntry getOuterClassEntry() {
+                return new ClassEntry(getOuterClassName());
+        }
+        
+        public boolean isInDefaultPackage() {
+                return m_name.indexOf('/') < 0;
+        }
+        
+        public String getPackageName() {
+                int pos = m_name.lastIndexOf('/');
+                if (pos > 0) {
+                        return m_name.substring(0, pos);
+                }
+                return null;
+        }
+        
+        public String getSimpleName() {
+                int pos = m_name.lastIndexOf('/');
+                if (pos > 0) {
+                        return m_name.substring(pos + 1);
+                }
+                return m_name;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java
new file mode 100644
index 00000000..e2c3d56f
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -0,0 +1,405 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+public class ClassMapping implements Serializable, Comparable<ClassMapping> {
+        
+        private static final long serialVersionUID = -5148491146902340107L;
+        
+        private String m_obfName;
+        private String m_deobfName;
+        private Map<String,ClassMapping> m_innerClassesByObf;
+        private Map<String,ClassMapping> m_innerClassesByDeobf;
+        private Map<String,FieldMapping> m_fieldsByObf;
+        private Map<String,FieldMapping> m_fieldsByDeobf;
+        private Map<String,MethodMapping> m_methodsByObf;
+        private Map<String,MethodMapping> m_methodsByDeobf;
+        
+        public ClassMapping(String obfName) {
+                this(obfName, null);
+        }
+        
+        public ClassMapping(String obfName, String deobfName) {
+                m_obfName = obfName;
+                m_deobfName = NameValidator.validateClassName(deobfName, false);
+                m_innerClassesByObf = Maps.newHashMap();
+                m_innerClassesByDeobf = Maps.newHashMap();
+                m_fieldsByObf = Maps.newHashMap();
+                m_fieldsByDeobf = Maps.newHashMap();
+                m_methodsByObf = Maps.newHashMap();
+                m_methodsByDeobf = Maps.newHashMap();
+        }
+        
+        public String getObfName() {
+                return m_obfName;
+        }
+        
+        public String getDeobfName() {
+                return m_deobfName;
+        }
+        
+        public void setDeobfName(String val) {
+                m_deobfName = NameValidator.validateClassName(val, false);
+        }
+        
+        //// INNER CLASSES ////////
+        
+        public Iterable<ClassMapping> innerClasses() {
+                assert (m_innerClassesByObf.size() >= m_innerClassesByDeobf.size());
+                return m_innerClassesByObf.values();
+        }
+        
+        public void addInnerClassMapping(ClassMapping classMapping) {
+                assert (isSimpleClassName(classMapping.getObfName()));
+                boolean obfWasAdded = m_innerClassesByObf.put(classMapping.getObfName(), classMapping) == null;
+                assert (obfWasAdded);
+                if (classMapping.getDeobfName() != null) {
+                        assert (isSimpleClassName(classMapping.getDeobfName()));
+                        boolean deobfWasAdded = m_innerClassesByDeobf.put(classMapping.getDeobfName(), classMapping) == null;
+                        assert (deobfWasAdded);
+                }
+        }
+        
+        public void removeInnerClassMapping(ClassMapping classMapping) {
+                boolean obfWasRemoved = m_innerClassesByObf.remove(classMapping.getObfName()) != null;
+                assert (obfWasRemoved);
+                if (classMapping.getDeobfName() != null) {
+                        boolean deobfWasRemoved = m_innerClassesByDeobf.remove(classMapping.getDeobfName()) != null;
+                        assert (deobfWasRemoved);
+                }
+        }
+        
+        public ClassMapping getOrCreateInnerClass(String obfName) {
+                assert (isSimpleClassName(obfName));
+                ClassMapping classMapping = m_innerClassesByObf.get(obfName);
+                if (classMapping == null) {
+                        classMapping = new ClassMapping(obfName);
+                        boolean wasAdded = m_innerClassesByObf.put(obfName, classMapping) == null;
+                        assert (wasAdded);
+                }
+                return classMapping;
+        }
+        
+        public ClassMapping getInnerClassByObf(String obfName) {
+                assert (isSimpleClassName(obfName));
+                return m_innerClassesByObf.get(obfName);
+        }
+        
+        public ClassMapping getInnerClassByDeobf(String deobfName) {
+                assert (isSimpleClassName(deobfName));
+                return m_innerClassesByDeobf.get(deobfName);
+        }
+        
+        public ClassMapping getInnerClassByDeobfThenObf(String name) {
+                ClassMapping classMapping = getInnerClassByDeobf(name);
+                if (classMapping == null) {
+                        classMapping = getInnerClassByObf(name);
+                }
+                return classMapping;
+        }
+        
+        public String getObfInnerClassName(String deobfName) {
+                assert (isSimpleClassName(deobfName));
+                ClassMapping classMapping = m_innerClassesByDeobf.get(deobfName);
+                if (classMapping != null) {
+                        return classMapping.getObfName();
+                }
+                return null;
+        }
+        
+        public String getDeobfInnerClassName(String obfName) {
+                assert (isSimpleClassName(obfName));
+                ClassMapping classMapping = m_innerClassesByObf.get(obfName);
+                if (classMapping != null) {
+                        return classMapping.getDeobfName();
+                }
+                return null;
+        }
+        
+        public void setInnerClassName(String obfName, String deobfName) {
+                assert (isSimpleClassName(obfName));
+                ClassMapping classMapping = getOrCreateInnerClass(obfName);
+                if (classMapping.getDeobfName() != null) {
+                        boolean wasRemoved = m_innerClassesByDeobf.remove(classMapping.getDeobfName()) != null;
+                        assert (wasRemoved);
+                }
+                classMapping.setDeobfName(deobfName);
+                if (deobfName != null) {
+                        assert (isSimpleClassName(deobfName));
+                        boolean wasAdded = m_innerClassesByDeobf.put(deobfName, classMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        //// FIELDS ////////
+        
+        public Iterable<FieldMapping> fields() {
+                assert (m_fieldsByObf.size() == m_fieldsByDeobf.size());
+                return m_fieldsByObf.values();
+        }
+        
+        public boolean containsObfField(String obfName) {
+                return m_fieldsByObf.containsKey(obfName);
+        }
+        
+        public boolean containsDeobfField(String deobfName) {
+                return m_fieldsByDeobf.containsKey(deobfName);
+        }
+        
+        public void addFieldMapping(FieldMapping fieldMapping) {
+                if (m_fieldsByObf.containsKey(fieldMapping.getObfName())) {
+                        throw new Error("Already have mapping for " + m_obfName + "." + fieldMapping.getObfName());
+                }
+                if (m_fieldsByDeobf.containsKey(fieldMapping.getDeobfName())) {
+                        throw new Error("Already have mapping for " + m_deobfName + "." + fieldMapping.getDeobfName());
+                }
+                boolean obfWasAdded = m_fieldsByObf.put(fieldMapping.getObfName(), fieldMapping) == null;
+                assert (obfWasAdded);
+                boolean deobfWasAdded = m_fieldsByDeobf.put(fieldMapping.getDeobfName(), fieldMapping) == null;
+                assert (deobfWasAdded);
+                assert (m_fieldsByObf.size() == m_fieldsByDeobf.size());
+        }
+        
+        public void removeFieldMapping(FieldMapping fieldMapping) {
+                boolean obfWasRemoved = m_fieldsByObf.remove(fieldMapping.getObfName()) != null;
+                assert (obfWasRemoved);
+                if (fieldMapping.getDeobfName() != null) {
+                        boolean deobfWasRemoved = m_fieldsByDeobf.remove(fieldMapping.getDeobfName()) != null;
+                        assert (deobfWasRemoved);
+                }
+        }
+        
+        public FieldMapping getFieldByObf(String obfName) {
+                return m_fieldsByObf.get(obfName);
+        }
+        
+        public FieldMapping getFieldByDeobf(String deobfName) {
+                return m_fieldsByDeobf.get(deobfName);
+        }
+        
+        public String getObfFieldName(String deobfName) {
+                FieldMapping fieldMapping = m_fieldsByDeobf.get(deobfName);
+                if (fieldMapping != null) {
+                        return fieldMapping.getObfName();
+                }
+                return null;
+        }
+        
+        public String getDeobfFieldName(String obfName) {
+                FieldMapping fieldMapping = m_fieldsByObf.get(obfName);
+                if (fieldMapping != null) {
+                        return fieldMapping.getDeobfName();
+                }
+                return null;
+        }
+        
+        public void setFieldName(String obfName, String deobfName) {
+                FieldMapping fieldMapping = m_fieldsByObf.get(obfName);
+                if (fieldMapping == null) {
+                        fieldMapping = new FieldMapping(obfName, deobfName);
+                        boolean obfWasAdded = m_fieldsByObf.put(obfName, fieldMapping) == null;
+                        assert (obfWasAdded);
+                } else {
+                        boolean wasRemoved = m_fieldsByDeobf.remove(fieldMapping.getDeobfName()) != null;
+                        assert (wasRemoved);
+                }
+                fieldMapping.setDeobfName(deobfName);
+                if (deobfName != null) {
+                        boolean wasAdded = m_fieldsByDeobf.put(deobfName, fieldMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        //// METHODS ////////
+        
+        public Iterable<MethodMapping> methods() {
+                assert (m_methodsByObf.size() >= m_methodsByDeobf.size());
+                return m_methodsByObf.values();
+        }
+        
+        public boolean containsObfMethod(String obfName, Signature obfSignature) {
+                return m_methodsByObf.containsKey(getMethodKey(obfName, obfSignature));
+        }
+        
+        public boolean containsDeobfMethod(String deobfName, Signature deobfSignature) {
+                return m_methodsByDeobf.containsKey(getMethodKey(deobfName, deobfSignature));
+        }
+        
+        public void addMethodMapping(MethodMapping methodMapping) {
+                String obfKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature());
+                if (m_methodsByObf.containsKey(obfKey)) {
+                        throw new Error("Already have mapping for " + m_obfName + "." + obfKey);
+                }
+                boolean wasAdded = m_methodsByObf.put(obfKey, methodMapping) == null;
+                assert (wasAdded);
+                if (methodMapping.getDeobfName() != null) {
+                        String deobfKey = getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature());
+                        if (m_methodsByDeobf.containsKey(deobfKey)) {
+                                throw new Error("Already have mapping for " + m_deobfName + "." + deobfKey);
+                        }
+                        boolean deobfWasAdded = m_methodsByDeobf.put(deobfKey, methodMapping) == null;
+                        assert (deobfWasAdded);
+                }
+                assert (m_methodsByObf.size() >= m_methodsByDeobf.size());
+        }
+        
+        public void removeMethodMapping(MethodMapping methodMapping) {
+                boolean obfWasRemoved = m_methodsByObf.remove(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature())) != null;
+                assert (obfWasRemoved);
+                if (methodMapping.getDeobfName() != null) {
+                        boolean deobfWasRemoved = m_methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null;
+                        assert (deobfWasRemoved);
+                }
+        }
+        
+        public MethodMapping getMethodByObf(String obfName, Signature signature) {
+                return m_methodsByObf.get(getMethodKey(obfName, signature));
+        }
+        
+        public MethodMapping getMethodByDeobf(String deobfName, Signature signature) {
+                return m_methodsByDeobf.get(getMethodKey(deobfName, signature));
+        }
+        
+        private String getMethodKey(String name, Signature signature) {
+                if (name == null) {
+                        throw new IllegalArgumentException("name cannot be null!");
+                }
+                if (signature == null) {
+                        throw new IllegalArgumentException("signature cannot be null!");
+                }
+                return name + signature;
+        }
+        
+        public void setMethodName(String obfName, Signature obfSignature, String deobfName) {
+                MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfName, obfSignature));
+                if (methodMapping == null) {
+                        methodMapping = createMethodMapping(obfName, obfSignature);
+                } else if (methodMapping.getDeobfName() != null) {
+                        boolean wasRemoved = m_methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null;
+                        assert (wasRemoved);
+                }
+                methodMapping.setDeobfName(deobfName);
+                if (deobfName != null) {
+                        boolean wasAdded = m_methodsByDeobf.put(getMethodKey(deobfName, obfSignature), methodMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        //// ARGUMENTS ////////
+        
+        public void setArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex, String argumentName) {
+                MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature));
+                if (methodMapping == null) {
+                        methodMapping = createMethodMapping(obfMethodName, obfMethodSignature);
+                }
+                methodMapping.setArgumentName(argumentIndex, argumentName);
+        }
+        
+        public void removeArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex) {
+                m_methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)).removeArgumentName(argumentIndex);
+        }
+        
+        private MethodMapping createMethodMapping(String obfName, Signature obfSignature) {
+                MethodMapping methodMapping = new MethodMapping(obfName, obfSignature);
+                boolean wasAdded = m_methodsByObf.put(getMethodKey(obfName, obfSignature), methodMapping) == null;
+                assert (wasAdded);
+                return methodMapping;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append(m_obfName);
+                buf.append(" <-> ");
+                buf.append(m_deobfName);
+                buf.append("\n");
+                buf.append("Fields:\n");
+                for (FieldMapping fieldMapping : fields()) {
+                        buf.append("\t");
+                        buf.append(fieldMapping.getObfName());
+                        buf.append(" <-> ");
+                        buf.append(fieldMapping.getDeobfName());
+                        buf.append("\n");
+                }
+                buf.append("Methods:\n");
+                for (MethodMapping methodMapping : m_methodsByObf.values()) {
+                        buf.append(methodMapping.toString());
+                        buf.append("\n");
+                }
+                buf.append("Inner Classes:\n");
+                for (ClassMapping classMapping : m_innerClassesByObf.values()) {
+                        buf.append("\t");
+                        buf.append(classMapping.getObfName());
+                        buf.append(" <-> ");
+                        buf.append(classMapping.getDeobfName());
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+        
+        @Override
+        public int compareTo(ClassMapping other) {
+                // sort by a, b, c, ... aa, ab, etc
+                if (m_obfName.length() != other.m_obfName.length()) {
+                        return m_obfName.length() - other.m_obfName.length();
+                }
+                return m_obfName.compareTo(other.m_obfName);
+        }
+        
+        public boolean renameObfClass(String oldObfClassName, String newObfClassName) {
+                
+                // rename inner classes
+                for (ClassMapping innerClassMapping : new ArrayList<ClassMapping>(m_innerClassesByObf.values())) {
+                        if (innerClassMapping.renameObfClass(oldObfClassName, newObfClassName)) {
+                                boolean wasRemoved = m_innerClassesByObf.remove(oldObfClassName) != null;
+                                assert (wasRemoved);
+                                boolean wasAdded = m_innerClassesByObf.put(newObfClassName, innerClassMapping) == null;
+                                assert (wasAdded);
+                        }
+                }
+                
+                // rename method signatures
+                for (MethodMapping methodMapping : new ArrayList<MethodMapping>(m_methodsByObf.values())) {
+                        String oldMethodKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature());
+                        if (methodMapping.renameObfClass(oldObfClassName, newObfClassName)) {
+                                boolean wasRemoved = m_methodsByObf.remove(oldMethodKey) != null;
+                                assert (wasRemoved);
+                                boolean wasAdded = m_methodsByObf.put(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()), methodMapping) == null;
+                                assert (wasAdded);
+                        }
+                }
+                
+                if (m_obfName.equals(oldObfClassName)) {
+                        // rename this class
+                        m_obfName = newObfClassName;
+                        return true;
+                }
+                return false;
+        }
+        
+        public boolean containsArgument(BehaviorEntry obfBehaviorEntry, String name) {
+                MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfBehaviorEntry.getName(), obfBehaviorEntry.getSignature()));
+                if (methodMapping != null) {
+                        return methodMapping.containsArgument(name);
+                }
+                return false;
+        }
+        
+        public static boolean isSimpleClassName(String name) {
+                return name.indexOf('/') < 0 && name.indexOf('$') < 0;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ClassNameReplacer.java b/src/cuchaz/enigma/mapping/ClassNameReplacer.java
new file mode 100644
index 00000000..bf984fd3
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ClassNameReplacer.java
@@ -0,0 +1,5 @@
+package cuchaz.enigma.mapping;
+
+public interface ClassNameReplacer {
+        String replace(String className);
+}
diff --git a/src/cuchaz/enigma/mapping/ConstructorEntry.java b/src/cuchaz/enigma/mapping/ConstructorEntry.java
new file mode 100644
index 00000000..5f3760f3
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ConstructorEntry.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class ConstructorEntry implements BehaviorEntry, Serializable {
+        
+        private static final long serialVersionUID = -868346075317366758L;
+        
+        private ClassEntry m_classEntry;
+        private Signature m_signature;
+        
+        public ConstructorEntry(ClassEntry classEntry) {
+                this(classEntry, null);
+        }
+        
+        public ConstructorEntry(ClassEntry classEntry, Signature signature) {
+                if (classEntry == null) {
+                        throw new IllegalArgumentException("Class cannot be null!");
+                }
+                
+                m_classEntry = classEntry;
+                m_signature = signature;
+        }
+        
+        public ConstructorEntry(ConstructorEntry other) {
+                m_classEntry = new ClassEntry(other.m_classEntry);
+                m_signature = other.m_signature;
+        }
+        
+        public ConstructorEntry(ConstructorEntry other, String newClassName) {
+                m_classEntry = new ClassEntry(newClassName);
+                m_signature = other.m_signature;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String getName() {
+                if (isStatic()) {
+                        return "<clinit>";
+                }
+                return "<init>";
+        }
+        
+        public boolean isStatic() {
+                return m_signature == null;
+        }
+        
+        @Override
+        public Signature getSignature() {
+                return m_signature;
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_classEntry.getName();
+        }
+        
+        @Override
+        public ConstructorEntry cloneToNewClass(ClassEntry classEntry) {
+                return new ConstructorEntry(this, classEntry.getName());
+        }
+        
+        @Override
+        public int hashCode() {
+                if (isStatic()) {
+                        return Util.combineHashesOrdered(m_classEntry);
+                } else {
+                        return Util.combineHashesOrdered(m_classEntry, m_signature);
+                }
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ConstructorEntry) {
+                        return equals((ConstructorEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ConstructorEntry other) {
+                if (isStatic() != other.isStatic()) {
+                        return false;
+                }
+                
+                if (isStatic()) {
+                        return m_classEntry.equals(other.m_classEntry);
+                } else {
+                        return m_classEntry.equals(other.m_classEntry) && m_signature.equals(other.m_signature);
+                }
+        }
+        
+        @Override
+        public String toString() {
+                if (isStatic()) {
+                        return m_classEntry.getName() + "." + getName();
+                } else {
+                        return m_classEntry.getName() + "." + getName() + m_signature;
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Entry.java b/src/cuchaz/enigma/mapping/Entry.java
new file mode 100644
index 00000000..39e1507d
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Entry.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public interface Entry {
+        String getName();
+        String getClassName();
+        ClassEntry getClassEntry();
+        Entry cloneToNewClass(ClassEntry classEntry);
+}
diff --git a/src/cuchaz/enigma/mapping/EntryPair.java b/src/cuchaz/enigma/mapping/EntryPair.java
new file mode 100644
index 00000000..60411c40
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/EntryPair.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public class EntryPair<T extends Entry> {
+        
+        public T obf;
+        public T deobf;
+        
+        public EntryPair(T obf, T deobf) {
+                this.obf = obf;
+                this.deobf = deobf;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/FieldEntry.java b/src/cuchaz/enigma/mapping/FieldEntry.java
new file mode 100644
index 00000000..6cc9eb78
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/FieldEntry.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class FieldEntry implements Entry, Serializable {
+        
+        private static final long serialVersionUID = 3004663582802885451L;
+        
+        private ClassEntry m_classEntry;
+        private String m_name;
+        
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public FieldEntry(ClassEntry classEntry, String name) {
+                if (classEntry == null) {
+                        throw new IllegalArgumentException("Class cannot be null!");
+                }
+                if (name == null) {
+                        throw new IllegalArgumentException("Field name cannot be null!");
+                }
+                
+                m_classEntry = classEntry;
+                m_name = name;
+        }
+        
+        public FieldEntry(FieldEntry other) {
+                m_classEntry = new ClassEntry(other.m_classEntry);
+                m_name = other.m_name;
+        }
+        
+        public FieldEntry(FieldEntry other, String newClassName) {
+                m_classEntry = new ClassEntry(newClassName);
+                m_name = other.m_name;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String getName() {
+                return m_name;
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_classEntry.getName();
+        }
+        
+        @Override
+        public FieldEntry cloneToNewClass(ClassEntry classEntry) {
+                return new FieldEntry(this, classEntry.getName());
+        }
+        
+        @Override
+        public int hashCode() {
+                return Util.combineHashesOrdered(m_classEntry, m_name);
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof FieldEntry) {
+                        return equals((FieldEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(FieldEntry other) {
+                return m_classEntry.equals(other.m_classEntry) && m_name.equals(other.m_name);
+        }
+        
+        @Override
+        public String toString() {
+                return m_classEntry.getName() + "." + m_name;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/FieldMapping.java b/src/cuchaz/enigma/mapping/FieldMapping.java
new file mode 100644
index 00000000..5f5c270d
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/FieldMapping.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+public class FieldMapping implements Serializable, Comparable<FieldMapping> {
+        
+        private static final long serialVersionUID = 8610742471440861315L;
+        
+        private String m_obfName;
+        private String m_deobfName;
+        
+        public FieldMapping(String obfName, String deobfName) {
+                m_obfName = obfName;
+                m_deobfName = NameValidator.validateFieldName(deobfName);
+        }
+        
+        public String getObfName() {
+                return m_obfName;
+        }
+        
+        public String getDeobfName() {
+                return m_deobfName;
+        }
+        
+        public void setDeobfName(String val) {
+                m_deobfName = NameValidator.validateFieldName(val);
+        }
+        
+        @Override
+        public int compareTo(FieldMapping other) {
+                return m_obfName.compareTo(other.m_obfName);
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/IllegalNameException.java b/src/cuchaz/enigma/mapping/IllegalNameException.java
new file mode 100644
index 00000000..aacaf3b0
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/IllegalNameException.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public class IllegalNameException extends RuntimeException {
+        
+        private static final long serialVersionUID = -2279910052561114323L;
+        
+        private String m_name;
+        private String m_reason;
+        
+        public IllegalNameException(String name) {
+                this(name, null);
+        }
+        
+        public IllegalNameException(String name, String reason) {
+                m_name = name;
+                m_reason = reason;
+        }
+        
+        public String getReason() {
+                return m_reason;
+        }
+        
+        @Override
+        public String getMessage() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("Illegal name: ");
+                buf.append(m_name);
+                if (m_reason != null) {
+                        buf.append(" because ");
+                        buf.append(m_reason);
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/JavassistUtil.java b/src/cuchaz/enigma/mapping/JavassistUtil.java
new file mode 100644
index 00000000..0c446c4a
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/JavassistUtil.java
@@ -0,0 +1,83 @@
+package cuchaz.enigma.mapping;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.Descriptor;
+import javassist.expr.ConstructorCall;
+import javassist.expr.FieldAccess;
+import javassist.expr.MethodCall;
+import javassist.expr.NewExpr;
+
+public class JavassistUtil {
+        
+        public static ClassEntry getClassEntry(CtClass c) {
+                return new ClassEntry(Descriptor.toJvmName(c.getName()));
+        }
+        
+        public static ClassEntry getSuperclassEntry(CtClass c) {
+                return new ClassEntry(Descriptor.toJvmName(c.getClassFile().getSuperclass()));
+        }
+        
+        public static MethodEntry getMethodEntry(CtMethod method) {
+                return new MethodEntry(
+                        getClassEntry(method.getDeclaringClass()),
+                        method.getName(),
+                        new Signature(method.getMethodInfo().getDescriptor())
+                );
+        }
+        
+        public static MethodEntry getMethodEntry(MethodCall call) {
+                return new MethodEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        call.getMethodName(),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(CtConstructor constructor) {
+                return new ConstructorEntry(
+                        getClassEntry(constructor.getDeclaringClass()),
+                        new Signature(constructor.getMethodInfo().getDescriptor())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(ConstructorCall call) {
+                return new ConstructorEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(NewExpr call) {
+                return new ConstructorEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static BehaviorEntry getBehaviorEntry(CtBehavior behavior) {
+                if (behavior instanceof CtMethod) {
+                        return getMethodEntry((CtMethod)behavior);
+                } else if (behavior instanceof CtConstructor) {
+                        return getConstructorEntry((CtConstructor)behavior);
+                }
+                throw new Error("behavior is neither Method nor Constructor!");
+        }
+        
+        public static FieldEntry getFieldEntry(CtField field) {
+                return new FieldEntry(
+                        getClassEntry(field.getDeclaringClass()),
+                        field.getName()
+                );
+        }
+        
+        public static FieldEntry getFieldEntry(FieldAccess call) {
+                return new FieldEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        call.getFieldName()
+                );
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingParseException.java b/src/cuchaz/enigma/mapping/MappingParseException.java
new file mode 100644
index 00000000..1974c222
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingParseException.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public class MappingParseException extends Exception {
+        
+        private static final long serialVersionUID = -5487280332892507236L;
+        
+        private int m_line;
+        private String m_message;
+        
+        public MappingParseException(int line, String message) {
+                m_line = line;
+                m_message = message;
+        }
+        
+        @Override
+        public String getMessage() {
+                return "Line " + m_line + ": " + m_message;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java
new file mode 100644
index 00000000..57d80013
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Mappings.java
@@ -0,0 +1,188 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.analysis.TranslationIndex;
+
+public class Mappings implements Serializable {
+        
+        private static final long serialVersionUID = 4649790259460259026L;
+        
+        protected Map<String,ClassMapping> m_classesByObf;
+        protected Map<String,ClassMapping> m_classesByDeobf;
+        
+        public Mappings() {
+                m_classesByObf = Maps.newHashMap();
+                m_classesByDeobf = Maps.newHashMap();
+        }
+        
+        public Mappings(Iterable<ClassMapping> classes) {
+                this();
+                
+                for (ClassMapping classMapping : classes) {
+                        m_classesByObf.put(classMapping.getObfName(), classMapping);
+                        if (classMapping.getDeobfName() != null) {
+                                m_classesByDeobf.put(classMapping.getDeobfName(), classMapping);
+                        }
+                }
+        }
+        
+        public Collection<ClassMapping> classes() {
+                assert (m_classesByObf.size() >= m_classesByDeobf.size());
+                return m_classesByObf.values();
+        }
+        
+        public void addClassMapping(ClassMapping classMapping) {
+                if (m_classesByObf.containsKey(classMapping.getObfName())) {
+                        throw new Error("Already have mapping for " + classMapping.getObfName());
+                }
+                boolean obfWasAdded = m_classesByObf.put(classMapping.getObfName(), classMapping) == null;
+                assert (obfWasAdded);
+                if (classMapping.getDeobfName() != null) {
+                        if (m_classesByDeobf.containsKey(classMapping.getDeobfName())) {
+                                throw new Error("Already have mapping for " + classMapping.getDeobfName());
+                        }
+                        boolean deobfWasAdded = m_classesByDeobf.put(classMapping.getDeobfName(), classMapping) == null;
+                        assert (deobfWasAdded);
+                }
+        }
+        
+        public void removeClassMapping(ClassMapping classMapping) {
+                boolean obfWasRemoved = m_classesByObf.remove(classMapping.getObfName()) != null;
+                assert (obfWasRemoved);
+                if (classMapping.getDeobfName() != null) {
+                        boolean deobfWasRemoved = m_classesByDeobf.remove(classMapping.getDeobfName()) != null;
+                        assert (deobfWasRemoved);
+                }
+        }
+        
+        public ClassMapping getClassByObf(ClassEntry entry) {
+                return getClassByObf(entry.getName());
+        }
+        
+        public ClassMapping getClassByObf(String obfName) {
+                return m_classesByObf.get(obfName);
+        }
+        
+        public ClassMapping getClassByDeobf(ClassEntry entry) {
+                return getClassByDeobf(entry.getName());
+        }
+        
+        public ClassMapping getClassByDeobf(String deobfName) {
+                return m_classesByDeobf.get(deobfName);
+        }
+        
+        public Translator getTranslator(TranslationDirection direction, TranslationIndex index) {
+                switch (direction) {
+                        case Deobfuscating:
+                                
+                                return new Translator(direction, m_classesByObf, index);
+                                
+                        case Obfuscating:
+                                
+                                // fill in the missing deobf class entries with obf entries
+                                Map<String,ClassMapping> classes = Maps.newHashMap();
+                                for (ClassMapping classMapping : classes()) {
+                                        if (classMapping.getDeobfName() != null) {
+                                                classes.put(classMapping.getDeobfName(), classMapping);
+                                        } else {
+                                                classes.put(classMapping.getObfName(), classMapping);
+                                        }
+                                }
+                                
+                                // translate the translation index
+                                // NOTE: this isn't actually recursive
+                                TranslationIndex deobfIndex = new TranslationIndex(index, getTranslator(TranslationDirection.Deobfuscating, index));
+                                
+                                return new Translator(direction, classes, deobfIndex);
+                                
+                        default:
+                                throw new Error("Invalid translation direction!");
+                }
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                for (ClassMapping classMapping : m_classesByObf.values()) {
+                        buf.append(classMapping.toString());
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+        
+        public void renameObfClass(String oldObfName, String newObfName) {
+                for (ClassMapping classMapping : new ArrayList<ClassMapping>(classes())) {
+                        if (classMapping.renameObfClass(oldObfName, newObfName)) {
+                                boolean wasRemoved = m_classesByObf.remove(oldObfName) != null;
+                                assert (wasRemoved);
+                                boolean wasAdded = m_classesByObf.put(newObfName, classMapping) == null;
+                                assert (wasAdded);
+                        }
+                }
+        }
+        
+        public Set<String> getAllObfClassNames() {
+                final Set<String> classNames = Sets.newHashSet();
+                for (ClassMapping classMapping : classes()) {
+                        
+                        // add the class name
+                        classNames.add(classMapping.getObfName());
+                        
+                        // add classes from method signatures
+                        for (MethodMapping methodMapping : classMapping.methods()) {
+                                for (Type type : methodMapping.getObfSignature().types()) {
+                                        if (type.hasClass()) {
+                                                classNames.add(type.getClassEntry().getClassName());
+                                        }
+                                }
+                        }
+                }
+                return classNames;
+        }
+        
+        public boolean containsDeobfClass(String deobfName) {
+                return m_classesByDeobf.containsKey(deobfName);
+        }
+        
+        public boolean containsDeobfField(ClassEntry obfClassEntry, String deobfName) {
+                ClassMapping classMapping = m_classesByObf.get(obfClassEntry.getName());
+                if (classMapping != null) {
+                        return classMapping.containsDeobfField(deobfName);
+                }
+                return false;
+        }
+        
+        public boolean containsDeobfMethod(ClassEntry obfClassEntry, String deobfName, Signature deobfSignature) {
+                ClassMapping classMapping = m_classesByObf.get(obfClassEntry.getName());
+                if (classMapping != null) {
+                        return classMapping.containsDeobfMethod(deobfName, deobfSignature);
+                }
+                return false;
+        }
+        
+        public boolean containsArgument(BehaviorEntry obfBehaviorEntry, String name) {
+                ClassMapping classMapping = m_classesByObf.get(obfBehaviorEntry.getClassName());
+                if (classMapping != null) {
+                        return classMapping.containsArgument(obfBehaviorEntry, name);
+                }
+                return false;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java
new file mode 100644
index 00000000..adf460e6
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsReader.java
@@ -0,0 +1,175 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.Deque;
+
+import com.google.common.collect.Queues;
+
+import cuchaz.enigma.Constants;
+
+public class MappingsReader {
+        
+        public Mappings read(Reader in) throws IOException, MappingParseException {
+                return read(new BufferedReader(in));
+        }
+        
+        public Mappings read(BufferedReader in) throws IOException, MappingParseException {
+                Mappings mappings = new Mappings();
+                Deque<Object> mappingStack = Queues.newArrayDeque();
+                
+                int lineNumber = 0;
+                String line = null;
+                while ( (line = in.readLine()) != null) {
+                        lineNumber++;
+                        
+                        // strip comments
+                        int commentPos = line.indexOf('#');
+                        if (commentPos >= 0) {
+                                line = line.substring(0, commentPos);
+                        }
+                        
+                        // skip blank lines
+                        if (line.trim().length() <= 0) {
+                                continue;
+                        }
+                        
+                        // get the indent of this line
+                        int indent = 0;
+                        for (int i = 0; i < line.length(); i++) {
+                                if (line.charAt(i) != '\t') {
+                                        break;
+                                }
+                                indent++;
+                        }
+                        
+                        // handle stack pops
+                        while (indent < mappingStack.size()) {
+                                mappingStack.pop();
+                        }
+                        
+                        String[] parts = line.trim().split("\\s");
+                        try {
+                                // read the first token
+                                String token = parts[0];
+                                
+                                if (token.equalsIgnoreCase("CLASS")) {
+                                        ClassMapping classMapping;
+                                        if (indent == 0) {
+                                                // outer class
+                                                classMapping = readClass(parts, false);
+                                                mappings.addClassMapping(classMapping);
+                                        } else if (indent == 1) {
+                                                // inner class
+                                                if (! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                        throw new MappingParseException(lineNumber, "Unexpected CLASS entry here!");
+                                                }
+                                                
+                                                classMapping = readClass(parts, true);
+                                                ((ClassMapping)mappingStack.getFirst()).addInnerClassMapping(classMapping);
+                                        } else {
+                                                throw new MappingParseException(lineNumber, "Unexpected CLASS entry nesting!");
+                                        }
+                                        mappingStack.push(classMapping);
+                                } else if (token.equalsIgnoreCase("FIELD")) {
+                                        if (mappingStack.isEmpty() || ! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                throw new MappingParseException(lineNumber, "Unexpected FIELD entry here!");
+                                        }
+                                        ((ClassMapping)mappingStack.getFirst()).addFieldMapping(readField(parts));
+                                } else if (token.equalsIgnoreCase("METHOD")) {
+                                        if (mappingStack.isEmpty() || ! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                throw new MappingParseException(lineNumber, "Unexpected METHOD entry here!");
+                                        }
+                                        MethodMapping methodMapping = readMethod(parts);
+                                        ((ClassMapping)mappingStack.getFirst()).addMethodMapping(methodMapping);
+                                        mappingStack.push(methodMapping);
+                                } else if (token.equalsIgnoreCase("ARG")) {
+                                        if (mappingStack.isEmpty() || ! (mappingStack.getFirst() instanceof MethodMapping)) {
+                                                throw new MappingParseException(lineNumber, "Unexpected ARG entry here!");
+                                        }
+                                        ((MethodMapping)mappingStack.getFirst()).addArgumentMapping(readArgument(parts));
+                                }
+                        } catch (ArrayIndexOutOfBoundsException | NumberFormatException ex) {
+                                throw new MappingParseException(lineNumber, "Malformed line!");
+                        }
+                }
+                
+                return mappings;
+        }
+        
+        private ArgumentMapping readArgument(String[] parts) {
+                return new ArgumentMapping(Integer.parseInt(parts[1]), parts[2]);
+        }
+        
+        private ClassMapping readClass(String[] parts, boolean makeSimple) {
+                if (parts.length == 2) {
+                        String obfName = processName(parts[1], makeSimple);
+                        return new ClassMapping(obfName);
+                } else {
+                        String obfName = processName(parts[1], makeSimple);
+                        String deobfName = processName(parts[2], makeSimple);
+                        return new ClassMapping(obfName, deobfName);
+                }
+        }
+        
+        private String processName(String name, boolean makeSimple) {
+                if (makeSimple) {
+                        return new ClassEntry(name).getSimpleName();
+                } else {
+                        return moveClassOutOfDefaultPackage(name, Constants.NonePackage);
+                }
+        }
+        
+        private String moveClassOutOfDefaultPackage(String className, String newPackageName) {
+                ClassEntry classEntry = new ClassEntry(className);
+                if (classEntry.isInDefaultPackage()) {
+                        return newPackageName + "/" + classEntry.getName();
+                }
+                return className;
+        }
+        
+        private FieldMapping readField(String[] parts) {
+                return new FieldMapping(parts[1], parts[2]);
+        }
+        
+        private MethodMapping readMethod(String[] parts) {
+                if (parts.length == 3) {
+                        String obfName = parts[1];
+                        Signature obfSignature = moveSignatureOutOfDefaultPackage(new Signature(parts[2]), Constants.NonePackage);
+                        return new MethodMapping(obfName, obfSignature);
+                } else {
+                        String obfName = parts[1];
+                        String deobfName = parts[2];
+                        Signature obfSignature = moveSignatureOutOfDefaultPackage(new Signature(parts[3]), Constants.NonePackage);
+                        if (obfName.equals(deobfName)) {
+                                return new MethodMapping(obfName, obfSignature);
+                        } else {
+                                return new MethodMapping(obfName, obfSignature, deobfName);
+                        }
+                }
+        }
+        
+        private Signature moveSignatureOutOfDefaultPackage(Signature signature, final String newPackageName) {
+                return new Signature(signature, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                ClassEntry classEntry = new ClassEntry(className);
+                                if (classEntry.isInDefaultPackage()) {
+                                        return newPackageName + "/" + className;
+                                }
+                                return null;
+                        }
+                });
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingsRenamer.java b/src/cuchaz/enigma/mapping/MappingsRenamer.java
new file mode 100644
index 00000000..0a41c2b8
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsRenamer.java
@@ -0,0 +1,237 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.util.Set;
+import java.util.zip.GZIPOutputStream;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.analysis.JarIndex;
+
+public class MappingsRenamer {
+        
+        private JarIndex m_index;
+        private Mappings m_mappings;
+        
+        public MappingsRenamer(JarIndex index, Mappings mappings) {
+                m_index = index;
+                m_mappings = mappings;
+        }
+        
+        public void setClassName(ClassEntry obf, String deobfName) {
+                deobfName = NameValidator.validateClassName(deobfName, !obf.isInnerClass());
+                ClassEntry targetEntry = new ClassEntry(deobfName);
+                if (m_mappings.containsDeobfClass(deobfName) || m_index.containsObfClass(targetEntry)) {
+                        throw new IllegalNameException(deobfName, "There is already a class with that name");
+                }
+                
+                ClassMapping classMapping = getOrCreateClassMapping(obf);
+                
+                if (obf.isInnerClass()) {
+                        classMapping.setInnerClassName(obf.getInnerClassName(), deobfName);
+                } else {
+                        if (classMapping.getDeobfName() != null) {
+                                boolean wasRemoved = m_mappings.m_classesByDeobf.remove(classMapping.getDeobfName()) != null;
+                                assert (wasRemoved);
+                        }
+                        classMapping.setDeobfName(deobfName);
+                        boolean wasAdded = m_mappings.m_classesByDeobf.put(deobfName, classMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        public void removeClassMapping(ClassEntry obf) {
+                ClassMapping classMapping = getClassMapping(obf);
+                if (obf.isInnerClass()) {
+                        classMapping.setInnerClassName(obf.getName(), null);
+                } else {
+                        boolean wasRemoved = m_mappings.m_classesByDeobf.remove(classMapping.getDeobfName()) != null;
+                        assert (wasRemoved);
+                        classMapping.setDeobfName(null);
+                }
+        }
+        
+        public void markClassAsDeobfuscated(ClassEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMapping(obf);
+                if (obf.isInnerClass()) {
+                        String innerClassName = Constants.NonePackage + "/" + obf.getInnerClassName();
+                        classMapping.setInnerClassName(innerClassName, innerClassName);
+                } else {
+                        classMapping.setDeobfName(obf.getName());
+                        boolean wasAdded = m_mappings.m_classesByDeobf.put(obf.getName(), classMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        public void setFieldName(FieldEntry obf, String deobfName) {
+                deobfName = NameValidator.validateFieldName(deobfName);
+                FieldEntry targetEntry = new FieldEntry(obf.getClassEntry(), deobfName);
+                if (m_mappings.containsDeobfField(obf.getClassEntry(), deobfName) || m_index.containsObfField(targetEntry)) {
+                        throw new IllegalNameException(deobfName, "There is already a field with that name");
+                }
+                
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setFieldName(obf.getName(), deobfName);
+        }
+        
+        public void removeFieldMapping(FieldEntry obf) {
+                ClassMapping classMapping = getClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setFieldName(obf.getName(), null);
+        }
+        
+        public void markFieldAsDeobfuscated(FieldEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setFieldName(obf.getName(), obf.getName());
+        }
+        
+        public void setMethodTreeName(MethodEntry obf, String deobfName) {
+                Set<MethodEntry> implementations = m_index.getRelatedMethodImplementations(obf);
+                
+                deobfName = NameValidator.validateMethodName(deobfName);
+                for (MethodEntry entry : implementations) {
+                        Signature deobfSignature = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateSignature(obf.getSignature());
+                        MethodEntry targetEntry = new MethodEntry(entry.getClassEntry(), deobfName, deobfSignature);
+                        if (m_mappings.containsDeobfMethod(entry.getClassEntry(), deobfName, entry.getSignature()) || m_index.containsObfBehavior(targetEntry)) {
+                                String deobfClassName = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateClass(entry.getClassName());
+                                throw new IllegalNameException(deobfName, "There is already a method with that name and signature in class " + deobfClassName);
+                        }
+                }
+                
+                for (MethodEntry entry : implementations) {
+                        setMethodName(entry, deobfName);
+                }
+        }
+        
+        public void setMethodName(MethodEntry obf, String deobfName) {
+                deobfName = NameValidator.validateMethodName(deobfName);
+                MethodEntry targetEntry = new MethodEntry(obf.getClassEntry(), deobfName, obf.getSignature());
+                if (m_mappings.containsDeobfMethod(obf.getClassEntry(), deobfName, obf.getSignature()) || m_index.containsObfBehavior(targetEntry)) {
+                        String deobfClassName = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateClass(obf.getClassName());
+                        throw new IllegalNameException(deobfName, "There is already a method with that name and signature in class " + deobfClassName);
+                }
+                
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setMethodName(obf.getName(), obf.getSignature(), deobfName);
+        }
+        
+        public void removeMethodTreeMapping(MethodEntry obf) {
+                for (MethodEntry implementation : m_index.getRelatedMethodImplementations(obf)) {
+                        removeMethodMapping(implementation);
+                }
+        }
+        
+        public void removeMethodMapping(MethodEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setMethodName(obf.getName(), obf.getSignature(), null);
+        }
+        
+        public void markMethodTreeAsDeobfuscated(MethodEntry obf) {
+                for (MethodEntry implementation : m_index.getRelatedMethodImplementations(obf)) {
+                        markMethodAsDeobfuscated(implementation);
+                }
+        }
+        
+        public void markMethodAsDeobfuscated(MethodEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setMethodName(obf.getName(), obf.getSignature(), obf.getName());
+        }
+        
+        public void setArgumentName(ArgumentEntry obf, String deobfName) {
+                deobfName = NameValidator.validateArgumentName(deobfName);
+                // NOTE: don't need to check arguments for name collisions with names determined by Procyon
+                if (m_mappings.containsArgument(obf.getBehaviorEntry(), deobfName)) {
+                        throw new IllegalNameException(deobfName, "There is already an argument with that name");
+                }
+                
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setArgumentName(obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), deobfName);
+        }
+        
+        public void removeArgumentMapping(ArgumentEntry obf) {
+                ClassMapping classMapping = getClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.removeArgumentName(obf.getMethodName(), obf.getMethodSignature(), obf.getIndex());
+        }
+        
+        public void markArgumentAsDeobfuscated(ArgumentEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setArgumentName(obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), obf.getName());
+        }
+        
+        public boolean moveFieldToObfClass(ClassMapping classMapping, FieldMapping fieldMapping, ClassEntry obfClass) {
+                classMapping.removeFieldMapping(fieldMapping);
+                ClassMapping targetClassMapping = getOrCreateClassMapping(obfClass);
+                if (!targetClassMapping.containsObfField(fieldMapping.getObfName())) {
+                        if (!targetClassMapping.containsDeobfField(fieldMapping.getDeobfName())) {
+                                targetClassMapping.addFieldMapping(fieldMapping);
+                                return true;
+                        } else {
+                                System.err.println("WARNING: deobf field was already there: " + obfClass + "." + fieldMapping.getDeobfName());
+                        }
+                }
+                return false;
+        }
+        
+        public boolean moveMethodToObfClass(ClassMapping classMapping, MethodMapping methodMapping, ClassEntry obfClass) {
+                classMapping.removeMethodMapping(methodMapping);
+                ClassMapping targetClassMapping = getOrCreateClassMapping(obfClass);
+                if (!targetClassMapping.containsObfMethod(methodMapping.getObfName(), methodMapping.getObfSignature())) {
+                        if (!targetClassMapping.containsDeobfMethod(methodMapping.getDeobfName(), methodMapping.getObfSignature())) {
+                                targetClassMapping.addMethodMapping(methodMapping);
+                                return true;
+                        } else {
+                                System.err.println("WARNING: deobf method was already there: " + obfClass + "." + methodMapping.getDeobfName() + methodMapping.getObfSignature());
+                        }
+                }
+                return false;
+        }
+        
+        public void write(OutputStream out) throws IOException {
+                // TEMP: just use the object output for now. We can find a more efficient storage format later
+                GZIPOutputStream gzipout = new GZIPOutputStream(out);
+                ObjectOutputStream oout = new ObjectOutputStream(gzipout);
+                oout.writeObject(this);
+                gzipout.finish();
+        }
+        
+        private ClassMapping getClassMapping(ClassEntry obfClassEntry) {
+                return m_mappings.m_classesByObf.get(obfClassEntry.getOuterClassName());
+        }
+        
+        private ClassMapping getOrCreateClassMapping(ClassEntry obfClassEntry) {
+                String obfClassName = obfClassEntry.getOuterClassName();
+                ClassMapping classMapping = m_mappings.m_classesByObf.get(obfClassName);
+                if (classMapping == null) {
+                        classMapping = new ClassMapping(obfClassName);
+                        boolean obfWasAdded = m_mappings.m_classesByObf.put(classMapping.getObfName(), classMapping) == null;
+                        assert (obfWasAdded);
+                }
+                return classMapping;
+        }
+        
+        private ClassMapping getClassMappingOrInnerClassMapping(ClassEntry obfClassEntry) {
+                ClassMapping classMapping = getClassMapping(obfClassEntry);
+                if (obfClassEntry.isInDefaultPackage()) {
+                        classMapping = classMapping.getInnerClassByObf(obfClassEntry.getInnerClassName());
+                }
+                return classMapping;
+        }
+        
+        private ClassMapping getOrCreateClassMappingOrInnerClassMapping(ClassEntry obfClassEntry) {
+                ClassMapping classMapping = getOrCreateClassMapping(obfClassEntry);
+                if (obfClassEntry.isInnerClass()) {
+                        classMapping = classMapping.getOrCreateInnerClass(obfClassEntry.getInnerClassName());
+                }
+                return classMapping;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingsWriter.java b/src/cuchaz/enigma/mapping/MappingsWriter.java
new file mode 100644
index 00000000..5ac409fc
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsWriter.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class MappingsWriter {
+        
+        public void write(Writer out, Mappings mappings) throws IOException {
+                write(new PrintWriter(out), mappings);
+        }
+        
+        public void write(PrintWriter out, Mappings mappings) throws IOException {
+                for (ClassMapping classMapping : sorted(mappings.classes())) {
+                        write(out, classMapping, 0);
+                }
+        }
+        
+        private void write(PrintWriter out, ClassMapping classMapping, int depth) throws IOException {
+                if (classMapping.getDeobfName() == null) {
+                        out.format("%sCLASS %s\n", getIndent(depth), classMapping.getObfName());
+                } else {
+                        out.format("%sCLASS %s %s\n", getIndent(depth), classMapping.getObfName(), classMapping.getDeobfName());
+                }
+                
+                for (ClassMapping innerClassMapping : sorted(classMapping.innerClasses())) {
+                        write(out, innerClassMapping, depth + 1);
+                }
+                
+                for (FieldMapping fieldMapping : sorted(classMapping.fields())) {
+                        write(out, fieldMapping, depth + 1);
+                }
+                
+                for (MethodMapping methodMapping : sorted(classMapping.methods())) {
+                        write(out, methodMapping, depth + 1);
+                }
+        }
+        
+        private void write(PrintWriter out, FieldMapping fieldMapping, int depth) throws IOException {
+                out.format("%sFIELD %s %s\n", getIndent(depth), fieldMapping.getObfName(), fieldMapping.getDeobfName());
+        }
+        
+        private void write(PrintWriter out, MethodMapping methodMapping, int depth) throws IOException {
+                if (methodMapping.getDeobfName() == null) {
+                        out.format("%sMETHOD %s %s\n", getIndent(depth), methodMapping.getObfName(), methodMapping.getObfSignature());
+                } else {
+                        out.format("%sMETHOD %s %s %s\n", getIndent(depth), methodMapping.getObfName(), methodMapping.getDeobfName(), methodMapping.getObfSignature());
+                }
+                
+                for (ArgumentMapping argumentMapping : sorted(methodMapping.arguments())) {
+                        write(out, argumentMapping, depth + 1);
+                }
+        }
+        
+        private void write(PrintWriter out, ArgumentMapping argumentMapping, int depth) throws IOException {
+                out.format("%sARG %d %s\n", getIndent(depth), argumentMapping.getIndex(), argumentMapping.getName());
+        }
+        
+        private <T extends Comparable<T>> List<T> sorted(Iterable<T> classes) {
+                List<T> out = new ArrayList<T>();
+                for (T t : classes) {
+                        out.add(t);
+                }
+                Collections.sort(out);
+                return out;
+        }
+        
+        private String getIndent(int depth) {
+                StringBuilder buf = new StringBuilder();
+                for (int i = 0; i < depth; i++) {
+                        buf.append("\t");
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MethodEntry.java b/src/cuchaz/enigma/mapping/MethodEntry.java
new file mode 100644
index 00000000..057e02b9
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MethodEntry.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class MethodEntry implements BehaviorEntry, Serializable {
+        
+        private static final long serialVersionUID = 4770915224467247458L;
+        
+        private ClassEntry m_classEntry;
+        private String m_name;
+        private Signature m_signature;
+        
+        public MethodEntry(ClassEntry classEntry, String name, Signature signature) {
+                if (classEntry == null) {
+                        throw new IllegalArgumentException("Class cannot be null!");
+                }
+                if (name == null) {
+                        throw new IllegalArgumentException("Method name cannot be null!");
+                }
+                if (signature == null) {
+                        throw new IllegalArgumentException("Method signature cannot be null!");
+                }
+                if (name.startsWith("<")) {
+                        throw new IllegalArgumentException("Don't use MethodEntry for a constructor!");
+                }
+                
+                m_classEntry = classEntry;
+                m_name = name;
+                m_signature = signature;
+        }
+        
+        public MethodEntry(MethodEntry other) {
+                m_classEntry = new ClassEntry(other.m_classEntry);
+                m_name = other.m_name;
+                m_signature = other.m_signature;
+        }
+        
+        public MethodEntry(MethodEntry other, String newClassName) {
+                m_classEntry = new ClassEntry(newClassName);
+                m_name = other.m_name;
+                m_signature = other.m_signature;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String getName() {
+                return m_name;
+        }
+        
+        @Override
+        public Signature getSignature() {
+                return m_signature;
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_classEntry.getName();
+        }
+        
+        @Override
+        public MethodEntry cloneToNewClass(ClassEntry classEntry) {
+                return new MethodEntry(this, classEntry.getName());
+        }
+        
+        @Override
+        public int hashCode() {
+                return Util.combineHashesOrdered(m_classEntry, m_name, m_signature);
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof MethodEntry) {
+                        return equals((MethodEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(MethodEntry other) {
+                return m_classEntry.equals(other.m_classEntry)
+                        && m_name.equals(other.m_name)
+                        && m_signature.equals(other.m_signature);
+        }
+        
+        @Override
+        public String toString() {
+                return m_classEntry.getName() + "." + m_name + m_signature;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java
new file mode 100644
index 00000000..1704428a
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MethodMapping.java
@@ -0,0 +1,161 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class MethodMapping implements Serializable, Comparable<MethodMapping> {
+        
+        private static final long serialVersionUID = -4409570216084263978L;
+        
+        private String m_obfName;
+        private String m_deobfName;
+        private Signature m_obfSignature;
+        private Map<Integer,ArgumentMapping> m_arguments;
+        
+        public MethodMapping(String obfName, Signature obfSignature) {
+                this(obfName, obfSignature, null);
+        }
+        
+        public MethodMapping(String obfName, Signature obfSignature, String deobfName) {
+                if (obfName == null) {
+                        throw new IllegalArgumentException("obf name cannot be null!");
+                }
+                if (obfSignature == null) {
+                        throw new IllegalArgumentException("obf signature cannot be null!");
+                }
+                m_obfName = obfName;
+                m_deobfName = NameValidator.validateMethodName(deobfName);
+                m_obfSignature = obfSignature;
+                m_arguments = new TreeMap<Integer,ArgumentMapping>();
+        }
+        
+        public String getObfName() {
+                return m_obfName;
+        }
+        
+        public String getDeobfName() {
+                return m_deobfName;
+        }
+        
+        public void setDeobfName(String val) {
+                m_deobfName = NameValidator.validateMethodName(val);
+        }
+        
+        public Signature getObfSignature() {
+                return m_obfSignature;
+        }
+        
+        public Iterable<ArgumentMapping> arguments() {
+                return m_arguments.values();
+        }
+        
+        public boolean isConstructor() {
+                return m_obfName.startsWith("<");
+        }
+        
+        public void addArgumentMapping(ArgumentMapping argumentMapping) {
+                boolean wasAdded = m_arguments.put(argumentMapping.getIndex(), argumentMapping) == null;
+                assert (wasAdded);
+        }
+        
+        public String getObfArgumentName(int index) {
+                ArgumentMapping argumentMapping = m_arguments.get(index);
+                if (argumentMapping != null) {
+                        return argumentMapping.getName();
+                }
+                
+                return null;
+        }
+        
+        public String getDeobfArgumentName(int index) {
+                ArgumentMapping argumentMapping = m_arguments.get(index);
+                if (argumentMapping != null) {
+                        return argumentMapping.getName();
+                }
+                
+                return null;
+        }
+        
+        public void setArgumentName(int index, String name) {
+                ArgumentMapping argumentMapping = m_arguments.get(index);
+                if (argumentMapping == null) {
+                        argumentMapping = new ArgumentMapping(index, name);
+                        boolean wasAdded = m_arguments.put(index, argumentMapping) == null;
+                        assert (wasAdded);
+                } else {
+                        argumentMapping.setName(name);
+                }
+        }
+        
+        public void removeArgumentName(int index) {
+                boolean wasRemoved = m_arguments.remove(index) != null;
+                assert (wasRemoved);
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("\t");
+                buf.append(m_obfName);
+                buf.append(" <-> ");
+                buf.append(m_deobfName);
+                buf.append("\n");
+                buf.append("\t");
+                buf.append(m_obfSignature);
+                buf.append("\n");
+                buf.append("\tArguments:\n");
+                for (ArgumentMapping argumentMapping : m_arguments.values()) {
+                        buf.append("\t\t");
+                        buf.append(argumentMapping.getIndex());
+                        buf.append(" -> ");
+                        buf.append(argumentMapping.getName());
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+        
+        @Override
+        public int compareTo(MethodMapping other) {
+                return (m_obfName + m_obfSignature).compareTo(other.m_obfName + other.m_obfSignature);
+        }
+        
+        public boolean renameObfClass(final String oldObfClassName, final String newObfClassName) {
+                
+                // rename obf classes in the signature
+                Signature newSignature = new Signature(m_obfSignature, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                if (className.equals(oldObfClassName)) {
+                                        return newObfClassName;
+                                }
+                                return null;
+                        }
+                });
+                
+                if (!newSignature.equals(m_obfSignature)) {
+                        m_obfSignature = newSignature;
+                        return true;
+                }
+                return false;
+        }
+        
+        public boolean containsArgument(String name) {
+                for (ArgumentMapping argumentMapping : m_arguments.values()) {
+                        if (argumentMapping.getName().equals(name)) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/NameValidator.java b/src/cuchaz/enigma/mapping/NameValidator.java
new file mode 100644
index 00000000..35a17f90
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/NameValidator.java
@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import javassist.bytecode.Descriptor;
+
+public class NameValidator {
+        
+        private static final Pattern IdentifierPattern;
+        private static final Pattern ClassPattern;
+        private static final List<String> ReservedWords = 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 {
+                
+                // java allows all kinds of weird characters...
+                StringBuilder startChars = new StringBuilder();
+                StringBuilder partChars = new StringBuilder();
+                for (int i = Character.MIN_CODE_POINT; i <= Character.MAX_CODE_POINT; i++) {
+                        if (Character.isJavaIdentifierStart(i)) {
+                                startChars.appendCodePoint(i);
+                        }
+                        if (Character.isJavaIdentifierPart(i)) {
+                                partChars.appendCodePoint(i);
+                        }
+                }
+                
+                String identifierRegex = "[A-Za-z_<][A-Za-z0-9_>]*";
+                IdentifierPattern = Pattern.compile(identifierRegex);
+                ClassPattern = Pattern.compile(String.format("^(%s(\\.|/))*(%s)$", identifierRegex, identifierRegex));
+        }
+        
+        public static String validateClassName(String name, boolean packageRequired) {
+                if (name == null) {
+                        return null;
+                }
+                if (!ClassPattern.matcher(name).matches() || ReservedWords.contains(name)) {
+                        throw new IllegalNameException(name, "This doesn't look like a legal class name");
+                }
+                if (packageRequired && new ClassEntry(name).getPackageName() == null) {
+                        throw new IllegalNameException(name, "Class must be in a package");
+                }
+                return Descriptor.toJvmName(name);
+        }
+        
+        public static String validateFieldName(String name) {
+                if (name == null) {
+                        return null;
+                }
+                if (!IdentifierPattern.matcher(name).matches() || ReservedWords.contains(name)) {
+                        throw new IllegalNameException(name, "This doesn't look like a legal identifier");
+                }
+                return name;
+        }
+        
+        public static String validateMethodName(String name) {
+                return validateFieldName(name);
+        }
+        
+        public static String validateArgumentName(String name) {
+                return validateFieldName(name);
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Signature.java b/src/cuchaz/enigma/mapping/Signature.java
new file mode 100644
index 00000000..ff7f8070
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Signature.java
@@ -0,0 +1,109 @@
+package cuchaz.enigma.mapping;
+
+import java.util.List;
+
+import com.beust.jcommander.internal.Lists;
+
+import cuchaz.enigma.Util;
+
+public class Signature {
+        
+        private List<Type> m_argumentTypes;
+        private Type m_returnType;
+        
+        public Signature(String signature) {
+                try {
+                        m_argumentTypes = Lists.newArrayList();
+                        int i=0;
+                        while (i<signature.length()) {
+                                char c = signature.charAt(i);
+                                if (c == '(') {
+                                        assert(m_argumentTypes.isEmpty());
+                                        assert(m_returnType == null);
+                                        i++;
+                                } else if (c == ')') {
+                                        i++;
+                                        break;
+                                } else {
+                                        String type = Type.parseFirst(signature.substring(i));
+                                        m_argumentTypes.add(new Type(type));
+                                        i += type.length();
+                                }
+                        }
+                        m_returnType = new Type(Type.parseFirst(signature.substring(i)));
+                } catch (Exception ex) {
+                        throw new IllegalArgumentException("Unable to parse signature: " + signature, ex);
+                }
+        }
+        
+        public Signature(Signature other, ClassNameReplacer replacer) {
+                m_argumentTypes = Lists.newArrayList(other.m_argumentTypes);
+                for (int i=0; i<m_argumentTypes.size(); i++) {
+                        m_argumentTypes.set(i, new Type(m_argumentTypes.get(i), replacer));
+                }
+                m_returnType = new Type(other.m_returnType, replacer);
+        }
+        
+        public List<Type> getArgumentTypes() {
+                return m_argumentTypes;
+        }
+        
+        public Type getReturnType() {
+                return m_returnType;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("(");
+                for (Type type : m_argumentTypes) {
+                        buf.append(type.toString());
+                }
+                buf.append(")");
+                buf.append(m_returnType.toString());
+                return buf.toString();
+        }
+        
+        public Iterable<Type> types() {
+                List<Type> types = Lists.newArrayList();
+                types.addAll(m_argumentTypes);
+                types.add(m_returnType);
+                return types;
+        }
+        
+        public Iterable<ClassEntry> classes() {
+                List<ClassEntry> out = Lists.newArrayList();
+                for (Type type : types()) {
+                        if (type.isClass()) {
+                                out.add(type.getClassEntry());
+                        }
+                }
+                return out;
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof Signature) {
+                        return equals((Signature)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(Signature other) {
+                return m_argumentTypes.equals(other.m_argumentTypes) && m_returnType.equals(other.m_returnType);
+        }
+        
+        @Override
+        public int hashCode() {
+                return Util.combineHashesOrdered(m_argumentTypes.hashCode(), m_returnType.hashCode());
+        }
+
+        public boolean hasClass(ClassEntry classEntry) {
+                for (Type type : types()) {
+                        if (type.hasClass() && type.getClassEntry().equals(classEntry)) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/SignatureUpdater.java b/src/cuchaz/enigma/mapping/SignatureUpdater.java
new file mode 100644
index 00000000..3477cd56
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/SignatureUpdater.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.List;
+
+import com.google.common.collect.Lists;
+
+public class SignatureUpdater {
+        
+        public interface ClassNameUpdater {
+                String update(String className);
+        }
+        
+        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 = -1;
+                        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 = -1;
+                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, new ClassNameUpdater() {
+                        @Override
+                        public String update(String className) {
+                                classNames.add(className);
+                                return className;
+                        }
+                });
+                return classNames;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/TranslationDirection.java b/src/cuchaz/enigma/mapping/TranslationDirection.java
new file mode 100644
index 00000000..d1b14cd5
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/TranslationDirection.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public enum TranslationDirection {
+        
+        Deobfuscating {
+                @Override
+                public <T> T choose(T deobfChoice, T obfChoice) {
+                        return deobfChoice;
+                }
+        },
+        Obfuscating {
+                @Override
+                public <T> T choose(T deobfChoice, T obfChoice) {
+                        return obfChoice;
+                }
+        };
+        
+        public abstract <T> T choose(T deobfChoice, T obfChoice);
+}
diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java
new file mode 100644
index 00000000..5eba18ce
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Translator.java
@@ -0,0 +1,239 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+import cuchaz.enigma.analysis.TranslationIndex;
+
+public class Translator {
+        
+        private TranslationDirection m_direction;
+        private Map<String,ClassMapping> m_classes;
+        private TranslationIndex m_index;
+        
+        public Translator() {
+                m_direction = null;
+                m_classes = Maps.newHashMap();
+        }
+        
+        public Translator(TranslationDirection direction, Map<String,ClassMapping> classes, TranslationIndex index) {
+                m_direction = direction;
+                m_classes = classes;
+                m_index = index;
+        }
+        
+        @SuppressWarnings("unchecked")
+        public <T extends Entry> T translateEntry(T entry) {
+                if (entry instanceof ClassEntry) {
+                        return (T)translateEntry((ClassEntry)entry);
+                } else if (entry instanceof FieldEntry) {
+                        return (T)translateEntry((FieldEntry)entry);
+                } else if (entry instanceof MethodEntry) {
+                        return (T)translateEntry((MethodEntry)entry);
+                } else if (entry instanceof ConstructorEntry) {
+                        return (T)translateEntry((ConstructorEntry)entry);
+                } else if (entry instanceof ArgumentEntry) {
+                        return (T)translateEntry((ArgumentEntry)entry);
+                } else {
+                        throw new Error("Unknown entry type: " + entry.getClass().getName());
+                }
+        }
+        
+        public String translateClass(String className) {
+                return translate(new ClassEntry(className));
+        }
+        
+        public String translate(ClassEntry in) {
+                ClassMapping classMapping = m_classes.get(in.getOuterClassName());
+                if (classMapping != null) {
+                        if (in.isInnerClass()) {
+                                // translate the inner class
+                                String translatedInnerClassName = m_direction.choose(
+                                        classMapping.getDeobfInnerClassName(in.getInnerClassName()),
+                                        classMapping.getObfInnerClassName(in.getInnerClassName())
+                                );
+                                if (translatedInnerClassName != null) {
+                                        // try to translate the outer name
+                                        String translatedOuterClassName = m_direction.choose(classMapping.getDeobfName(), classMapping.getObfName());
+                                        if (translatedOuterClassName != null) {
+                                                return translatedOuterClassName + "$" + translatedInnerClassName;
+                                        } else {
+                                                return in.getOuterClassName() + "$" + translatedInnerClassName;
+                                        }
+                                }
+                        } else {
+                                // just return outer
+                                return m_direction.choose(classMapping.getDeobfName(), classMapping.getObfName());
+                        }
+                }
+                return null;
+        }
+        
+        public ClassEntry translateEntry(ClassEntry in) {
+                
+                // can we translate the inner class?
+                String name = translate(in);
+                if (name != null) {
+                        return new ClassEntry(name);
+                }
+                
+                if (in.isInnerClass()) {
+                        
+                        // guess not. just translate the outer class name then
+                        String outerClassName = translate(in.getOuterClassEntry());
+                        if (outerClassName != null) {
+                                return new ClassEntry(outerClassName + "$" + in.getInnerClassName());
+                        }
+                }
+                
+                return in;
+        }
+        
+        public String translate(FieldEntry in) {
+                
+                // resolve the class entry
+                ClassEntry resolvedClassEntry = m_index.resolveEntryClass(in);
+                if (resolvedClassEntry != null) {
+                
+                        // look for the class
+                        ClassMapping classMapping = findClassMapping(resolvedClassEntry);
+                        if (classMapping != null) {
+                                
+                                // look for the field
+                                String translatedName = m_direction.choose(
+                                        classMapping.getDeobfFieldName(in.getName()),
+                                        classMapping.getObfFieldName(in.getName())
+                                );
+                                if (translatedName != null) {
+                                        return translatedName;
+                                }
+                        }
+                }
+                return null;
+        }
+        
+        public FieldEntry translateEntry(FieldEntry in) {
+                String name = translate(in);
+                if (name == null) {
+                        name = in.getName();
+                }
+                return new FieldEntry(translateEntry(in.getClassEntry()), name);
+        }
+        
+        public String translate(MethodEntry in) {
+                
+                // resolve the class entry
+                ClassEntry resolvedClassEntry = m_index.resolveEntryClass(in);
+                if (resolvedClassEntry != null) {
+                
+                        // look for class
+                        ClassMapping classMapping = findClassMapping(resolvedClassEntry);
+                        if (classMapping != null) {
+                                
+                                // look for the method
+                                MethodMapping methodMapping = m_direction.choose(
+                                        classMapping.getMethodByObf(in.getName(), in.getSignature()),
+                                        classMapping.getMethodByDeobf(in.getName(), translateSignature(in.getSignature()))
+                                );
+                                if (methodMapping != null) {
+                                        return m_direction.choose(methodMapping.getDeobfName(), methodMapping.getObfName());
+                                }
+                        }
+                }
+                return null;
+        }
+        
+        public MethodEntry translateEntry(MethodEntry in) {
+                String name = translate(in);
+                if (name == null) {
+                        name = in.getName();
+                }
+                return new MethodEntry(translateEntry(in.getClassEntry()), name, translateSignature(in.getSignature()));
+        }
+        
+        public ConstructorEntry translateEntry(ConstructorEntry in) {
+                if (in.isStatic()) {
+                        return new ConstructorEntry(translateEntry(in.getClassEntry()));
+                } else {
+                        return new ConstructorEntry(translateEntry(in.getClassEntry()), translateSignature(in.getSignature()));
+                }
+        }
+        
+        public BehaviorEntry translateEntry(BehaviorEntry in) {
+                if (in instanceof MethodEntry) {
+                        return translateEntry((MethodEntry)in);
+                } else if (in instanceof ConstructorEntry) {
+                        return translateEntry((ConstructorEntry)in);
+                }
+                throw new Error("Wrong entry type!");
+        }
+        
+        public String translate(ArgumentEntry in) {
+                
+                // look for the class
+                ClassMapping classMapping = findClassMapping(in.getClassEntry());
+                if (classMapping != null) {
+                        
+                        // look for the method
+                        MethodMapping methodMapping = m_direction.choose(
+                                classMapping.getMethodByObf(in.getMethodName(), in.getMethodSignature()),
+                                classMapping.getMethodByDeobf(in.getMethodName(), translateSignature(in.getMethodSignature()))
+                        );
+                        if (methodMapping != null) {
+                                return m_direction.choose(
+                                        methodMapping.getDeobfArgumentName(in.getIndex()),
+                                        methodMapping.getObfArgumentName(in.getIndex())
+                                );
+                        }
+                }
+                return null;
+        }
+        
+        public ArgumentEntry translateEntry(ArgumentEntry in) {
+                String name = translate(in);
+                if (name == null) {
+                        name = in.getName();
+                }
+                return new ArgumentEntry(translateEntry(in.getBehaviorEntry()), in.getIndex(), name);
+        }
+        
+        public Type translateType(Type type) {
+                return new Type(type, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                return translateClass(className);
+                        }
+                });
+        }
+        
+        public Signature translateSignature(Signature signature) {
+                return new Signature(signature, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                return translateClass(className);
+                        }
+                });
+        }
+        
+        private ClassMapping findClassMapping(ClassEntry classEntry) {
+                ClassMapping classMapping = m_classes.get(classEntry.getOuterClassName());
+                if (classMapping != null && classEntry.isInnerClass()) {
+                        classMapping = m_direction.choose(
+                                classMapping.getInnerClassByObf(classEntry.getInnerClassName()),
+                                classMapping.getInnerClassByDeobfThenObf(classEntry.getInnerClassName())
+                        );
+                }
+                return classMapping;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Type.java b/src/cuchaz/enigma/mapping/Type.java
new file mode 100644
index 00000000..9f5d52f0
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Type.java
@@ -0,0 +1,218 @@
+package cuchaz.enigma.mapping;
+
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+public class Type {
+        
+        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> m_lookup;
+                
+                static {
+                        m_lookup = Maps.newTreeMap();
+                        for (Primitive val : values()) {
+                                m_lookup.put(val.getCode(), val);
+                        }
+                }
+                
+                public static Primitive get(char code) {
+                        return m_lookup.get(code);
+                }
+                
+                private char m_code;
+                
+                private Primitive(char code) {
+                        m_code = code;
+                }
+        
+                public char getCode() {
+                        return m_code;
+                }
+        }
+        
+        public static String parseFirst(String in) {
+                
+                if (in == null || in.length() <= 0) {
+                        throw new IllegalArgumentException("No type to parse, input is empty!");
+                }
+                
+                // read one type 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 arrays
+                int dim = countArrayDimension(in);
+                if (dim > 0) {
+                        String arrayType = Type.parseFirst(in.substring(dim));
+                        return in.substring(0, dim + arrayType.length());
+                }
+                
+                throw new IllegalArgumentException("don't know how to parse: " + in);
+        }
+                
+        private String m_name;
+        
+        public Type(String name) {
+                m_name = name;
+        }
+        
+        public Type(ClassEntry classEntry) {
+                m_name = "L" + classEntry.getClassName() + ";";
+        }
+        
+        public Type(Type type, ClassNameReplacer replacer) {
+                m_name = type.m_name;
+                if (type.isClass()) {
+                        String replacedName = replacer.replace(type.getClassEntry().getClassName());
+                        if (replacedName != null) {
+                                m_name = "L" + replacedName + ";";
+                        }
+                } else if (type.isArray() && type.hasClass()) {
+                        String replacedName = replacer.replace(type.getClassEntry().getClassName());
+                        if (replacedName != null) {
+                                m_name = Type.getArrayPrefix(type.getArrayDimension()) + "L" + replacedName + ";";
+                        }
+                }
+        }
+        
+        @Override
+        public String toString() {
+                return m_name;
+        }
+        
+        public boolean isVoid() {
+                return m_name.length() == 1 && m_name.charAt(0) == 'V';
+        }
+        
+        public boolean isPrimitive() {
+                return m_name.length() == 1 && Primitive.get(m_name.charAt(0)) != null;
+        }
+        
+        public Primitive getPrimitive() {
+                if (!isPrimitive()) {
+                        throw new IllegalStateException("not a primitive");
+                }
+                return Primitive.get(m_name.charAt(0));
+        }
+        
+        public boolean isClass() {
+                return m_name.charAt(0) == 'L' && m_name.charAt(m_name.length() - 1) == ';';
+        }
+        
+        public ClassEntry getClassEntry() {
+                if (isClass()) {
+                        String name = m_name.substring(1, m_name.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().isClass()) {
+                        return getArrayType().getClassEntry();
+                } else {
+                        throw new IllegalStateException("type doesn't have a class");
+                }
+        }
+        
+        public boolean isArray() {
+                return m_name.charAt(0) == '[';
+        }
+        
+        public int getArrayDimension() {
+                if (!isArray()) {
+                        throw new IllegalStateException("not an array");
+                }
+                return countArrayDimension(m_name);
+        }
+        
+        public Type getArrayType() {
+                if (!isArray()) {
+                        throw new IllegalStateException("not an array");
+                }
+                return new Type(m_name.substring(getArrayDimension(), m_name.length()));
+        }
+        
+        private static String getArrayPrefix(int dimension) {
+                StringBuilder buf = new StringBuilder();
+                for (int i=0; i<dimension; i++) {
+                        buf.append("[");
+                }
+                return buf.toString();
+        }
+        
+        public boolean hasClass() {
+                return isClass() || (isArray() && getArrayType().hasClass());
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof Type) {
+                        return equals((Type)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(Type other) {
+                return m_name.equals(other.m_name);
+        }
+        
+        public int hashCode() {
+                return m_name.hashCode();
+        }
+        
+        private static int countArrayDimension(String in) {
+                int i=0;
+                for(; 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 ';'
+                // remember to treat parameters correctly
+                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;
+        }
+}