32 files changed, 831 insertions, 132 deletions
diff --git a/src/main/java/cuchaz/enigma/Constants.java b/src/main/java/cuchaz/enigma/Constants.java
index 5bdb3af7..04730480 100644
--- a/src/main/java/cuchaz/enigma/Constants.java
+++ b/src/main/java/cuchaz/enigma/Constants.java
@@ -16,5 +16,4 @@ public class Constants {
    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 NONE_PACKAGE = "none";
 }
diff --git a/src/main/java/cuchaz/enigma/Deobfuscator.java b/src/main/java/cuchaz/enigma/Deobfuscator.java
index 20bb8b98..2766380b 100644
--- a/src/main/java/cuchaz/enigma/Deobfuscator.java
+++ b/src/main/java/cuchaz/enigma/Deobfuscator.java
@@ -146,7 +146,7 @@ public class Deobfuscator {
            if (!deobfClassEntry.equals(obfClassEntry)) {
                // if the class has a mapping, clearly it's deobfuscated
                deobfClasses.add(deobfClassEntry);
-            } else if (!obfClassEntry.getPackageName().equals(Constants.NONE_PACKAGE)) {
+            } else if (obfClassEntry.getPackageName() != null) {
                // also call it deobufscated if it's not in the none package
                deobfClasses.add(obfClassEntry);
            } else {
@@ -532,12 +532,20 @@ public class Deobfuscator {
            return false;
        } else if (obfEntry instanceof ArgumentEntry) {
            return translator.translate((ArgumentEntry) obfEntry) != null;
+        } else if (obfEntry instanceof LocalVariableEntry) {
+            // TODO: Implement it
+            //return translator.translate((LocalVariableEntry)obfEntry) != null;
+            return false;
        } else {
            throw new Error("Unknown entry type: " + obfEntry.getClass().getName());
        }
    }
    public void rename(Entry obfEntry, String newName) {
+        rename(obfEntry, newName, true);
+    }
+    public void rename(Entry obfEntry, String newName, boolean clearCache) {
        if (obfEntry instanceof ClassEntry) {
            this.renamer.setClassName((ClassEntry) obfEntry, Descriptor.toJvmName(newName));
        } else if (obfEntry instanceof FieldEntry) {
@@ -548,12 +556,15 @@ public class Deobfuscator {
            throw new IllegalArgumentException("Cannot rename constructors");
        } else if (obfEntry instanceof ArgumentEntry) {
            this.renamer.setArgumentTreeName((ArgumentEntry) obfEntry, newName);
+        } else if (obfEntry instanceof LocalVariableEntry) {
+            // TODO: Implement it
        } else {
            throw new Error("Unknown entry type: " + obfEntry.getClass().getName());
        }
        // clear caches
-        this.translatorCache.clear();
+        if (clearCache)
+            this.translatorCache.clear();
    }
    public void removeMapping(Entry obfEntry) {
@@ -586,6 +597,8 @@ public class Deobfuscator {
            throw new IllegalArgumentException("Cannot rename constructors");
        } else if (obfEntry instanceof ArgumentEntry) {
            this.renamer.markArgumentAsDeobfuscated((ArgumentEntry) obfEntry);
+        } else if (obfEntry instanceof LocalVariableEntry) {
+            // TODO: Implement it
        } else {
            throw new Error("Unknown entry type: " + obfEntry);
        }
@@ -593,4 +606,25 @@ public class Deobfuscator {
        // clear caches
        this.translatorCache.clear();
    }
+    public void changeModifier(Entry entry, Mappings.EntryModifier modifierEntry)
+    {
+        Entry obfEntry = obfuscateEntry(entry);
+        if (obfEntry instanceof ClassEntry)
+            this.renamer.setClassModifier((ClassEntry) obfEntry, modifierEntry);
+        else if (obfEntry instanceof FieldEntry)
+            this.renamer.setFieldModifier((FieldEntry) obfEntry, modifierEntry);
+        else if (obfEntry instanceof BehaviorEntry)
+            this.renamer.setMethodModifier((BehaviorEntry) obfEntry, modifierEntry);
+        else
+            throw new Error("Unknown entry type: " + obfEntry);
+    }
+    public Mappings.EntryModifier getModifier(Entry obEntry)
+    {
+        Entry entry = obfuscateEntry(obEntry);
+        if (entry != null)
+            obEntry = entry;
+        return getTranslator(TranslationDirection.Deobfuscating).getModifier(obEntry);
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java b/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java
index 13efbd51..73405662 100644
--- a/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java
+++ b/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java
@@ -187,10 +187,6 @@ public class TranslatingTypeLoader implements ITypeLoader {
    public List<String> getClassNamesToTry(ClassEntry obfClassEntry) {
        List<String> classNamesToTry = Lists.newArrayList();
        classNamesToTry.add(obfClassEntry.getName());
-        if (obfClassEntry.getPackageName().equals(Constants.NONE_PACKAGE)) {
-            // taking off the none package, if any
-            classNamesToTry.add(obfClassEntry.getSimpleName());
-        }
        if (obfClassEntry.isInnerClass()) {
            // try just the inner class name
            classNamesToTry.add(obfClassEntry.getInnermostClassName());
@@ -201,12 +197,8 @@ public class TranslatingTypeLoader implements ITypeLoader {
    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.NONE_PACKAGE);
        // reconstruct inner classes
-        new InnerClassWriter(this.jarIndex).write(c);
+        new InnerClassWriter(this.jarIndex, this.deobfuscatingTranslator).write(c);
        // re-get the javassist handle since we changed class names
        ClassEntry obfClassEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
diff --git a/src/main/java/cuchaz/enigma/analysis/JarIndex.java b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
index e501540d..ee1dd544 100644
--- a/src/main/java/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
@@ -59,17 +59,10 @@ public class JarIndex {
    public void indexJar(JarFile jar, boolean buildInnerClasses) {
        // step 1: read the class names
-        for (ClassEntry classEntry : JarClassIterator.getClassEntries(jar)) {
+        this.obfClassEntries.addAll(JarClassIterator.getClassEntries(jar));
-            if (classEntry.isInDefaultPackage()) {
-                // move out of default package
-                classEntry = new ClassEntry(Constants.NONE_PACKAGE + "/" + classEntry.getName());
-            }
-            this.obfClassEntries.add(classEntry);
-        }
        // step 2: index field/method/constructor access
        for (CtClass c : JarClassIterator.classes(jar)) {
-            ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE);
            for (CtField field : c.getDeclaredFields()) {
                FieldEntry fieldEntry = EntryFactory.getFieldEntry(field);
                this.access.put(fieldEntry, Access.get(field));
@@ -84,7 +77,6 @@ public class JarIndex {
        // step 3: index extends, implements, fields, and methods
        for (CtClass c : JarClassIterator.classes(jar)) {
-            ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE);
            this.translationIndex.indexClass(c);
            String className = Descriptor.toJvmName(c.getName());
            for (String interfaceName : c.getClassFile().getInterfaces()) {
@@ -101,7 +93,6 @@ public class JarIndex {
        // step 4: index field, method, constructor references
        for (CtClass c : JarClassIterator.classes(jar)) {
-            ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE);
            for (CtBehavior behavior : c.getDeclaredBehaviors()) {
                indexBehaviorReferences(behavior);
            }
@@ -111,7 +102,6 @@ public class JarIndex {
            // step 5: index inner classes and anonymous classes
            for (CtClass c : JarClassIterator.classes(jar)) {
-                ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE);
                ClassEntry innerClassEntry = EntryFactory.getClassEntry(c);
                ClassEntry outerClassEntry = findOuterClass(c);
                if (outerClassEntry != null) {
@@ -781,6 +771,14 @@ public class JarIndex {
        return this.access.containsKey(obfBehaviorEntry);
    }
+    public boolean containsEntryWithSameName(Entry entry)
+    {
+        for (Entry target : this.access.keySet())
+            if (target.getName().equals(entry.getName()) && entry.getClass().isInstance(target.getClass()))
+                return true;
+        return false;
+    }
    public boolean containsObfArgument(ArgumentEntry obfArgumentEntry) {
        // check the behavior
        if (!containsObfBehavior(obfArgumentEntry.getBehaviorEntry())) {
@@ -801,6 +799,9 @@ public class JarIndex {
            return containsObfBehavior((BehaviorEntry) obfEntry);
        } else if (obfEntry instanceof ArgumentEntry) {
            return containsObfArgument((ArgumentEntry) obfEntry);
+        } else if (obfEntry instanceof LocalVariableEntry) {
+            // TODO: Implement it
+            return false;
        } else {
            throw new Error("Entry type not supported: " + obfEntry.getClass().getName());
        }
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
index c328f5f1..e690abdf 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
@@ -10,6 +10,9 @@
 ******************************************************************************/
 package cuchaz.enigma.analysis;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
 import com.strobel.assembler.metadata.MemberReference;
 import com.strobel.assembler.metadata.MethodReference;
 import com.strobel.assembler.metadata.ParameterDefinition;
@@ -17,6 +20,7 @@ import com.strobel.assembler.metadata.TypeReference;
 import com.strobel.decompiler.languages.TextLocation;
 import com.strobel.decompiler.languages.java.ast.*;
 import cuchaz.enigma.mapping.*;
+import javassist.bytecode.Descriptor;
 import java.util.HashMap;
 import java.util.Map;
@@ -27,11 +31,14 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
    // TODO: Really fix Procyon index problem with inner classes
    private int argumentPosition;
-    private Map<String, Entry> argumentCache = new HashMap<>();
+    private int localsPosition;
+    private Multimap<String, Identifier> unmatchedIdentifier = HashMultimap.create();
+    private Map<String, Entry> identifierEntryCache = new HashMap<>();
    public SourceIndexBehaviorVisitor(BehaviorEntry behaviorEntry) {
        this.behaviorEntry = behaviorEntry;
        this.argumentPosition = 0;
+        this.localsPosition = 0;
    }
    @Override
@@ -66,6 +73,9 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
            }
        }
+        // Check for identifier
+        node.getArguments().stream().filter(expression -> expression instanceof IdentifierExpression)
+                .forEach(expression -> this.checkIdentifier((IdentifierExpression) expression, index));
        return recurse(node, index);
    }
@@ -106,7 +116,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
                    argumentPosition++, node.getName());
            Identifier identifier = node.getNameToken();
            // cache the argument entry and the identifier
-            argumentCache.put(identifier.getName(), argumentEntry);
+            identifierEntryCache.put(identifier.getName(), argumentEntry);
            index.addDeclaration(identifier, argumentEntry);
        }
@@ -121,12 +131,31 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
            FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new Type(ref.getErasedSignature()));
            index.addReference(node.getIdentifierToken(), fieldEntry, this.behaviorEntry);
        }
-        else if (argumentCache.containsKey(node.getIdentifier())) // If it's in the argument cache, create a token!
+        else
-            index.addDeclaration(node.getIdentifierToken(), argumentCache.get(node.getIdentifier()));
+            this.checkIdentifier(node, index);
        return recurse(node, index);
    }
+    private void checkIdentifier(IdentifierExpression node, SourceIndex index)
+    {
+        if (identifierEntryCache.containsKey(node.getIdentifier())) // If it's in the argument cache, create a token!
+            index.addDeclaration(node.getIdentifierToken(), identifierEntryCache.get(node.getIdentifier()));
+        else
+            unmatchedIdentifier.put(node.getIdentifier(), node.getIdentifierToken()); // Not matched actually, put it!
+    }
+    private void addDeclarationToUnmatched(String key, SourceIndex index)
+    {
+        Entry entry = identifierEntryCache.get(key);
+        // This cannot happened in theory
+        if (entry == null)
+            return;
+        for (Identifier identifier : unmatchedIdentifier.get(key))
+            index.addDeclaration(identifier, entry);
+        unmatchedIdentifier.removeAll(key);
+    }
    @Override
    public Void visitObjectCreationExpression(ObjectCreationExpression node, SourceIndex index) {
        MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
@@ -141,4 +170,43 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
        return recurse(node, index);
    }
+    @Override
+    public Void visitForEachStatement(ForEachStatement node, SourceIndex index) {
+        if (node.getVariableType() instanceof SimpleType)
+        {
+            SimpleType type = (SimpleType) node.getVariableType();
+            TypeReference typeReference = type.getUserData(Keys.TYPE_REFERENCE);
+            Identifier identifier = node.getVariableNameToken();
+            String signature = Descriptor.of(typeReference.getErasedDescription());
+            LocalVariableEntry localVariableEntry = new LocalVariableEntry(behaviorEntry, localsPosition++, identifier.getName(), new Type(signature));
+            identifierEntryCache.put(identifier.getName(), localVariableEntry);
+            addDeclarationToUnmatched(identifier.getName(), index);
+            index.addDeclaration(identifier, localVariableEntry);
+        }
+        return recurse(node, index);
+    }
+    @Override
+    public Void visitVariableDeclaration(VariableDeclarationStatement node, SourceIndex index) {
+        AstNodeCollection<VariableInitializer> variables = node.getVariables();
+        // Single assignation
+        if (variables.size() == 1)
+        {
+            VariableInitializer initializer = variables.firstOrNullObject();
+            if (initializer != null && node.getType() instanceof SimpleType)
+            {
+                SimpleType type = (SimpleType) node.getType();
+                TypeReference typeReference = type.getUserData(Keys.TYPE_REFERENCE);
+                String signature = Descriptor.of(typeReference.getErasedDescription());
+                Identifier identifier = initializer.getNameToken();
+                LocalVariableEntry localVariableEntry = new LocalVariableEntry(behaviorEntry, localsPosition++, initializer.getName(), new Type(signature));
+                identifierEntryCache.put(identifier.getName(), localVariableEntry);
+                addDeclarationToUnmatched(identifier.getName(), index);
+                index.addDeclaration(identifier, localVariableEntry);
+            }
+        }
+        return recurse(node, index);
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java b/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
index 25edaef4..d51131f6 100644
--- a/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
@@ -181,6 +181,8 @@ public class TranslationIndex {
            return behaviorExists((BehaviorEntry) entry);
        } else if (entry instanceof ArgumentEntry) {
            return behaviorExists(((ArgumentEntry) entry).getBehaviorEntry());
+        } else if (entry instanceof LocalVariableEntry) {
+            return behaviorExists(((LocalVariableEntry) entry).getBehaviorEntry());
        }
        throw new IllegalArgumentException("Cannot check existence for " + entry.getClass());
    }
diff --git a/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java b/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java
index eb7e9a17..d49f13ab 100644
--- a/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java
+++ b/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java
@@ -19,8 +19,9 @@ import java.util.Map;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.ClassNameReplacer;
+import cuchaz.enigma.mapping.Mappings;
 import cuchaz.enigma.mapping.Translator;
-import javassist.CtClass;
+import javassist.*;
 import javassist.bytecode.*;
 import javassist.bytecode.SignatureAttribute.*;
@@ -70,6 +71,41 @@ public class ClassRenamer {
        }
    }
+    public static void applyModifier(Object obj, Mappings.EntryModifier modifier)
+    {
+        int mod = -1;
+        if (obj instanceof CtField)
+            mod = ((CtField) obj).getModifiers();
+        else if (obj instanceof CtBehavior)
+            mod = ((CtBehavior) obj).getModifiers();
+        else if (obj instanceof CtClass)
+            mod = ((CtClass) obj).getModifiers();
+        if (mod != -1)
+        {
+            switch (modifier)
+            {
+                case PRIVATE:
+                    mod = Modifier.setPrivate(mod);
+                    break;
+                case PROTECTED:
+                    mod = Modifier.setProtected(mod);
+                    break;
+                case PUBLIC:
+                    mod = Modifier.setPublic(mod);
+                    break;
+                default:
+                    break;
+            }
+            if (obj instanceof CtField)
+                ((CtField) obj).setModifiers(mod);
+            else if (obj instanceof CtBehavior)
+                ((CtBehavior) obj).setModifiers(mod);
+            else
+                ((CtClass) obj).setModifiers(mod);
+        }
+    }
    public static void renameClasses(CtClass c, final Translator translator) {
        renameClasses(c, className -> {
            ClassEntry entry = translator.translateEntry(new ClassEntry(className));
@@ -110,6 +146,7 @@ public class ClassRenamer {
        // rename the constant pool (covers ClassInfo, MethodTypeInfo, and NameAndTypeInfo)
        ConstPool constPool = c.getClassFile().getConstPool();
+        String className = constPool.getClassName();
        constPool.renameClass(map);
        // rename class attributes
@@ -140,8 +177,9 @@ public class ClassRenamer {
        if (attr != null) {
            for (int i = 0; i < attr.tableLength(); i++) {
+                String innerName = attr.innerClass(i);
                // get the inner class full name (which has already been translated)
-                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i)));
+                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(innerName));
                if (attr.innerNameIndex(i) != 0) {
                    // update the inner name
diff --git a/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java b/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java
index 6c05b838..62ebfafb 100644
--- a/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java
+++ b/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -11,14 +11,9 @@
 package cuchaz.enigma.bytecode;
 import cuchaz.enigma.mapping.*;
-import javassist.CtBehavior;
+import cuchaz.enigma.mapping.Translator;
-import javassist.CtClass;
+import javassist.*;
-import javassist.CtField;
+import javassist.bytecode.*;
-import javassist.CtMethod;
-import javassist.bytecode.ConstPool;
-import javassist.bytecode.Descriptor;
-import javassist.bytecode.EnclosingMethodAttribute;
-import javassist.bytecode.SourceFileAttribute;
 public class ClassTranslator {
@@ -74,6 +69,9 @@ public class ClassTranslator {
        }
        ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+        Mappings.EntryModifier modifier = this.translator.getModifier(classEntry);
+        if (modifier != null && modifier != Mappings.EntryModifier.UNCHANGED)
+            ClassRenamer.applyModifier(c, modifier);
        // translate all the fields
        for (CtField field : c.getDeclaredFields()) {
@@ -81,6 +79,10 @@ public class ClassTranslator {
            // translate the name
            FieldEntry entry = EntryFactory.getFieldEntry(field);
            String translatedName = this.translator.translate(entry);
+            modifier = this.translator.getModifier(entry);
+            if (modifier != null && modifier != Mappings.EntryModifier.UNCHANGED)
+                ClassRenamer.applyModifier(field, modifier);
            if (translatedName != null) {
                field.setName(translatedName);
            }
@@ -95,6 +97,10 @@ public class ClassTranslator {
            BehaviorEntry entry = EntryFactory.getBehaviorEntry(behavior);
+            modifier = this.translator.getModifier(entry);
+            if (modifier != null && modifier != Mappings.EntryModifier.UNCHANGED)
+                ClassRenamer.applyModifier(behavior, modifier);
            if (behavior instanceof CtMethod) {
                CtMethod method = (CtMethod) behavior;
@@ -149,5 +155,8 @@ public class ClassTranslator {
            String sourceFile = Descriptor.toJvmName(deobfClassEntry.getOutermostClassEntry().getSimpleName()) + ".java";
            c.getClassFile().addAttribute(new SourceFileAttribute(constants, sourceFile));
        }
+        InnerClassesAttribute attr = (InnerClassesAttribute) c.getClassFile().getAttribute(InnerClassesAttribute.tag);
+        if (attr != null)
+            InnerClassWriter.changeModifier(c, attr, translator);
    }
 }
diff --git a/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java b/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java
index 6d926106..6e2a29d5 100644
--- a/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java
+++ b/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java
@@ -15,22 +15,22 @@ import com.google.common.collect.Lists;
 import java.util.Collection;
 import java.util.List;
+import cuchaz.enigma.Deobfuscator;
 import cuchaz.enigma.analysis.JarIndex;
-import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.*;
-import cuchaz.enigma.mapping.ClassEntry;
+import javassist.ClassPool;
-import cuchaz.enigma.mapping.EntryFactory;
 import javassist.CtClass;
-import javassist.bytecode.AccessFlag;
+import javassist.NotFoundException;
-import javassist.bytecode.ConstPool;
+import javassist.bytecode.*;
-import javassist.bytecode.EnclosingMethodAttribute;
-import javassist.bytecode.InnerClassesAttribute;
 public class InnerClassWriter {
    private JarIndex index;
+    private Translator deobfuscatorTranslator;
-    public InnerClassWriter(JarIndex index) {
+    public InnerClassWriter(JarIndex index, Translator deobfuscatorTranslator) {
        this.index = index;
+        this.deobfuscatorTranslator = deobfuscatorTranslator;
    }
    public void write(CtClass c) {
@@ -96,6 +96,29 @@ public class InnerClassWriter {
        }
    }
+    // FIXME: modiffier is not applied to inner class
+    public static void changeModifier(CtClass c, InnerClassesAttribute attr, Translator translator)
+    {
+        ClassPool pool = c.getClassPool();
+        for (int i = 0; i < attr.tableLength(); i++) {
+            String innerName = attr.innerClass(i);
+            // get the inner class full name (which has already been translated)
+            ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(innerName));
+            try
+            {
+                CtClass innerClass = pool.get(innerName);
+                Mappings.EntryModifier modifier = translator.getModifier(classEntry);
+                if (modifier != null && modifier != Mappings.EntryModifier.UNCHANGED)
+                    ClassRenamer.applyModifier(innerClass, modifier);
+            } catch (NotFoundException e)
+            {
+                // This shouldn't be possible in theory
+                //e.printStackTrace();
+            }
+        }
+    }
    private void writeInnerClass(InnerClassesAttribute attr, List<ClassEntry> obfClassChain, ClassEntry obfClassEntry) {
        // get the new inner class name
diff --git a/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java b/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java
index 3f4b96f9..24b5f363 100644
--- a/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java
+++ b/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java
@@ -76,11 +76,27 @@ public class LocalVariableRenamer {
        int numArgs = 0;
        if (behaviorEntry.getSignature() != null) {
            numArgs = behaviorEntry.getSignature().getArgumentTypes().size();
+            boolean isNestedClassConstructor = false;
+            // If the behavior is a constructor and if it have more than one arg, it's probably from a nested!
+            if (behaviorEntry instanceof ConstructorEntry && behaviorEntry.getClassEntry() != null && behaviorEntry.getClassEntry().isInnerClass() && numArgs >= 1)
+            {
+                // Get the first arg type
+                Type firstArg = behaviorEntry.getSignature().getArgumentTypes().get(0);
+                // If the arg is a class and if the class name match the outer class name of the constructor, it's definitely a constructor of a nested class
+                if (firstArg.isClass() && firstArg.getClassEntry().equals(behaviorEntry.getClassEntry().getOuterClassEntry())) {
+                    isNestedClassConstructor = true;
+                    numArgs--;
+                }
+            }
            for (int i = starti; i < starti + numArgs && i < table.tableLength(); i++) {
                int argi = i - starti;
                String argName = this.translator.translate(new ArgumentEntry(behaviorEntry, argi, ""));
                if (argName == null) {
-                    Type argType = behaviorEntry.getSignature().getArgumentTypes().get(argi);
+                    Type argType = behaviorEntry.getSignature().getArgumentTypes().get(isNestedClassConstructor ? argi + 1 : argi);
                    // Unfortunately each of these have different name getters, so they have different code paths
                    if (argType.isPrimitive()) {
                        Type.Primitive argCls = argType.getPrimitive();
diff --git a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java
index 0960c86b..73600114 100644
--- a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java
+++ b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java
@@ -58,7 +58,7 @@ public class ClassIdentity {
            // classes not in the none package can be passed through
            ClassEntry classEntry = new ClassEntry(className);
-            if (!classEntry.getPackageName().equals(Constants.NONE_PACKAGE)) {
+            if (classEntry.getPackageName() != null) {
                return className;
            }
diff --git a/src/main/java/cuchaz/enigma/convert/MappingsConverter.java b/src/main/java/cuchaz/enigma/convert/MappingsConverter.java
index 3d2cb86a..929c89f2 100644
--- a/src/main/java/cuchaz/enigma/convert/MappingsConverter.java
+++ b/src/main/java/cuchaz/enigma/convert/MappingsConverter.java
@@ -243,7 +243,7 @@ public class MappingsConverter {
        // non obfuscated classes can be migrated
        ClassEntry classEntry = oldObfType.getClassEntry();
-        if (!classEntry.getPackageName().equals(Constants.NONE_PACKAGE)) {
+        if (classEntry.getPackageName() != null) {
            return true;
        }
diff --git a/src/main/java/cuchaz/enigma/gui/ClassMatchingGui.java b/src/main/java/cuchaz/enigma/gui/ClassMatchingGui.java
index 3cd1705a..edf1e30b 100644
--- a/src/main/java/cuchaz/enigma/gui/ClassMatchingGui.java
+++ b/src/main/java/cuchaz/enigma/gui/ClassMatchingGui.java
@@ -131,7 +131,7 @@ public class ClassMatchingGui {
            sourceTypePanel.add(button);
        }
-        m_sourceClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR);
+        m_sourceClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false);
        m_sourceClasses.setSelectionListener(this::setSourceClass);
        JScrollPane sourceScroller = new JScrollPane(m_sourceClasses);
        sourcePanel.add(sourceScroller);
@@ -147,7 +147,7 @@ public class ClassMatchingGui {
        destPanel.add(m_top10Matches);
        m_top10Matches.addActionListener(event -> toggleTop10Matches());
-        m_destClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR);
+        m_destClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false);
        m_destClasses.setSelectionListener(this::setDestClass);
        JScrollPane destScroller = new JScrollPane(m_destClasses);
        destPanel.add(destScroller);
diff --git a/src/main/java/cuchaz/enigma/gui/ClassSelector.java b/src/main/java/cuchaz/enigma/gui/ClassSelector.java
index 92fcaba0..435509e5 100644
--- a/src/main/java/cuchaz/enigma/gui/ClassSelector.java
+++ b/src/main/java/cuchaz/enigma/gui/ClassSelector.java
@@ -44,7 +44,7 @@ public class ClassSelector extends JTree {
    private RenameSelectionListener renameSelectionListener;
    private Comparator<ClassEntry> comparator;
-    public ClassSelector(Gui gui, Comparator<ClassEntry> comparator) {
+    public ClassSelector(Gui gui, Comparator<ClassEntry> comparator, boolean isRenamable) {
        this.comparator = comparator;
        // configure the tree control
@@ -77,7 +77,7 @@ public class ClassSelector extends JTree {
            {
                @Override public boolean isCellEditable(EventObject event)
                {
-                    return !(event instanceof MouseEvent) && super.isCellEditable(event);
+                    return isRenamable && !(event instanceof MouseEvent) && super.isCellEditable(event);
                }
            };
            this.setCellEditor(editor);
@@ -112,7 +112,7 @@ public class ClassSelector extends JTree {
                            try
                            {
                                renameSelectionListener.onSelectionRename(node.getUserObject(), objectData, node);
-                                node.setUserObject(objectData);
+                                node.setUserObject(objectData); // Make sure that it's modified
                            } catch (IllegalNameException ex)
                            {
                                JOptionPane.showOptionDialog(gui.getFrame(), ex.getMessage(), "Enigma - Error", JOptionPane.OK_OPTION,
@@ -181,6 +181,10 @@ public class ClassSelector extends JTree {
            // I can never keep this rule straight when writing these damn things...
            // a < b => -1, a == b => 0, a > b => +1
+            if(b == null || a == null){
+                return 0;
+            }
            String[] aparts = a.split("/");
            String[] bparts = b.split("/");
            for (int i = 0; true; i++) {
@@ -447,6 +451,51 @@ public class ClassSelector extends JTree {
        model.insertNodeInto(classNode, packageNode, getPlacementIndex(packageNode, classNode));
    }
+    public void reload()
+    {
+        DefaultTreeModel model = (DefaultTreeModel) getModel();
+        model.reload(sort(rootNodes));
+    }
+    private DefaultMutableTreeNode sort(DefaultMutableTreeNode node) {
+        for(int i = 0; i < node.getChildCount() - 1; i++) {
+            DefaultMutableTreeNode child = (DefaultMutableTreeNode) node.getChildAt(i);
+            if (child == null)
+                continue;
+            String nt = child.toString();
+            for(int j = i + 1; j <= node.getChildCount() - 1; j++) {
+                DefaultMutableTreeNode prevNode = (DefaultMutableTreeNode) node.getChildAt(j);
+                if (prevNode == null || prevNode.getUserObject() == null)
+                    continue;
+                String np = prevNode.getUserObject().toString();
+                if(nt.compareToIgnoreCase(np) > 0) {
+                    node.insert(child, j);
+                    node.insert(prevNode, i);
+                }
+            }
+            if(child.getChildCount() > 0) {
+                sort(child);
+            }
+        }
+        for(int i = 0; i < node.getChildCount() - 1; i++) {
+            DefaultMutableTreeNode child = (DefaultMutableTreeNode) node.getChildAt(i);
+            for(int j = i + 1; j <= node.getChildCount() - 1; j++) {
+                DefaultMutableTreeNode prevNode = (DefaultMutableTreeNode) node.getChildAt(j);
+                if(!prevNode.isLeaf() && child.isLeaf()) {
+                    node.insert(child, j);
+                    node.insert(prevNode, i);
+                }
+            }
+        }
+        return node;
+    }
    private int getPlacementIndex(ClassSelectorPackageNode newPackageNode, ClassSelectorClassNode classNode)
    {
        List<ClassSelectorClassNode> classNodes = classNodes(newPackageNode);
diff --git a/src/main/java/cuchaz/enigma/gui/Gui.java b/src/main/java/cuchaz/enigma/gui/Gui.java
index 0ccb3f79..ed18777a 100644
--- a/src/main/java/cuchaz/enigma/gui/Gui.java
+++ b/src/main/java/cuchaz/enigma/gui/Gui.java
@@ -136,6 +136,9 @@ public class Gui {
        m_selectionHighlightPainter = new SelectionHighlightPainter();
        this.editor = new PanelEditor(this);
        JScrollPane sourceScroller = new JScrollPane(this.editor);
+        this.editor.setContentType("text/java");
+        DefaultSyntaxKit kit = (DefaultSyntaxKit) this.editor.getEditorKit();
+        kit.toggleComponent(this.editor, "de.sciss.syntaxpane.components.TokenMarker");
        // init editor popup menu
        this.popupMenu = new PopupMenuBar(this);
@@ -439,6 +442,8 @@ public class Gui {
            showConstructorEntry((ConstructorEntry) m_reference.entry);
        } else if (m_reference.entry instanceof ArgumentEntry) {
            showArgumentEntry((ArgumentEntry) m_reference.entry);
+        } else if (m_reference.entry instanceof LocalVariableEntry) {
+            showLocalVariableEntry((LocalVariableEntry) m_reference.entry);
        } else {
            throw new Error("Unknown entry type: " + m_reference.entry.getClass().getName());
        }
@@ -446,26 +451,39 @@ public class Gui {
        redraw();
    }
+    private void showLocalVariableEntry(LocalVariableEntry entry) {
+        addNameValue(m_infoPanel, "Variable", entry.getName());
+        addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
+        addNameValue(m_infoPanel, "Method", entry.getBehaviorEntry().getName());
+        addNameValue(m_infoPanel, "Index", Integer.toString(entry.getIndex()));
+        addNameValue(m_infoPanel, "Type", entry.getType().toString());
+    }
    private void showClassEntry(ClassEntry entry) {
        addNameValue(m_infoPanel, "Class", entry.getName());
+        addModifierComboBox(m_infoPanel, "Modifier", entry);
    }
    private void showFieldEntry(FieldEntry entry) {
        addNameValue(m_infoPanel, "Field", entry.getName());
        addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
        addNameValue(m_infoPanel, "Type", entry.getType().toString());
+        addModifierComboBox(m_infoPanel, "Modifier", entry);
    }
    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());
+        addModifierComboBox(m_infoPanel, "Modifier", entry);
    }
    private void showConstructorEntry(ConstructorEntry entry) {
        addNameValue(m_infoPanel, "Constructor", entry.getClassEntry().getName());
        if (!entry.isStatic()) {
            addNameValue(m_infoPanel, "Signature", entry.getSignature().toString());
+            addModifierComboBox(m_infoPanel, "Modifier", entry);
        }
    }
@@ -488,6 +506,25 @@ public class Gui {
        panel.add(Utils.unboldLabel(new JLabel(value, JLabel.LEFT)));
    }
+    private JComboBox<Mappings.EntryModifier> addModifierComboBox(JPanel container, String name, Entry entry)
+    {
+        if (!getController().entryIsInJar(entry))
+            return null;
+        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);
+        JComboBox<Mappings.EntryModifier> combo = new JComboBox<>(Mappings.EntryModifier.values());
+        ((JLabel)combo.getRenderer()).setHorizontalAlignment(JLabel.LEFT);
+        combo.setPreferredSize(new Dimension(100, label.getPreferredSize().height));
+        combo.setSelectedIndex(getController().getDeobfuscator().getModifier(entry).ordinal());
+        combo.addItemListener(getController()::modifierChange);
+        panel.add(combo);
+        return combo;
+    }
    public void onCaretMove(int pos) {
        Token token = this.controller.getToken(pos);
@@ -574,8 +611,7 @@ public class Gui {
        int offset = text.getText().lastIndexOf('/') + 1;
        // If it's a class and isn't in the default package, assume that it's deobfuscated.
-        if (m_reference.getNameableEntry() instanceof ClassEntry && !text.getText().startsWith(Constants.NONE_PACKAGE)
+        if (m_reference.getNameableEntry() instanceof ClassEntry && text.getText().contains("/") && offset != 0)
-                && offset != 0)
            text.select(offset, text.getText().length());
        else
            text.selectAll();
@@ -766,21 +802,24 @@ public class Gui {
                DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) node.getChildAt(i);
                ClassEntry prevDataChild = (ClassEntry) childNode.getUserObject();
                ClassEntry dataChild = new ClassEntry(data + "/" + prevDataChild.getSimpleName());
-                this.controller.rename(new EntryReference<>(prevDataChild, prevDataChild.getName()), dataChild.getName(), false);
+                this.controller.rename(new EntryReference<>(prevDataChild, prevDataChild.getName()), dataChild.getName(), false, i + 1 == node.getChildCount());
+                childNode.setUserObject(dataChild);
            }
+            node.setUserObject(data);
+            // Ob package will never be modified, just reload deob view
+            this.deobfPanel.deobfClasses.reload();
        }
        // class rename
        else if (data instanceof ClassEntry)
-            this.controller.rename(new EntryReference<>((ClassEntry) prevData, ((ClassEntry) prevData).getName()), ((ClassEntry) data).getName(), false);
+            this.controller.rename(new EntryReference<>((ClassEntry) prevData, ((ClassEntry) prevData).getName()), ((ClassEntry) data).getName(), false, true);
    }
    public void moveClassTree(EntryReference<Entry, Entry> deobfReference, String newName)
    {
        String oldEntry = deobfReference.entry.getClassEntry().getPackageName();
        String newEntry = new ClassEntry(Descriptor.toJvmName(newName)).getPackageName();
-        if (oldEntry != null && newEntry != null)
+        moveClassTree(deobfReference, newName, oldEntry == null,
-            moveClassTree(deobfReference, newName, oldEntry.equals(Constants.NONE_PACKAGE),
+                newEntry == null);
-                    newEntry.equals(Constants.NONE_PACKAGE));
    }
    public void moveClassTree(EntryReference<Entry, Entry> deobfReference, String newName, boolean isOldOb, boolean isNewOb)
@@ -795,6 +834,8 @@ public class Gui {
            ClassSelectorPackageNode packageNode = this.obfPanel.obfClasses.getPackageNode(oldEntry);
            this.obfPanel.obfClasses.removeNode(packageNode, oldEntry);
            this.obfPanel.obfClasses.removeNodeIfEmpty(packageNode);
+            this.deobfPanel.deobfClasses.reload();
+            this.obfPanel.obfClasses.reload();
        }
        // Deob -> ob
        else if (isNewOb && !isOldOb)
@@ -803,17 +844,21 @@ public class Gui {
            ClassSelectorPackageNode packageNode = this.deobfPanel.deobfClasses.getPackageNode(oldEntry);
            this.deobfPanel.deobfClasses.removeNode(packageNode, oldEntry);
            this.deobfPanel.deobfClasses.removeNodeIfEmpty(packageNode);
+            this.deobfPanel.deobfClasses.reload();
+            this.obfPanel.obfClasses.reload();
        }
        // Local move
        else if (isOldOb)
        {
            this.obfPanel.obfClasses.moveClassTree(oldEntry, newEntry, null);
            this.obfPanel.obfClasses.removeNodeIfEmpty(this.obfPanel.obfClasses.getPackageNode(oldEntry));
+            this.obfPanel.obfClasses.reload();
        }
        else
        {
            this.deobfPanel.deobfClasses.moveClassTree(oldEntry, newEntry, null);
            this.deobfPanel.deobfClasses.removeNodeIfEmpty(this.deobfPanel.deobfClasses.getPackageNode(oldEntry));
+            this.deobfPanel.deobfClasses.reload();
        }
    }
 }
diff --git a/src/main/java/cuchaz/enigma/gui/GuiController.java b/src/main/java/cuchaz/enigma/gui/GuiController.java
index 3188ff02..c2e202e2 100644
--- a/src/main/java/cuchaz/enigma/gui/GuiController.java
+++ b/src/main/java/cuchaz/enigma/gui/GuiController.java
@@ -20,6 +20,7 @@ import cuchaz.enigma.mapping.*;
 import cuchaz.enigma.throwables.MappingParseException;
 import cuchaz.enigma.utils.ReadableToken;
+import java.awt.event.ItemEvent;
 import java.io.File;
 import java.io.IOException;
 import java.util.Collection;
@@ -193,16 +194,16 @@ public class GuiController {
    }
    public void rename(EntryReference<Entry, Entry> deobfReference, String newName) {
-        rename(deobfReference, newName, true);
+        rename(deobfReference, newName, true, true);
    }
-    public void rename(EntryReference<Entry, Entry> deobfReference, String newName, boolean refreshClassTree)
+    public void rename(EntryReference<Entry, Entry> deobfReference, String newName, boolean refreshClassTree, boolean clearTranslationCache)
    {
        EntryReference<Entry, Entry> obfReference = this.deobfuscator.obfuscateReference(deobfReference);
-        this.deobfuscator.rename(obfReference.getNameableEntry(), newName);
+        this.deobfuscator.rename(obfReference.getNameableEntry(), newName, clearTranslationCache);
        this.isDirty = true;
-        if (refreshClassTree && deobfReference.entry instanceof ClassEntry)
+        if (refreshClassTree && deobfReference.entry instanceof ClassEntry && !((ClassEntry) deobfReference.entry).isInnerClass())
            this.gui.moveClassTree(deobfReference, newName);
        refreshCurrentClass(obfReference);
@@ -221,7 +222,7 @@ public class GuiController {
        EntryReference<Entry, Entry> obfReference = this.deobfuscator.obfuscateReference(deobfReference);
        this.deobfuscator.markAsDeobfuscated(obfReference.getNameableEntry());
        this.isDirty = true;
-        if (deobfReference.entry instanceof ClassEntry)
+        if (deobfReference.entry instanceof ClassEntry && !((ClassEntry) deobfReference.entry).isInnerClass())
            this.gui.moveClassTree(deobfReference, obfReference.entry.getName(), true, false);
        refreshCurrentClass(obfReference);
    }
@@ -338,4 +339,19 @@ public class GuiController {
            }
        }.start();
    }
+    public Deobfuscator getDeobfuscator()
+    {
+        return deobfuscator;
+    }
+    public void modifierChange(ItemEvent event)
+    {
+        if (event.getStateChange() == ItemEvent.SELECTED)
+        {
+            deobfuscator.changeModifier(gui.m_reference.entry, (Mappings.EntryModifier) event.getItem());
+            this.isDirty = true;
+            refreshCurrentClass();
+        }
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/gui/MemberMatchingGui.java b/src/main/java/cuchaz/enigma/gui/MemberMatchingGui.java
index 50550910..ecc280d5 100644
--- a/src/main/java/cuchaz/enigma/gui/MemberMatchingGui.java
+++ b/src/main/java/cuchaz/enigma/gui/MemberMatchingGui.java
@@ -138,7 +138,7 @@ public class MemberMatchingGui<T extends Entry> {
            sourceTypePanel.add(button);
        }
-        m_sourceClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR);
+        m_sourceClasses = new ClassSelector(null, ClassSelector.DEOBF_CLASS_COMPARATOR, false);
        m_sourceClasses.setSelectionListener(this::setSourceClass);
        JScrollPane sourceScroller = new JScrollPane(m_sourceClasses);
        classesPanel.add(sourceScroller);
diff --git a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorClassNode.java b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorClassNode.java
index 1c9dad4b..83418267 100644
--- a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorClassNode.java
+++ b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorClassNode.java
@@ -49,6 +49,11 @@ public class ClassSelectorClassNode extends DefaultMutableTreeNode {
        super.setUserObject(classEntry);
    }
+    @Override public Object getUserObject()
+    {
+        return classEntry;
+    }
    public boolean equals(ClassSelectorClassNode other) {
        return this.classEntry.equals(other.classEntry);
    }
diff --git a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java
index d2e421e7..31b4ebfa 100644
--- a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java
+++ b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java
@@ -19,7 +19,7 @@ public class ClassSelectorPackageNode extends DefaultMutableTreeNode {
    private String packageName;
    public ClassSelectorPackageNode(String packageName) {
-        this.packageName = packageName;
+        this.packageName = packageName != null ? packageName : "(none)";
    }
    public String getPackageName() {
@@ -33,9 +33,14 @@ public class ClassSelectorPackageNode extends DefaultMutableTreeNode {
        super.setUserObject(userObject);
    }
+    @Override public Object getUserObject()
+    {
+        return packageName;
+    }
    @Override
    public String toString() {
-        return Descriptor.toJavaName(this.packageName);
+        return !packageName.equals("(none)") ? Descriptor.toJavaName(this.packageName) : "(none)";
    }
    @Override
@@ -44,6 +49,6 @@ public class ClassSelectorPackageNode extends DefaultMutableTreeNode {
    }
    public boolean equals(ClassSelectorPackageNode other) {
-        return this.packageName.equals(other.packageName);
+        return other != null && this.packageName.equals(other.packageName);
    }
 }
diff --git a/src/main/java/cuchaz/enigma/gui/panels/PanelDeobf.java b/src/main/java/cuchaz/enigma/gui/panels/PanelDeobf.java
index 447c51af..4f551756 100644
--- a/src/main/java/cuchaz/enigma/gui/panels/PanelDeobf.java
+++ b/src/main/java/cuchaz/enigma/gui/panels/PanelDeobf.java
@@ -17,7 +17,7 @@ public class PanelDeobf extends JPanel {
    public PanelDeobf(Gui gui) {
        this.gui = gui;
-        this.deobfClasses = new ClassSelector(gui, ClassSelector.DEOBF_CLASS_COMPARATOR);
+        this.deobfClasses = new ClassSelector(gui, ClassSelector.DEOBF_CLASS_COMPARATOR, true);
        this.deobfClasses.setSelectionListener(gui::navigateTo);
        this.deobfClasses.setRenameSelectionListener(gui::onPanelRename);
diff --git a/src/main/java/cuchaz/enigma/gui/panels/PanelEditor.java b/src/main/java/cuchaz/enigma/gui/panels/PanelEditor.java
index cf3c4e93..914952b9 100644
--- a/src/main/java/cuchaz/enigma/gui/panels/PanelEditor.java
+++ b/src/main/java/cuchaz/enigma/gui/panels/PanelEditor.java
@@ -10,7 +10,6 @@ import javax.swing.JEditorPane;
 import cuchaz.enigma.gui.BrowserCaret;
 import cuchaz.enigma.gui.Gui;
-import de.sciss.syntaxpane.DefaultSyntaxKit;
 public class PanelEditor extends JEditorPane {
    private final Gui gui;
@@ -21,7 +20,6 @@ public class PanelEditor extends JEditorPane {
        this.setEditable(false);
        this.setSelectionColor(new Color(31, 46, 90));
        this.setCaret(new BrowserCaret());
-        this.setContentType("text/java");
        this.addCaretListener(event -> gui.onCaretMove(event.getDot()));
        final PanelEditor self = this;
        this.addMouseListener(new MouseAdapter()
@@ -71,8 +69,5 @@ public class PanelEditor extends JEditorPane {
                }
            }
        });
-        DefaultSyntaxKit kit = (DefaultSyntaxKit) this.getEditorKit();
-        kit.toggleComponent(this, "de.sciss.syntaxpane.components.TokenMarker");
    }
 }
diff --git a/src/main/java/cuchaz/enigma/gui/panels/PanelObf.java b/src/main/java/cuchaz/enigma/gui/panels/PanelObf.java
index 74772a5f..27bb70b4 100644
--- a/src/main/java/cuchaz/enigma/gui/panels/PanelObf.java
+++ b/src/main/java/cuchaz/enigma/gui/panels/PanelObf.java
@@ -28,7 +28,7 @@ public class PanelObf extends JPanel {
            return aname.compareTo(bname);
        };
-        this.obfClasses = new ClassSelector(gui, obfClassComparator);
+        this.obfClasses = new ClassSelector(gui, obfClassComparator, false);
        this.obfClasses.setSelectionListener(gui::navigateTo);
        this.obfClasses.setRenameSelectionListener(gui::onPanelRename);
diff --git a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
index 36b35f73..8f893889 100644
--- a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
@@ -17,33 +17,49 @@ import java.util.Map;
 import cuchaz.enigma.throwables.MappingConflict;
+// FIXME: Enigma doesn't support inner classes of inner class????!
 public class ClassMapping implements Comparable<ClassMapping> {
    private String m_obfFullName;
    private String m_obfSimpleName;
    private String m_deobfName;
+    private String m_previousDeobfName;
    private Map<String, ClassMapping> m_innerClassesByObfSimple;
+    private Map<String, ClassMapping> m_innerClassesByObfFull;
    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;
+    private boolean isDirty;
+    private Mappings.EntryModifier modifier;
-    public ClassMapping(String obfFullName) {
+    public ClassMapping(String obfFullName)
-        this(obfFullName, null);
+    {
+        this(obfFullName, null, Mappings.EntryModifier.UNCHANGED);
    }
-    public ClassMapping(String obfFullName, String deobfName) {
+    public ClassMapping(String obfFullName, String deobfName)
+    {
+        this(obfFullName, deobfName, Mappings.EntryModifier.UNCHANGED);
+    }
+    public ClassMapping(String obfFullName, String deobfName, Mappings.EntryModifier modifier)
+    {
        m_obfFullName = obfFullName;
        ClassEntry classEntry = new ClassEntry(obfFullName);
        m_obfSimpleName = classEntry.isInnerClass() ? classEntry.getInnermostClassName() : classEntry.getSimpleName();
+        m_previousDeobfName = null;
        m_deobfName = NameValidator.validateClassName(deobfName, false);
        m_innerClassesByObfSimple = Maps.newHashMap();
+        m_innerClassesByObfFull = Maps.newHashMap();
        m_innerClassesByDeobf = Maps.newHashMap();
        m_fieldsByObf = Maps.newHashMap();
        m_fieldsByDeobf = Maps.newHashMap();
        m_methodsByObf = Maps.newHashMap();
        m_methodsByDeobf = Maps.newHashMap();
+        isDirty = true;
+        this.modifier = modifier;
    }
    public String getObfFullName() {
@@ -54,12 +70,18 @@ public class ClassMapping implements Comparable<ClassMapping> {
        return m_obfSimpleName;
    }
+    public String getPreviousDeobfName() {
+        return m_previousDeobfName;
+    }
    public String getDeobfName() {
        return m_deobfName;
    }
    public void setDeobfName(String val) {
+        m_previousDeobfName = m_deobfName;
        m_deobfName = NameValidator.validateClassName(val, false);
+        this.isDirty = true;
    }
    //// INNER CLASSES ////////
@@ -70,9 +92,11 @@ public class ClassMapping implements Comparable<ClassMapping> {
    }
    public void addInnerClassMapping(ClassMapping classMapping) throws MappingConflict {
-        if (this.m_innerClassesByObfSimple.containsKey(classMapping.getObfSimpleName())) {
+        // FIXME: dirty hack, that can get into issues, but it's a temp fix!
+        if (this.m_innerClassesByObfFull.containsKey(classMapping.getObfSimpleName())) {
            throw new MappingConflict("classes", classMapping.getObfSimpleName(), this.m_innerClassesByObfSimple.get(classMapping.getObfSimpleName()).getObfSimpleName());
        }
+        m_innerClassesByObfFull.put(classMapping.getObfFullName(), classMapping);
        m_innerClassesByObfSimple.put(classMapping.getObfSimpleName(), classMapping);
        if (classMapping.getDeobfName() != null) {
@@ -81,23 +105,28 @@ public class ClassMapping implements Comparable<ClassMapping> {
            }
            m_innerClassesByDeobf.put(classMapping.getDeobfName(), classMapping);
        }
+        this.isDirty = true;
    }
    public void removeInnerClassMapping(ClassMapping classMapping) {
+        m_innerClassesByObfFull.remove(classMapping.getObfFullName());
        boolean obfWasRemoved = m_innerClassesByObfSimple.remove(classMapping.getObfSimpleName()) != null;
        assert (obfWasRemoved);
        if (classMapping.getDeobfName() != null) {
            boolean deobfWasRemoved = m_innerClassesByDeobf.remove(classMapping.getDeobfName()) != null;
            assert (deobfWasRemoved);
        }
+        this.isDirty = true;
    }
    public ClassMapping getOrCreateInnerClass(ClassEntry obfInnerClass) {
        ClassMapping classMapping = m_innerClassesByObfSimple.get(obfInnerClass.getInnermostClassName());
        if (classMapping == null) {
            classMapping = new ClassMapping(obfInnerClass.getName());
+            m_innerClassesByObfFull.put(classMapping.getObfFullName(), classMapping);
            boolean wasAdded = m_innerClassesByObfSimple.put(classMapping.getObfSimpleName(), classMapping) == null;
            assert (wasAdded);
+            this.isDirty = true;
        }
        return classMapping;
    }
@@ -141,6 +170,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
            boolean wasAdded = m_innerClassesByDeobf.put(deobfName, classMapping) == null;
            assert (wasAdded);
        }
+        this.isDirty = true;
    }
    public boolean hasInnerClassByObfSimple(String obfSimpleName) {
@@ -172,15 +202,17 @@ public class ClassMapping implements Comparable<ClassMapping> {
        if (m_fieldsByObf.containsKey(obfKey)) {
            throw new Error("Already have mapping for " + m_obfFullName + "." + obfKey);
        }
-        String deobfKey = getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType());
+        if (fieldMapping.getDeobfName() != null) {
-        if (m_fieldsByDeobf.containsKey(deobfKey)) {
+            String deobfKey = getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType());
-            throw new Error("Already have mapping for " + m_deobfName + "." + deobfKey);
+            if (m_fieldsByDeobf.containsKey(deobfKey)) {
+                throw new Error("Already have mapping for " + m_deobfName + "." + deobfKey);
+            }
+            boolean deobfWasAdded = m_fieldsByDeobf.put(deobfKey, fieldMapping) == null;
+            assert (deobfWasAdded);
        }
        boolean obfWasAdded = m_fieldsByObf.put(obfKey, fieldMapping) == null;
        assert (obfWasAdded);
-        boolean deobfWasAdded = m_fieldsByDeobf.put(deobfKey, fieldMapping) == null;
+        this.isDirty = true;
-        assert (deobfWasAdded);
-        assert (m_fieldsByObf.size() == m_fieldsByDeobf.size());
    }
    public void removeFieldMapping(FieldMapping fieldMapping) {
@@ -190,6 +222,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
            boolean deobfWasRemoved = m_fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType())) != null;
            assert (deobfWasRemoved);
        }
+        this.isDirty = true;
    }
    public FieldMapping getFieldByObf(String obfName, Type obfType) {
@@ -226,12 +259,11 @@ public class ClassMapping implements Comparable<ClassMapping> {
        return name + ":" + type;
    }
    public void setFieldName(String obfName, Type obfType, String deobfName) {
        assert (deobfName != null);
        FieldMapping fieldMapping = m_fieldsByObf.get(getFieldKey(obfName, obfType));
        if (fieldMapping == null) {
-            fieldMapping = new FieldMapping(obfName, obfType, deobfName);
+            fieldMapping = new FieldMapping(obfName, obfType, deobfName, Mappings.EntryModifier.UNCHANGED);
            boolean obfWasAdded = m_fieldsByObf.put(getFieldKey(obfName, obfType), fieldMapping) == null;
            assert (obfWasAdded);
        } else {
@@ -243,6 +275,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
            boolean wasAdded = m_fieldsByDeobf.put(getFieldKey(deobfName, obfType), fieldMapping) == null;
            assert (wasAdded);
        }
+        this.isDirty = true;
    }
    public void setFieldObfNameAndType(String oldObfName, Type obfType, String newObfName, Type newObfType) {
@@ -253,6 +286,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
        fieldMapping.setObfType(newObfType);
        boolean obfWasAdded = m_fieldsByObf.put(getFieldKey(newObfName, newObfType), fieldMapping) == null;
        assert(obfWasAdded);
+        this.isDirty = true;
    }
    //// METHODS ////////
@@ -285,6 +319,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
            boolean deobfWasAdded = m_methodsByDeobf.put(deobfKey, methodMapping) == null;
            assert (deobfWasAdded);
        }
+        this.isDirty = true;
        assert (m_methodsByObf.size() >= m_methodsByDeobf.size());
    }
@@ -295,6 +330,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
            boolean deobfWasRemoved = m_methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null;
            assert (deobfWasRemoved);
        }
+        this.isDirty = true;
    }
    public MethodMapping getMethodByObf(String obfName, Signature obfSignature) {
@@ -328,6 +364,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
            boolean wasAdded = m_methodsByDeobf.put(getMethodKey(deobfName, obfSignature), methodMapping) == null;
            assert (wasAdded);
        }
+        this.isDirty = true;
    }
    public void setMethodObfNameAndSignature(String oldObfName, Signature obfSignature, String newObfName, Signature newObfSignature) {
@@ -338,6 +375,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
        methodMapping.setObfSignature(newObfSignature);
        boolean obfWasAdded = m_methodsByObf.put(getMethodKey(newObfName, newObfSignature), methodMapping) == null;
        assert(obfWasAdded);
+        this.isDirty = true;
    }
    //// ARGUMENTS ////////
@@ -349,16 +387,19 @@ public class ClassMapping implements Comparable<ClassMapping> {
            methodMapping = createMethodMapping(obfMethodName, obfMethodSignature);
        }
        methodMapping.setArgumentName(argumentIndex, argumentName);
+        this.isDirty = true;
    }
    public void removeArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex) {
        m_methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)).removeArgumentName(argumentIndex);
+        this.isDirty = true;
    }
    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);
+        this.isDirty = true;
        return methodMapping;
    }
@@ -441,6 +482,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
            m_obfFullName = newObfClassName;
            return true;
        }
+        this.isDirty = true;
        return false;
    }
@@ -456,4 +498,54 @@ public class ClassMapping implements Comparable<ClassMapping> {
    public ClassEntry getObfEntry() {
        return new ClassEntry(m_obfFullName);
    }
+    public boolean isDirty()
+    {
+        return isDirty;
+    }
+    public void resetDirty()
+    {
+        this.isDirty = false;
+    }
+    public void setModifier(Mappings.EntryModifier modifier)
+    {
+        if (this.modifier != modifier)
+            this.isDirty = true;
+        this.modifier = modifier;
+    }
+    public Mappings.EntryModifier getModifier()
+    {
+        return modifier;
+    }
+    public void setFieldModifier(String obfName, Type obfType, Mappings.EntryModifier modifier) {
+        FieldMapping fieldMapping = m_fieldsByObf.get(getFieldKey(obfName, obfType));
+        if (fieldMapping == null) {
+            fieldMapping = new FieldMapping(obfName, obfType, null, Mappings.EntryModifier.UNCHANGED);
+            m_fieldsByObf.put(getFieldKey(obfName, obfType), fieldMapping);
+        }
+        if (fieldMapping.getModifier() != modifier)
+        {
+            fieldMapping.setModifier(modifier);
+            this.isDirty = true;
+        }
+    }
+    public void setMethodModifier(String obfName, Signature sig, Mappings.EntryModifier modifier) {
+        MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfName, sig));
+        if (methodMapping == null) {
+            methodMapping = new MethodMapping(obfName, sig, null, Mappings.EntryModifier.UNCHANGED);
+            m_methodsByObf.put(getMethodKey(obfName, sig), methodMapping);
+        }
+        if (methodMapping.getModifier() != modifier)
+        {
+            methodMapping.setModifier(modifier);
+            this.isDirty = true;
+        }
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/mapping/FieldMapping.java b/src/main/java/cuchaz/enigma/mapping/FieldMapping.java
index 1b596606..e75485cd 100644
--- a/src/main/java/cuchaz/enigma/mapping/FieldMapping.java
+++ b/src/main/java/cuchaz/enigma/mapping/FieldMapping.java
@@ -15,16 +15,19 @@ public class FieldMapping implements Comparable<FieldMapping>, MemberMapping<Fie
    private String obfName;
    private String deobfName;
    private Type obfType;
+    private Mappings.EntryModifier modifier;
-    public FieldMapping(String obfName, Type obfType, String deobfName) {
+    public FieldMapping(String obfName, Type obfType, String deobfName, Mappings.EntryModifier modifier) {
        this.obfName = obfName;
        this.deobfName = NameValidator.validateFieldName(deobfName);
        this.obfType = obfType;
+        this.modifier = modifier;
    }
    public FieldMapping(FieldMapping other, ClassNameReplacer obfClassNameReplacer) {
        this.obfName = other.obfName;
        this.deobfName = other.deobfName;
+        this.modifier = other.modifier;
        this.obfType = new Type(other.obfType, obfClassNameReplacer);
    }
@@ -58,6 +61,16 @@ public class FieldMapping implements Comparable<FieldMapping>, MemberMapping<Fie
        this.obfType = val;
    }
+    public void setModifier(Mappings.EntryModifier modifier)
+    {
+        this.modifier = modifier;
+    }
+    public Mappings.EntryModifier getModifier()
+    {
+        return modifier;
+    }
    @Override
    public int compareTo(FieldMapping other) {
        return (this.obfName + this.obfType).compareTo(other.obfName + other.obfType);
diff --git a/src/main/java/cuchaz/enigma/mapping/LocalVariableEntry.java b/src/main/java/cuchaz/enigma/mapping/LocalVariableEntry.java
new file mode 100644
index 00000000..8bbaaaf6
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/mapping/LocalVariableEntry.java
@@ -0,0 +1,104 @@
+package cuchaz.enigma.mapping;
+import cuchaz.enigma.utils.Utils;
+/**
+ * Desc...
+ * Created by Thog
+ * 19/10/2016
+ */
+public class LocalVariableEntry implements Entry
+{
+    protected final BehaviorEntry behaviorEntry;
+    protected final String name;
+    protected final Type type;
+    protected final int index;
+    public LocalVariableEntry(BehaviorEntry behaviorEntry, int index, String name, Type type) {
+        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("Variable name cannot be null!");
+        }
+        if (type == null) {
+            throw new IllegalArgumentException("Variable type cannot be null!");
+        }
+        this.behaviorEntry = behaviorEntry;
+        this.name = name;
+        this.type = type;
+        this.index = index;
+    }
+    public LocalVariableEntry(LocalVariableEntry other, ClassEntry newClassEntry) {
+        this.behaviorEntry = (BehaviorEntry) other.behaviorEntry.cloneToNewClass(newClassEntry);
+        this.name = other.name;
+        this.type = other.type;
+        this.index = other.index;
+    }
+    public BehaviorEntry getBehaviorEntry() {
+        return this.behaviorEntry;
+    }
+    public Type getType() {
+        return type;
+    }
+    public int getIndex() {
+        return index;
+    }
+    @Override
+    public String getName() {
+        return this.name;
+    }
+    @Override
+    public ClassEntry getClassEntry() {
+        return this.behaviorEntry.getClassEntry();
+    }
+    @Override
+    public String getClassName() {
+        return this.behaviorEntry.getClassName();
+    }
+    @Override
+    public LocalVariableEntry cloneToNewClass(ClassEntry classEntry) {
+        return new LocalVariableEntry(this, classEntry);
+    }
+    public String getMethodName() {
+        return this.behaviorEntry.getName();
+    }
+    public Signature getMethodSignature() {
+        return this.behaviorEntry.getSignature();
+    }
+    @Override
+    public int hashCode() {
+        return Utils.combineHashesOrdered(this.behaviorEntry, this.type.hashCode(), this.name.hashCode(), Integer.hashCode(this.index));
+    }
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof LocalVariableEntry && equals((LocalVariableEntry) other);
+    }
+    public boolean equals(LocalVariableEntry other) {
+        return this.behaviorEntry.equals(other.behaviorEntry) && this.type.equals(other.type) && this.name.equals(other.name) && this.index == other.index;
+    }
+    @Override
+    public String toString() {
+        return this.behaviorEntry.toString() + "(" + this.index + ":" + this.name + ":" + this.type + ")";
+    }
+}
diff --git a/src/main/java/cuchaz/enigma/mapping/Mappings.java b/src/main/java/cuchaz/enigma/mapping/Mappings.java
index 7061be79..d493dcfa 100644
--- a/src/main/java/cuchaz/enigma/mapping/Mappings.java
+++ b/src/main/java/cuchaz/enigma/mapping/Mappings.java
@@ -15,11 +15,7 @@ import com.google.common.collect.Maps;
 import java.io.File;
 import java.io.IOException;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import com.google.common.collect.Sets;
 import cuchaz.enigma.analysis.TranslationIndex;
@@ -30,6 +26,7 @@ public class Mappings {
    protected Map<String, ClassMapping> classesByObf;
    protected Map<String, ClassMapping> classesByDeobf;
    private final FormatType originMapping;
+    private Mappings previousState;
    public Mappings()
    {
@@ -40,6 +37,7 @@ public class Mappings {
        this.originMapping = originMapping;
        this.classesByObf = Maps.newHashMap();
        this.classesByDeobf = Maps.newHashMap();
+        this.previousState = null;
    }
    public Collection<ClassMapping> classes() {
@@ -175,6 +173,16 @@ public class Mappings {
        return classMapping != null && classMapping.containsDeobfField(deobfName, obfType);
    }
+    public boolean containsDeobfField(ClassEntry obfClassEntry, String deobfName) {
+        ClassMapping classMapping = this.classesByObf.get(obfClassEntry.getName());
+        if (classMapping != null)
+            for (FieldMapping fieldMapping : classMapping.fields())
+                if (deobfName.equals(fieldMapping.getDeobfName()) || deobfName.equals(fieldMapping.getObfName()))
+                    return true;
+        return false;
+    }
    public boolean containsDeobfMethod(ClassEntry obfClassEntry, String deobfName, Signature obfSignature) {
        ClassMapping classMapping = this.classesByObf.get(obfClassEntry.getName());
        return classMapping != null && classMapping.containsDeobfMethod(deobfName, obfSignature);
@@ -204,9 +212,19 @@ public class Mappings {
        return originMapping;
    }
+    public void savePreviousState()
+    {
+        this.previousState = new Mappings(this.originMapping);
+        this.previousState.classesByDeobf = Maps.newHashMap(this.classesByDeobf);
+        this.previousState.classesByObf = Maps.newHashMap(this.classesByObf);
+        classesByDeobf.values().forEach(ClassMapping::resetDirty);
+        classesByObf.values().forEach(ClassMapping::resetDirty);
+    }
    public void saveEnigmaMappings(File file, boolean isDirectoryFormat) throws IOException
    {
        new MappingsEnigmaWriter().write(file, this, isDirectoryFormat);
+        this.savePreviousState();
    }
    public void saveSRGMappings(File file) throws IOException
@@ -214,8 +232,22 @@ public class Mappings {
        new MappingsSRGWriter().write(file, this);
    }
+    public Mappings getPreviousState() {
+        return previousState;
+    }
    public enum FormatType
    {
        ENIGMA_FILE, ENIGMA_DIRECTORY, SRG_FILE
    }
+    public enum EntryModifier
+    {
+        UNCHANGED, PUBLIC, PROTECTED, PRIVATE;
+        public String getFormattedName()
+        {
+            return " ACC:" + super.toString();
+        }
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
index 74c5340c..cdfed726 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
@@ -37,6 +37,7 @@ public class MappingsEnigmaReader
                else if (file.isDirectory())
                    readDirectory(mappings, file.getAbsoluteFile());
            }
+            mappings.savePreviousState();
        }
        else
            throw new IOException("Cannot access directory" + directory.getAbsolutePath());
@@ -134,21 +135,51 @@ public class MappingsEnigmaReader
    private ClassMapping readClass(String[] parts, boolean makeSimple) {
        if (parts.length == 2) {
            return new ClassMapping(parts[1]);
-        } else {
+        } else if (parts.length == 3) {
-            return new ClassMapping(parts[1], parts[2]);
+            boolean access = parts[2].startsWith("ACC:");
-        }
+            ClassMapping mapping;
+            if (access)
+                mapping = new ClassMapping(parts[1], null, Mappings.EntryModifier.valueOf(parts[2].substring(4)));
+            else
+                mapping = new ClassMapping(parts[1], parts[2]);
+            return mapping;
+        } else if (parts.length == 4)
+            return new ClassMapping(parts[1], parts[2], Mappings.EntryModifier.valueOf(parts[3].substring(4)));
+        return null;
    }
    /* TEMP */
    protected FieldMapping readField(String[] parts) {
-        return new FieldMapping(parts[1], new Type(parts[3]), parts[2]);
+        FieldMapping mapping = null;
+        if (parts.length == 4)
+        {
+            boolean access = parts[3].startsWith("ACC:");
+            if (access)
+                mapping = new FieldMapping(parts[1], new Type(parts[2]), null,
+                        Mappings.EntryModifier.valueOf(parts[3].substring(4)));
+            else
+                mapping = new FieldMapping(parts[1], new Type(parts[3]), parts[2], Mappings.EntryModifier.UNCHANGED);
+        }
+        else if (parts.length == 5)
+            mapping = new FieldMapping(parts[1], new Type(parts[3]), parts[2], Mappings.EntryModifier.valueOf(parts[4].substring(4)));
+        return mapping;
    }
    private MethodMapping readMethod(String[] parts) {
-        if (parts.length == 3) {
+        MethodMapping mapping = null;
-            return new MethodMapping(parts[1], new Signature(parts[2]));
+        if (parts.length == 3)
-        } else {
+            mapping = new MethodMapping(parts[1], new Signature(parts[2]));
-            return new MethodMapping(parts[1], new Signature(parts[3]), parts[2]);
+        else if (parts.length == 4){
+            boolean access = parts[3].startsWith("ACC:");
+            if (access)
+                mapping = new MethodMapping(parts[1], new Signature(parts[2]), null, Mappings.EntryModifier.valueOf(parts[3].substring(4)));
+            else
+                mapping = new MethodMapping(parts[1], new Signature(parts[3]), parts[2]);
        }
+        else if (parts.length == 5)
+            mapping = new MethodMapping(parts[1], new Signature(parts[3]), parts[2],
+                    Mappings.EntryModifier.valueOf(parts[4].substring(4)));
+        return mapping;
    }
 }
diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaWriter.java b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaWriter.java
index ba0720a0..c09f4a67 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaWriter.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaWriter.java
@@ -30,24 +30,14 @@ public class MappingsEnigmaWriter {
                        writeAsDirectory(out, mappings);
        }
-        private void deleteDir(File file) {
-                File[] contents = file.listFiles();
-                if (contents != null) {
-                        for (File f : contents) {
-                                deleteDir(f);
-                        }
-                }
-                file.delete();
-        }
        public void writeAsDirectory(File target, Mappings mappings) throws IOException {
-                //TODO: Know what have changes during write to not rewrite all the things
-                deleteDir(target);
                if (!target.exists() && !target.mkdirs())
-                        throw  new IOException("Cannot create mapping directory!");
+                        throw new IOException("Cannot create mapping directory!");
                for (ClassMapping classMapping : sorted(mappings.classes())) {
+                        if (!classMapping.isDirty())
+                                continue;
+                        this.deletePreviousClassMapping(target, classMapping);
                        File obFile = new File(target, classMapping.getObfFullName() + ".mapping");
                        File result;
                        if (classMapping.getDeobfName() == null)
@@ -68,8 +58,53 @@ public class MappingsEnigmaWriter {
                        outputWriter.close();
                }
+                // Remove dropped mappings
+                if (mappings.getPreviousState() != null)
+                {
+                        List<ClassMapping> droppedClassMappings = new ArrayList<>(mappings.getPreviousState().classes());
+                        List<ClassMapping> classMappings = new ArrayList<>(mappings.classes());
+                        droppedClassMappings.removeAll(classMappings);
+                        for (ClassMapping classMapping : droppedClassMappings)
+                        {
+                                File obFile = new File(target, classMapping.getObfFullName() + ".mapping");
+                                File result;
+                                if (classMapping.getDeobfName() == null)
+                                        result = obFile;
+                                else
+                                {
+                                        // Make sure that old version of the file doesn't exist
+                                        if (obFile.exists())
+                                                obFile.delete();
+                                        result = new File(target, classMapping.getDeobfName() + ".mapping");
+                                }
+                                if (result.exists())
+                                        result.delete();
+                        }
+                }
        }
-        
+        private void deletePreviousClassMapping(File target, ClassMapping classMapping) {
+                File prevFile = null;
+                // Deob rename
+                if (classMapping.getDeobfName() != null && classMapping.getPreviousDeobfName() != null && !classMapping.getPreviousDeobfName().equals(classMapping.getDeobfName()))
+                {
+                        prevFile = new File(target, classMapping.getPreviousDeobfName() + ".mapping");
+                }
+                // Deob to ob rename
+                else if (classMapping.getDeobfName() == null && classMapping.getPreviousDeobfName() != null)
+                {
+                        prevFile = new File(target, classMapping.getPreviousDeobfName() + ".mapping");
+                }
+                // Ob to Deob rename
+                else if (classMapping.getDeobfName() != null && classMapping.getPreviousDeobfName() == null)
+                {
+                        prevFile = new File(target, classMapping.getObfFullName() + ".mapping");
+                }
+                if (prevFile != null && prevFile.exists())
+                        prevFile.delete();
+        }
        public void write(PrintWriter out, Mappings mappings) throws IOException {
                for (ClassMapping classMapping : sorted(mappings.classes())) {
                        write(out, classMapping, 0);
@@ -78,9 +113,9 @@ public class MappingsEnigmaWriter {
        
        private void write(PrintWriter out, ClassMapping classMapping, int depth) throws IOException {
                if (classMapping.getDeobfName() == null) {
-                        out.format("%sCLASS %s\n", getIndent(depth), classMapping.getObfFullName());
+                        out.format("%sCLASS %s%s\n", getIndent(depth), classMapping.getObfFullName(), classMapping.getModifier() == Mappings.EntryModifier.UNCHANGED ? "" : classMapping.getModifier().getFormattedName());
                } else {
-                        out.format("%sCLASS %s %s\n", getIndent(depth), classMapping.getObfFullName(), classMapping.getDeobfName());
+                        out.format("%sCLASS %s %s%s\n", getIndent(depth), classMapping.getObfFullName(), classMapping.getDeobfName(), classMapping.getModifier() == Mappings.EntryModifier.UNCHANGED ? "" :  classMapping.getModifier().getFormattedName());
                }
                
                for (ClassMapping innerClassMapping : sorted(classMapping.innerClasses())) {
@@ -97,14 +132,17 @@ public class MappingsEnigmaWriter {
        }
        
        private void write(PrintWriter out, FieldMapping fieldMapping, int depth) throws IOException {
-                out.format("%sFIELD %s %s %s\n", getIndent(depth), fieldMapping.getObfName(), fieldMapping.getDeobfName(), fieldMapping.getObfType().toString());
+                if (fieldMapping.getDeobfName() == null)
+                        out.format("%sFIELD %s %s%s\n", getIndent(depth), fieldMapping.getObfName(), fieldMapping.getObfType().toString(), fieldMapping.getModifier() == Mappings.EntryModifier.UNCHANGED ? "" : fieldMapping.getModifier().getFormattedName());
+                else
+                        out.format("%sFIELD %s %s %s%s\n", getIndent(depth), fieldMapping.getObfName(), fieldMapping.getDeobfName(), fieldMapping.getObfType().toString(), fieldMapping.getModifier() == Mappings.EntryModifier.UNCHANGED ? "" : fieldMapping.getModifier().getFormattedName());
        }
        
        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());
+                        out.format("%sMETHOD %s %s%s\n", getIndent(depth), methodMapping.getObfName(), methodMapping.getObfSignature(), methodMapping.getModifier() == Mappings.EntryModifier.UNCHANGED ? "" :methodMapping.getModifier().getFormattedName());
                } else {
-                        out.format("%sMETHOD %s %s %s\n", getIndent(depth), methodMapping.getObfName(), methodMapping.getDeobfName(), methodMapping.getObfSignature());
+                        out.format("%sMETHOD %s %s %s%s\n", getIndent(depth), methodMapping.getObfName(), methodMapping.getDeobfName(), methodMapping.getObfSignature(), methodMapping.getModifier() == Mappings.EntryModifier.UNCHANGED ? "" : methodMapping.getModifier().getFormattedName());
                }
                
                for (ArgumentMapping argumentMapping : sorted(methodMapping.arguments())) {
diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsRenamer.java b/src/main/java/cuchaz/enigma/mapping/MappingsRenamer.java
index 5c299e3e..bac62503 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsRenamer.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsRenamer.java
@@ -90,8 +90,23 @@ public class MappingsRenamer {
    public void setFieldName(FieldEntry obf, String deobfName) {
        deobfName = NameValidator.validateFieldName(deobfName);
        FieldEntry targetEntry = new FieldEntry(obf.getClassEntry(), deobfName, obf.getType());
-        if (m_mappings.containsDeobfField(obf.getClassEntry(), deobfName, obf.getType()) || m_index.containsObfField(targetEntry)) {
+        ClassEntry definedClass = null;
-            throw new IllegalNameException(deobfName, "There is already a field with that name");
+        if (m_mappings.containsDeobfField(obf.getClassEntry(), deobfName) || m_index.containsEntryWithSameName(targetEntry))
+            definedClass = obf.getClassEntry();
+        else {
+            for (ClassEntry ancestorEntry : this.m_index.getTranslationIndex().getAncestry(obf.getClassEntry())) {
+                if (m_mappings.containsDeobfField(ancestorEntry, deobfName) || m_index.containsEntryWithSameName(targetEntry.cloneToNewClass(ancestorEntry))) {
+                    definedClass = ancestorEntry;
+                    break;
+                }
+            }
+        }
+        if (definedClass != null) {
+            String className = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateClass(definedClass.getClassName());
+            if (className == null)
+                className = definedClass.getClassName();
+            throw new IllegalNameException(deobfName, "There is already a field with that name in " + className);
        }
        ClassMapping classMapping = getOrCreateClassMapping(obf.getClassEntry());
@@ -306,4 +321,22 @@ public class MappingsRenamer {
        }
        return mappingChain;
    }
+    public void setClassModifier(ClassEntry obEntry, Mappings.EntryModifier modifier)
+    {
+        ClassMapping classMapping = getOrCreateClassMapping(obEntry);
+        classMapping.setModifier(modifier);
+    }
+    public void setFieldModifier(FieldEntry obEntry, Mappings.EntryModifier modifier)
+    {
+        ClassMapping classMapping = getOrCreateClassMapping(obEntry.getClassEntry());
+        classMapping.setFieldModifier(obEntry.getName(), obEntry.getType(), modifier);
+    }
+    public void setMethodModifier(BehaviorEntry obEntry, Mappings.EntryModifier modifier)
+    {
+        ClassMapping classMapping = getOrCreateClassMapping(obEntry.getClassEntry());
+        classMapping.setMethodModifier(obEntry.getName(), obEntry.getSignature(), modifier);
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java b/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java
index 229bf464..4d0c2610 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java
@@ -34,25 +34,25 @@ public class MappingsSRGWriter {
                if(innerClassMapping.getDeobfName() == null || innerClassMapping.getObfSimpleName() == null || innerClassMapping.getDeobfName() == null){
                    continue;
                }
-                String innerClassName = classMapping.getObfSimpleName() + "$" + innerClassMapping.getObfSimpleName().replace("none/", "");
+                String innerClassName = classMapping.getObfSimpleName() + "$" + innerClassMapping.getObfSimpleName();
-                String innerDebofClassName = classMapping.getDeobfName() + "$" + innerClassMapping.getDeobfName().replace("none/", "");
+                String innerDeobfClassName = classMapping.getDeobfName() + "$" + innerClassMapping.getDeobfName();
                writer.write("CL: " + innerClassName + " " + classMapping.getDeobfName() + "$" + innerClassMapping.getDeobfName());
                writer.write(System.lineSeparator());
                for (FieldMapping fieldMapping : sorted(innerClassMapping.fields())) {
-                    fieldMappings.add("FD: " + innerClassName + "/" + fieldMapping.getObfName() + " " + innerDebofClassName + "/" + fieldMapping.getDeobfName());
+                    fieldMappings.add("FD: " + innerClassName + "/" + fieldMapping.getObfName() + " " + innerDeobfClassName + "/" + fieldMapping.getDeobfName());
                }
                for (MethodMapping methodMapping : sorted(innerClassMapping.methods())) {
-                    methodMappings.add("MD: " + innerClassName + "/" + methodMapping.getObfName() + " " + methodMapping.getObfSignature().toString().replace("none/", "") + " " + innerDebofClassName + "/" + methodMapping.getDeobfName() + " " + mappings.getTranslator(TranslationDirection.Deobfuscating, index).translateSignature(methodMapping.getObfSignature()));
+                    methodMappings.add("MD: " + innerClassName + "/" + methodMapping.getObfName() + " " + methodMapping.getObfSignature().toString() + " " + innerDeobfClassName + "/" + methodMapping.getDeobfName() + " " + mappings.getTranslator(TranslationDirection.Deobfuscating, index).translateSignature(methodMapping.getObfSignature()));
                }
            }
            for (FieldMapping fieldMapping : sorted(classMapping.fields())) {
-                fieldMappings.add("FD: " + classMapping.getObfFullName().replace("none/", "") + "/" + fieldMapping.getObfName() + " " + classMapping.getDeobfName() + "/" + fieldMapping.getDeobfName());
+                fieldMappings.add("FD: " + classMapping.getObfFullName() + "/" + fieldMapping.getObfName() + " " + classMapping.getDeobfName() + "/" + fieldMapping.getDeobfName());
            }
            for (MethodMapping methodMapping : sorted(classMapping.methods())) {
-                methodMappings.add("MD: " + classMapping.getObfFullName().replace("none/", "") + "/" + methodMapping.getObfName() + " " + methodMapping.getObfSignature().toString().replace("none/", "") + " " + classMapping.getDeobfName() + "/" + methodMapping.getDeobfName() + " " + mappings.getTranslator(TranslationDirection.Deobfuscating, index).translateSignature(methodMapping.getObfSignature()));
+                methodMappings.add("MD: " + classMapping.getObfFullName() + "/" + methodMapping.getObfName() + " " + methodMapping.getObfSignature().toString() + " " + classMapping.getDeobfName() + "/" + methodMapping.getDeobfName() + " " + mappings.getTranslator(TranslationDirection.Deobfuscating, index).translateSignature(methodMapping.getObfSignature()));
            }
        }
        for(String fd : fieldMappings){
diff --git a/src/main/java/cuchaz/enigma/mapping/MethodMapping.java b/src/main/java/cuchaz/enigma/mapping/MethodMapping.java
index 99b9c887..455ff6b7 100644
--- a/src/main/java/cuchaz/enigma/mapping/MethodMapping.java
+++ b/src/main/java/cuchaz/enigma/mapping/MethodMapping.java
@@ -22,12 +22,17 @@ public class MethodMapping implements Comparable<MethodMapping>, MemberMapping<B
    private String deobfName;
    private Signature obfSignature;
    private Map<Integer, ArgumentMapping> arguments;
+    private Mappings.EntryModifier modifier;
    public MethodMapping(String obfName, Signature obfSignature) {
-        this(obfName, obfSignature, null);
+        this(obfName, obfSignature, null,Mappings.EntryModifier.UNCHANGED);
    }
    public MethodMapping(String obfName, Signature obfSignature, String deobfName) {
+        this(obfName, obfSignature, deobfName, Mappings.EntryModifier.UNCHANGED);
+    }
+    public MethodMapping(String obfName, Signature obfSignature, String deobfName, Mappings.EntryModifier modifier) {
        if (obfName == null) {
            throw new IllegalArgumentException("obf name cannot be null!");
        }
@@ -38,11 +43,13 @@ public class MethodMapping implements Comparable<MethodMapping>, MemberMapping<B
        this.deobfName = NameValidator.validateMethodName(deobfName);
        this.obfSignature = obfSignature;
        this.arguments = Maps.newTreeMap();
+        this.modifier = modifier;
    }
    
    public MethodMapping(MethodMapping other, ClassNameReplacer obfClassNameReplacer) {
        this.obfName = other.obfName;
        this.deobfName = other.deobfName;
+        this.modifier = other.modifier;
        this.obfSignature = new Signature(other.obfSignature, obfClassNameReplacer);
        this.arguments = Maps.newTreeMap();
        for (Map.Entry<Integer,ArgumentMapping> entry : other.arguments.entrySet()) {
@@ -187,4 +194,14 @@ public class MethodMapping implements Comparable<MethodMapping>, MemberMapping<B
            return new MethodEntry(classEntry, this.obfName, this.obfSignature);
        }
    }
+    public Mappings.EntryModifier getModifier()
+    {
+        return modifier;
+    }
+    public void setModifier(Mappings.EntryModifier modifier)
+    {
+        this.modifier = modifier;
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/mapping/Translator.java b/src/main/java/cuchaz/enigma/mapping/Translator.java
index b05714cc..e94009ee 100644
--- a/src/main/java/cuchaz/enigma/mapping/Translator.java
+++ b/src/main/java/cuchaz/enigma/mapping/Translator.java
@@ -58,6 +58,8 @@ public class Translator {
            return (T) translateEntry((ConstructorEntry) entry);
        } else if (entry instanceof ArgumentEntry) {
            return (T) translateEntry((ArgumentEntry) entry);
+        } else if (entry instanceof  LocalVariableEntry) {
+            return (T) translateEntry((LocalVariableEntry) entry);
        } else {
            throw new Error("Unknown entry type: " + entry.getClass().getName());
        }
@@ -74,11 +76,28 @@ public class Translator {
            return translate(entry);
        } else if (entry instanceof ArgumentEntry) {
            return translate((ArgumentEntry) entry);
+        } else if (entry instanceof  LocalVariableEntry) {
+            return translate((LocalVariableEntry) entry);
        } else {
            throw new Error("Unknown entry type: " + entry.getClass().getName());
        }
    }
+    public String translate(LocalVariableEntry in)
+    {
+        LocalVariableEntry translated = translateEntry(in);
+        if (translated.equals(in)) {
+            return null;
+        }
+        return translated.getName();
+    }
+    public LocalVariableEntry translateEntry(LocalVariableEntry in)
+    {
+        // TODO: Implement it
+        return in;
+    }
    public String translate(ClassEntry in) {
        ClassEntry translated = translateEntry(in);
        if (translated.equals(in)) {
@@ -310,4 +329,27 @@ public class Translator {
        assert (mappingsChain.size() == parts.length);
        return mappingsChain;
    }
+    public Mappings.EntryModifier getModifier(Entry entry)
+    {
+        ClassMapping classMapping = findClassMapping(entry.getClassEntry());
+        if (classMapping != null && !entry.getName().equals("<clinit>"))
+        {
+            if (entry instanceof ClassEntry)
+                return classMapping.getModifier();
+            else if (entry instanceof FieldEntry)
+            {
+                FieldMapping fieldMapping = classMapping.getFieldByObf(entry.getName(), ((FieldEntry) entry).getType());
+                return fieldMapping != null ? fieldMapping.getModifier() : Mappings.EntryModifier.UNCHANGED;
+            }
+            else if (entry instanceof BehaviorEntry)
+            {
+                MethodMapping methodMapping = classMapping.getMethodByObf(entry.getName(), ((BehaviorEntry) entry).getSignature());
+                return methodMapping != null ? methodMapping.getModifier() : Mappings.EntryModifier.UNCHANGED;
+            }
+            else
+                throw new Error("Unknown entry type: " + entry.getClass().getName());
+        }
+        return Mappings.EntryModifier.UNCHANGED;
+    }
 }