Renamed Fields

55 files changed, 750 insertions, 814 deletions

diff --git a/src/main/java/cuchaz/enigma/CommandMain.java b/src/main/java/cuchaz/enigma/CommandMain.java
index 69f56849..b715c6e2 100644
--- a/src/main/java/cuchaz/enigma/CommandMain.java
+++ b/src/main/java/cuchaz/enigma/CommandMain.java
@@ -11,7 +11,6 @@
 package cuchaz.enigma;
 
 import java.io.File;
-import java.io.FileReader;
 import java.util.jar.JarFile;
 
 import cuchaz.enigma.Deobfuscator.ProgressListener;
diff --git a/src/main/java/cuchaz/enigma/ConvertMain.java b/src/main/java/cuchaz/enigma/ConvertMain.java
index 409a2692..a68ab614 100644
--- a/src/main/java/cuchaz/enigma/ConvertMain.java
+++ b/src/main/java/cuchaz/enigma/ConvertMain.java
@@ -11,8 +11,6 @@
 package cuchaz.enigma;
 
 import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
 import java.io.IOException;
 import java.util.jar.JarFile;
 
@@ -42,7 +40,7 @@ public class ConvertMain {
             //Get the mapping files
             File inMappingsFile = new File(OldMappings);
             File outMappingsFile = new File(NewMappings);
-            Mappings mappings = new MappingsReader().read( inMappingsFile);
+            Mappings mappings = new MappingsReader().read(inMappingsFile);
             //Make the Match Files..
             File classMatchesFile = new File(ClassMatches);
             File fieldMatchesFile = new File(FieldMatches);
@@ -187,7 +185,7 @@ public class ConvertMain {
         checker.dropBrokenMappings(destMappings);
         deobfuscators.dest.setMappings(destMappings);
 
-        new MemberMatchingGui<FieldEntry>(classMatches, fieldMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener<FieldEntry>() {
+        new MemberMatchingGui<>(classMatches, fieldMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener<FieldEntry>() {
             @Override
             public void save(MemberMatches<FieldEntry> matches) {
                 try {
@@ -260,7 +258,7 @@ public class ConvertMain {
         checker.dropBrokenMappings(destMappings);
         deobfuscators.dest.setMappings(destMappings);
 
-        new MemberMatchingGui<BehaviorEntry>(classMatches, methodMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener<BehaviorEntry>() {
+        new MemberMatchingGui<>(classMatches, methodMatches, deobfuscators.source, deobfuscators.dest).setSaveListener(new MemberMatchingGui.SaveListener<BehaviorEntry>() {
             @Override
             public void save(MemberMatches<BehaviorEntry> matches) {
                 try {
diff --git a/src/main/java/cuchaz/enigma/Main.java b/src/main/java/cuchaz/enigma/Main.java
index b135de77..d52e390a 100644
--- a/src/main/java/cuchaz/enigma/Main.java
+++ b/src/main/java/cuchaz/enigma/Main.java
@@ -12,6 +12,7 @@ package cuchaz.enigma;
 
 import java.io.File;
 import java.util.jar.JarFile;
+
 import javax.swing.UIManager;
 
 import cuchaz.enigma.gui.Gui;
diff --git a/src/main/java/cuchaz/enigma/MainFormatConverter.java b/src/main/java/cuchaz/enigma/MainFormatConverter.java
index 29e334ec..712b0f89 100644
--- a/src/main/java/cuchaz/enigma/MainFormatConverter.java
+++ b/src/main/java/cuchaz/enigma/MainFormatConverter.java
@@ -13,8 +13,6 @@ package cuchaz.enigma;
 import com.google.common.collect.Maps;
 
 import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
 import java.lang.reflect.Field;
 import java.util.Map;
 import java.util.jar.JarFile;
diff --git a/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java
index 776f0909..39ff449e 100644
--- a/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java
+++ b/src/main/java/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java
@@ -31,50 +31,50 @@ public class BehaviorReferenceTreeNode extends DefaultMutableTreeNode implements
     private Access m_access;
 
     public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, BehaviorEntry entry) {
-        m_deobfuscatingTranslator = deobfuscatingTranslator;
-        m_entry = entry;
-        m_reference = null;
+        this.m_deobfuscatingTranslator = deobfuscatingTranslator;
+        this.m_entry = entry;
+        this.m_reference = null;
     }
 
     public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference<BehaviorEntry, BehaviorEntry> reference, Access access) {
-        m_deobfuscatingTranslator = deobfuscatingTranslator;
-        m_entry = reference.entry;
-        m_reference = reference;
-        m_access = access;
+        this.m_deobfuscatingTranslator = deobfuscatingTranslator;
+        this.m_entry = reference.entry;
+        this.m_reference = reference;
+        this.m_access = access;
     }
 
     @Override
     public BehaviorEntry getEntry() {
-        return m_entry;
+        return this.m_entry;
     }
 
     @Override
     public EntryReference<BehaviorEntry, BehaviorEntry> getReference() {
-        return m_reference;
+        return this.m_reference;
     }
 
     @Override
     public String toString() {
-        if (m_reference != null) {
-            return String.format("%s (%s)", m_deobfuscatingTranslator.translateEntry(m_reference.context), m_access);
+        if (this.m_reference != null) {
+            return String.format("%s (%s)", this.m_deobfuscatingTranslator.translateEntry(this.m_reference.context), this.m_access);
         }
-        return m_deobfuscatingTranslator.translateEntry(m_entry).toString();
+        return this.m_deobfuscatingTranslator.translateEntry(this.m_entry).toString();
     }
 
     public void load(JarIndex index, boolean recurse) {
         // get all the child nodes
-        for (EntryReference<BehaviorEntry, BehaviorEntry> reference : index.getBehaviorReferences(m_entry)) {
-            add(new BehaviorReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_entry)));
+        for (EntryReference<BehaviorEntry, BehaviorEntry> reference : index.getBehaviorReferences(this.m_entry)) {
+            add(new BehaviorReferenceTreeNode(this.m_deobfuscatingTranslator, reference, index.getAccess(this.m_entry)));
         }
 
-        if (recurse && children != null) {
-            for (Object child : children) {
+        if (recurse && this.children != null) {
+            for (Object child : this.children) {
                 if (child instanceof BehaviorReferenceTreeNode) {
                     BehaviorReferenceTreeNode node = (BehaviorReferenceTreeNode) child;
 
                     // don't recurse into ancestor
                     Set<Entry> ancestors = Sets.newHashSet();
-                    TreeNode n = (TreeNode) node;
+                    TreeNode n = node;
                     while (n.getParent() != null) {
                         n = n.getParent();
                         if (n instanceof BehaviorReferenceTreeNode) {
diff --git a/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java b/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java
index 1df76255..cd185846 100644
--- a/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java
+++ b/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java
@@ -21,7 +21,7 @@ public class BridgeMarker {
     private JarIndex m_jarIndex;
 
     public BridgeMarker(JarIndex jarIndex) {
-        m_jarIndex = jarIndex;
+        this.m_jarIndex = jarIndex;
     }
 
     public void markBridges(CtClass c) {
@@ -30,7 +30,7 @@ public class BridgeMarker {
             MethodEntry methodEntry = EntryFactory.getMethodEntry(method);
 
             // is this a bridge method?
-            MethodEntry bridgedMethodEntry = m_jarIndex.getBridgedMethod(methodEntry);
+            MethodEntry bridgedMethodEntry = this.m_jarIndex.getBridgedMethod(methodEntry);
             if (bridgedMethodEntry != null) {
 
                 // it's a bridge method! add the bridge flag
diff --git a/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java b/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
index 8f8986c1..3420cd6d 100644
--- a/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
+++ b/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
@@ -24,27 +24,27 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode {
 
     private static final long serialVersionUID = 3112703459157851912L;
 
-    private Translator m_deobfuscatingTranslator;
-    private ClassEntry m_entry;
+    private Translator deobfuscatingTranslator;
+    private ClassEntry entry;
 
     public ClassImplementationsTreeNode(Translator deobfuscatingTranslator, ClassEntry entry) {
-        m_deobfuscatingTranslator = deobfuscatingTranslator;
-        m_entry = entry;
+        this.deobfuscatingTranslator = deobfuscatingTranslator;
+        this.entry = entry;
     }
 
     public ClassEntry getClassEntry() {
-        return m_entry;
+        return this.entry;
     }
 
     public String getDeobfClassName() {
-        return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        return this.deobfuscatingTranslator.translateClass(this.entry.getClassName());
     }
 
     @Override
     public String toString() {
         String className = getDeobfClassName();
         if (className == null) {
-            className = m_entry.getClassName();
+            className = this.entry.getClassName();
         }
         return className;
     }
@@ -52,8 +52,8 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode {
     public void load(JarIndex index) {
         // get all method implementations
         List<ClassImplementationsTreeNode> nodes = Lists.newArrayList();
-        for (String implementingClassName : index.getImplementingClasses(m_entry.getClassName())) {
-            nodes.add(new ClassImplementationsTreeNode(m_deobfuscatingTranslator, new ClassEntry(implementingClassName)));
+        for (String implementingClassName : index.getImplementingClasses(this.entry.getClassName())) {
+            nodes.add(new ClassImplementationsTreeNode(this.deobfuscatingTranslator, new ClassEntry(implementingClassName)));
         }
 
         // add them to this node
@@ -62,7 +62,7 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode {
 
     public static ClassImplementationsTreeNode findNode(ClassImplementationsTreeNode node, MethodEntry entry) {
         // is this the node?
-        if (node.m_entry.equals(entry)) {
+        if (node.entry.equals(entry)) {
             return node;
         }
 
diff --git a/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
index ca2b8215..beac9d5d 100644
--- a/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
+++ b/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
@@ -23,20 +23,20 @@ public class ClassInheritanceTreeNode extends DefaultMutableTreeNode {
 
     private static final long serialVersionUID = 4432367405826178490L;
 
-    private Translator m_deobfuscatingTranslator;
-    private String m_obfClassName;
+    private Translator deobfuscatingTranslator;
+    private String obfClassName;
 
     public ClassInheritanceTreeNode(Translator deobfuscatingTranslator, String obfClassName) {
-        m_deobfuscatingTranslator = deobfuscatingTranslator;
-        m_obfClassName = obfClassName;
+        this.deobfuscatingTranslator = deobfuscatingTranslator;
+        this.obfClassName = obfClassName;
     }
 
     public String getObfClassName() {
-        return m_obfClassName;
+        return this.obfClassName;
     }
 
     public String getDeobfClassName() {
-        return m_deobfuscatingTranslator.translateClass(m_obfClassName);
+        return this.deobfuscatingTranslator.translateClass(this.obfClassName);
     }
 
     @Override
@@ -45,14 +45,14 @@ public class ClassInheritanceTreeNode extends DefaultMutableTreeNode {
         if (deobfClassName != null) {
             return deobfClassName;
         }
-        return m_obfClassName;
+        return this.obfClassName;
     }
 
     public void load(TranslationIndex ancestries, boolean recurse) {
         // get all the child nodes
         List<ClassInheritanceTreeNode> nodes = Lists.newArrayList();
-        for (ClassEntry subclassEntry : ancestries.getSubclass(new ClassEntry(m_obfClassName))) {
-            nodes.add(new ClassInheritanceTreeNode(m_deobfuscatingTranslator, subclassEntry.getName()));
+        for (ClassEntry subclassEntry : ancestries.getSubclass(new ClassEntry(this.obfClassName))) {
+            nodes.add(new ClassInheritanceTreeNode(this.deobfuscatingTranslator, subclassEntry.getName()));
         }
 
         // add them to this node
diff --git a/src/main/java/cuchaz/enigma/analysis/EntryReference.java b/src/main/java/cuchaz/enigma/analysis/EntryReference.java
index eb58388c..6a7a4bf0 100644
--- a/src/main/java/cuchaz/enigma/analysis/EntryReference.java
+++ b/src/main/java/cuchaz/enigma/analysis/EntryReference.java
@@ -24,7 +24,7 @@ public class EntryReference<E extends Entry, C extends Entry> {
     public E entry;
     public C context;
 
-    private boolean m_isNamed;
+    private boolean sourceName;
 
     public EntryReference(E entry, String sourceName) {
         this(entry, sourceName, null);
@@ -38,16 +38,16 @@ public class EntryReference<E extends Entry, C extends Entry> {
         this.entry = entry;
         this.context = context;
 
-        m_isNamed = sourceName != null && sourceName.length() > 0;
+        this.sourceName = sourceName != null && sourceName.length() > 0;
         if (entry instanceof ConstructorEntry && ConstructorNonNames.contains(sourceName)) {
-            m_isNamed = false;
+            this.sourceName = false;
         }
     }
 
     public EntryReference(E entry, C context, EntryReference<E, C> other) {
         this.entry = entry;
         this.context = context;
-        m_isNamed = other.m_isNamed;
+        this.sourceName = other.sourceName;
     }
 
     public ClassEntry getLocationClassEntry() {
@@ -58,7 +58,7 @@ public class EntryReference<E extends Entry, C extends Entry> {
     }
 
     public boolean isNamed() {
-        return m_isNamed;
+        return this.sourceName;
     }
 
     public Entry getNameableEntry() {
@@ -91,10 +91,7 @@ public class EntryReference<E extends Entry, C extends Entry> {
 
     @Override
     public boolean equals(Object other) {
-        if (other instanceof EntryReference) {
-            return equals((EntryReference<?, ?>) other);
-        }
-        return false;
+        return other instanceof EntryReference && equals((EntryReference<?, ?>) other);
     }
 
     public boolean equals(EntryReference<?, ?> other) {
diff --git a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
index b99537cc..9c3d051b 100644
--- a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
+++ b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
@@ -36,7 +36,7 @@ public class EntryRenamer {
         // for each key/value pair...
         Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
         for (Map.Entry<Key, Val> entry : map.entrySet()) {
-            entriesToAdd.add(new AbstractMap.SimpleEntry<Key, Val>(
+            entriesToAdd.add(new AbstractMap.SimpleEntry<>(
                     renameClassesInThing(renames, entry.getKey()),
                     renameClassesInThing(renames, entry.getValue())
             ));
@@ -51,7 +51,7 @@ public class EntryRenamer {
         // for each key/value pair...
         Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
         for (Map.Entry<Key, Val> entry : map.entries()) {
-            entriesToAdd.add(new AbstractMap.SimpleEntry<Key, Val>(
+            entriesToAdd.add(new AbstractMap.SimpleEntry<>(
                     renameClassesInThing(renames, entry.getKey()),
                     renameClassesInThing(renames, entry.getValue())
             ));
@@ -66,7 +66,7 @@ public class EntryRenamer {
         // for each key/value pair...
         Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
         for (Map.Entry<Key, Val> entry : map.entries()) {
-            entriesToAdd.add(new AbstractMap.SimpleEntry<Key, Val>(
+            entriesToAdd.add(new AbstractMap.SimpleEntry<>(
                     renameMethodsInThing(renames, entry.getKey()),
                     renameMethodsInThing(renames, entry.getValue())
             ));
@@ -81,7 +81,7 @@ public class EntryRenamer {
         // for each key/value pair...
         Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
         for (Map.Entry<Key, Val> entry : map.entrySet()) {
-            entriesToAdd.add(new AbstractMap.SimpleEntry<Key, Val>(
+            entriesToAdd.add(new AbstractMap.SimpleEntry<>(
                     renameMethodsInThing(renames, entry.getKey()),
                     renameMethodsInThing(renames, entry.getValue())
             ));
@@ -164,19 +164,9 @@ public class EntryRenamer {
             reference.context = renameClassesInThing(renames, reference.context);
             return thing;
         } else if (thing instanceof Signature) {
-            return (T) new Signature((Signature) thing, new ClassNameReplacer() {
-                @Override
-                public String replace(String className) {
-                    return renameClassesInThing(renames, className);
-                }
-            });
+            return (T) new Signature((Signature) thing, className -> renameClassesInThing(renames, className));
         } else if (thing instanceof Type) {
-            return (T) new Type((Type) thing, new ClassNameReplacer() {
-                @Override
-                public String replace(String className) {
-                    return renameClassesInThing(renames, className);
-                }
-            });
+            return (T) new Type((Type) thing, className -> renameClassesInThing(renames, className));
         }
 
         return thing;
diff --git a/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
index 4b302e05..05d9c13f 100644
--- a/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
+++ b/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
@@ -20,51 +20,51 @@ public class FieldReferenceTreeNode extends DefaultMutableTreeNode implements Re
 
     private static final long serialVersionUID = -7934108091928699835L;
 
-    private Translator m_deobfuscatingTranslator;
-    private FieldEntry m_entry;
-    private EntryReference<FieldEntry, BehaviorEntry> m_reference;
-    private Access m_access;
+    private Translator deobfuscatingTranslator;
+    private FieldEntry entry;
+    private EntryReference<FieldEntry, BehaviorEntry> reference;
+    private Access access;
 
     public FieldReferenceTreeNode(Translator deobfuscatingTranslator, FieldEntry entry) {
-        m_deobfuscatingTranslator = deobfuscatingTranslator;
-        m_entry = entry;
-        m_reference = null;
+        this.deobfuscatingTranslator = deobfuscatingTranslator;
+        this.entry = entry;
+        this.reference = null;
     }
 
     private FieldReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference<FieldEntry, BehaviorEntry> reference, Access access) {
-        m_deobfuscatingTranslator = deobfuscatingTranslator;
-        m_entry = reference.entry;
-        m_reference = reference;
-        m_access = access;
+        this.deobfuscatingTranslator = deobfuscatingTranslator;
+        this.entry = reference.entry;
+        this.reference = reference;
+        this.access = access;
     }
 
     @Override
     public FieldEntry getEntry() {
-        return m_entry;
+        return this.entry;
     }
 
     @Override
     public EntryReference<FieldEntry, BehaviorEntry> getReference() {
-        return m_reference;
+        return this.reference;
     }
 
     @Override
     public String toString() {
-        if (m_reference != null) {
-            return String.format("%s (%s)", m_deobfuscatingTranslator.translateEntry(m_reference.context), m_access);
+        if (this.reference != null) {
+            return String.format("%s (%s)", this.deobfuscatingTranslator.translateEntry(this.reference.context), this.access);
         }
-        return m_deobfuscatingTranslator.translateEntry(m_entry).toString();
+        return this.deobfuscatingTranslator.translateEntry(this.entry).toString();
     }
 
     public void load(JarIndex index, boolean recurse) {
         // get all the child nodes
-        if (m_reference == null) {
-            for (EntryReference<FieldEntry, BehaviorEntry> reference : index.getFieldReferences(m_entry)) {
-                add(new FieldReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_entry)));
+        if (this.reference == null) {
+            for (EntryReference<FieldEntry, BehaviorEntry> reference : index.getFieldReferences(this.entry)) {
+                add(new FieldReferenceTreeNode(this.deobfuscatingTranslator, reference, index.getAccess(this.entry)));
             }
         } else {
-            for (EntryReference<BehaviorEntry, BehaviorEntry> reference : index.getBehaviorReferences(m_reference.context)) {
-                add(new BehaviorReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_reference.context)));
+            for (EntryReference<BehaviorEntry, BehaviorEntry> reference : index.getBehaviorReferences(this.reference.context)) {
+                add(new BehaviorReferenceTreeNode(this.deobfuscatingTranslator, reference, index.getAccess(this.reference.context)));
             }
         }
 
diff --git a/src/main/java/cuchaz/enigma/analysis/JarClassIterator.java b/src/main/java/cuchaz/enigma/analysis/JarClassIterator.java
index 17a17151..04004270 100644
--- a/src/main/java/cuchaz/enigma/analysis/JarClassIterator.java
+++ b/src/main/java/cuchaz/enigma/analysis/JarClassIterator.java
@@ -31,15 +31,15 @@ import javassist.bytecode.Descriptor;
 
 public class JarClassIterator implements Iterator<CtClass> {
 
-    private JarFile m_jar;
-    private Iterator<JarEntry> m_iter;
+    private JarFile jar;
+    private Iterator<JarEntry> iter;
 
     public JarClassIterator(JarFile jar) {
-        m_jar = jar;
+        this.jar = jar;
 
         // get the jar entries that correspond to classes
         List<JarEntry> classEntries = Lists.newArrayList();
-        Enumeration<JarEntry> entries = m_jar.entries();
+        Enumeration<JarEntry> entries = this.jar.entries();
         while (entries.hasMoreElements()) {
             JarEntry entry = entries.nextElement();
 
@@ -48,19 +48,19 @@ public class JarClassIterator implements Iterator<CtClass> {
                 classEntries.add(entry);
             }
         }
-        m_iter = classEntries.iterator();
+        this.iter = classEntries.iterator();
     }
 
     @Override
     public boolean hasNext() {
-        return m_iter.hasNext();
+        return this.iter.hasNext();
     }
 
     @Override
     public CtClass next() {
-        JarEntry entry = m_iter.next();
+        JarEntry entry = this.iter.next();
         try {
-            return getClass(m_jar, entry);
+            return getClass(this.jar, entry);
         } catch (IOException | NotFoundException ex) {
             throw new Error("Unable to load class: " + entry.getName());
         }
@@ -86,12 +86,7 @@ public class JarClassIterator implements Iterator<CtClass> {
     }
 
     public static Iterable<CtClass> classes(final JarFile jar) {
-        return new Iterable<CtClass>() {
-            @Override
-            public Iterator<CtClass> iterator() {
-                return new JarClassIterator(jar);
-            }
-        };
+        return () -> new JarClassIterator(jar);
     }
 
     public static CtClass getClass(JarFile jar, ClassEntry classEntry) {
diff --git a/src/main/java/cuchaz/enigma/analysis/JarIndex.java b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
index 848d8511..8b30f9eb 100644
--- a/src/main/java/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
@@ -26,32 +26,32 @@ import javassist.expr.*;
 
 public class JarIndex {
 
-    private Set<ClassEntry> m_obfClassEntries;
-    private TranslationIndex m_translationIndex;
-    private Map<Entry, Access> m_access;
-    private Multimap<ClassEntry, FieldEntry> m_fields;
-    private Multimap<ClassEntry, BehaviorEntry> m_behaviors;
-    private Multimap<String, MethodEntry> m_methodImplementations;
-    private Multimap<BehaviorEntry, EntryReference<BehaviorEntry, BehaviorEntry>> m_behaviorReferences;
-    private Multimap<FieldEntry, EntryReference<FieldEntry, BehaviorEntry>> m_fieldReferences;
-    private Multimap<ClassEntry, ClassEntry> m_innerClassesByOuter;
-    private Map<ClassEntry, ClassEntry> m_outerClassesByInner;
-    private Map<ClassEntry, BehaviorEntry> m_anonymousClasses;
-    private Map<MethodEntry, MethodEntry> m_bridgedMethods;
+    private Set<ClassEntry> obfClassEntries;
+    private TranslationIndex translationIndex;
+    private Map<Entry, Access> access;
+    private Multimap<ClassEntry, FieldEntry> fields;
+    private Multimap<ClassEntry, BehaviorEntry> behaviors;
+    private Multimap<String, MethodEntry> methodImplementations;
+    private Multimap<BehaviorEntry, EntryReference<BehaviorEntry, BehaviorEntry>> behaviorReferences;
+    private Multimap<FieldEntry, EntryReference<FieldEntry, BehaviorEntry>> fieldReferences;
+    private Multimap<ClassEntry, ClassEntry> innerClassesByOuter;
+    private Map<ClassEntry, ClassEntry> outerClassesByInner;
+    private Map<ClassEntry, BehaviorEntry> anonymousClasses;
+    private Map<MethodEntry, MethodEntry> bridgedMethods;
 
     public JarIndex() {
-        m_obfClassEntries = Sets.newHashSet();
-        m_translationIndex = new TranslationIndex();
-        m_access = Maps.newHashMap();
-        m_fields = HashMultimap.create();
-        m_behaviors = HashMultimap.create();
-        m_methodImplementations = HashMultimap.create();
-        m_behaviorReferences = HashMultimap.create();
-        m_fieldReferences = HashMultimap.create();
-        m_innerClassesByOuter = HashMultimap.create();
-        m_outerClassesByInner = Maps.newHashMap();
-        m_anonymousClasses = Maps.newHashMap();
-        m_bridgedMethods = Maps.newHashMap();
+        this.obfClassEntries = Sets.newHashSet();
+        this.translationIndex = new TranslationIndex();
+        this.access = Maps.newHashMap();
+        this.fields = HashMultimap.create();
+        this.behaviors = HashMultimap.create();
+        this.methodImplementations = HashMultimap.create();
+        this.behaviorReferences = HashMultimap.create();
+        this.fieldReferences = HashMultimap.create();
+        this.innerClassesByOuter = HashMultimap.create();
+        this.outerClassesByInner = Maps.newHashMap();
+        this.anonymousClasses = Maps.newHashMap();
+        this.bridgedMethods = Maps.newHashMap();
     }
 
     public void indexJar(JarFile jar, boolean buildInnerClasses) {
@@ -62,7 +62,7 @@ public class JarIndex {
                 // move out of default package
                 classEntry = new ClassEntry(Constants.NonePackage + "/" + classEntry.getName());
             }
-            m_obfClassEntries.add(classEntry);
+            this.obfClassEntries.add(classEntry);
         }
 
         // step 2: index field/method/constructor access
@@ -70,20 +70,20 @@ public class JarIndex {
             ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
             for (CtField field : c.getDeclaredFields()) {
                 FieldEntry fieldEntry = EntryFactory.getFieldEntry(field);
-                m_access.put(fieldEntry, Access.get(field));
-                m_fields.put(fieldEntry.getClassEntry(), fieldEntry);
+                this.access.put(fieldEntry, Access.get(field));
+                this.fields.put(fieldEntry.getClassEntry(), fieldEntry);
             }
             for (CtBehavior behavior : c.getDeclaredBehaviors()) {
                 BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior);
-                m_access.put(behaviorEntry, Access.get(behavior));
-                m_behaviors.put(behaviorEntry.getClassEntry(), behaviorEntry);
+                this.access.put(behaviorEntry, Access.get(behavior));
+                this.behaviors.put(behaviorEntry.getClassEntry(), behaviorEntry);
             }
         }
 
         // step 3: index extends, implements, fields, and methods
         for (CtClass c : JarClassIterator.classes(jar)) {
             ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
-            m_translationIndex.indexClass(c);
+            this.translationIndex.indexClass(c);
             String className = Descriptor.toJvmName(c.getName());
             for (String interfaceName : c.getClassFile().getInterfaces()) {
                 className = Descriptor.toJvmName(className);
@@ -113,13 +113,13 @@ public class JarIndex {
                 ClassEntry innerClassEntry = EntryFactory.getClassEntry(c);
                 ClassEntry outerClassEntry = findOuterClass(c);
                 if (outerClassEntry != null) {
-                    m_innerClassesByOuter.put(outerClassEntry, innerClassEntry);
-                    boolean innerWasAdded = m_outerClassesByInner.put(innerClassEntry, outerClassEntry) == null;
+                    this.innerClassesByOuter.put(outerClassEntry, innerClassEntry);
+                    boolean innerWasAdded = this.outerClassesByInner.put(innerClassEntry, outerClassEntry) == null;
                     assert (innerWasAdded);
 
                     BehaviorEntry enclosingBehavior = isAnonymousClass(c, outerClassEntry);
                     if (enclosingBehavior != null) {
-                        m_anonymousClasses.put(innerClassEntry, enclosingBehavior);
+                        this.anonymousClasses.put(innerClassEntry, enclosingBehavior);
 
                         // DEBUG
                         //System.out.println("ANONYMOUS: " + outerClassEntry.getName() + "$" + innerClassEntry.getSimpleName());
@@ -132,7 +132,7 @@ public class JarIndex {
 
             // step 6: update other indices with inner class info
             Map<String, String> renames = Maps.newHashMap();
-            for (ClassEntry innerClassEntry : m_innerClassesByOuter.values()) {
+            for (ClassEntry innerClassEntry : this.innerClassesByOuter.values()) {
                 String newName = innerClassEntry.buildClassEntry(getObfClassChain(innerClassEntry)).getName();
                 if (!innerClassEntry.getName().equals(newName)) {
                     // DEBUG
@@ -140,12 +140,12 @@ public class JarIndex {
                     renames.put(innerClassEntry.getName(), newName);
                 }
             }
-            EntryRenamer.renameClassesInSet(renames, m_obfClassEntries);
-            m_translationIndex.renameClasses(renames);
-            EntryRenamer.renameClassesInMultimap(renames, m_methodImplementations);
-            EntryRenamer.renameClassesInMultimap(renames, m_behaviorReferences);
-            EntryRenamer.renameClassesInMultimap(renames, m_fieldReferences);
-            EntryRenamer.renameClassesInMap(renames, m_access);
+            EntryRenamer.renameClassesInSet(renames, this.obfClassEntries);
+            this.translationIndex.renameClasses(renames);
+            EntryRenamer.renameClassesInMultimap(renames, this.methodImplementations);
+            EntryRenamer.renameClassesInMultimap(renames, this.behaviorReferences);
+            EntryRenamer.renameClassesInMultimap(renames, this.fieldReferences);
+            EntryRenamer.renameClassesInMap(renames, this.access);
         }
     }
 
@@ -156,12 +156,12 @@ public class JarIndex {
             MethodEntry methodEntry = (MethodEntry) behaviorEntry;
 
             // index implementation
-            m_methodImplementations.put(behaviorEntry.getClassName(), methodEntry);
+            this.methodImplementations.put(behaviorEntry.getClassName(), methodEntry);
 
             // look for bridge and bridged methods
             CtMethod bridgedMethod = getBridgedMethod((CtMethod) behavior);
             if (bridgedMethod != null) {
-                m_bridgedMethods.put(methodEntry, EntryFactory.getMethodEntry(bridgedMethod));
+                this.bridgedMethods.put(methodEntry, EntryFactory.getMethodEntry(bridgedMethod));
             }
         }
         // looks like we don't care about constructors here
@@ -175,7 +175,7 @@ public class JarIndex {
                 @Override
                 public void edit(MethodCall call) {
                     MethodEntry calledMethodEntry = EntryFactory.getMethodEntry(call);
-                    ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledMethodEntry);
+                    ClassEntry resolvedClassEntry = translationIndex.resolveEntryClass(calledMethodEntry);
                     if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledMethodEntry.getClassEntry())) {
                         calledMethodEntry = new MethodEntry(
                                 resolvedClassEntry,
@@ -188,13 +188,13 @@ public class JarIndex {
                             call.getMethodName(),
                             behaviorEntry
                     );
-                    m_behaviorReferences.put(calledMethodEntry, reference);
+                    behaviorReferences.put(calledMethodEntry, reference);
                 }
 
                 @Override
                 public void edit(FieldAccess call) {
                     FieldEntry calledFieldEntry = EntryFactory.getFieldEntry(call);
-                    ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledFieldEntry);
+                    ClassEntry resolvedClassEntry = translationIndex.resolveEntryClass(calledFieldEntry);
                     if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledFieldEntry.getClassEntry())) {
                         calledFieldEntry = new FieldEntry(calledFieldEntry, resolvedClassEntry);
                     }
@@ -203,7 +203,7 @@ public class JarIndex {
                             call.getFieldName(),
                             behaviorEntry
                     );
-                    m_fieldReferences.put(calledFieldEntry, reference);
+                    fieldReferences.put(calledFieldEntry, reference);
                 }
 
                 @Override
@@ -214,7 +214,7 @@ public class JarIndex {
                             call.getMethodName(),
                             behaviorEntry
                     );
-                    m_behaviorReferences.put(calledConstructorEntry, reference);
+                    behaviorReferences.put(calledConstructorEntry, reference);
                 }
 
                 @Override
@@ -225,7 +225,7 @@ public class JarIndex {
                             call.getClassName(),
                             behaviorEntry
                     );
-                    m_behaviorReferences.put(calledConstructorEntry, reference);
+                    behaviorReferences.put(calledConstructorEntry, reference);
                 }
             });
         } catch (CannotCompileException ex) {
@@ -314,7 +314,7 @@ public class JarIndex {
 
                     // is the entry a superclass of the context?
                     ClassEntry calledClassEntry = reference.entry.getClassEntry();
-                    ClassEntry superclassEntry = m_translationIndex.getSuperclass(reference.context.getClassEntry());
+                    ClassEntry superclassEntry = this.translationIndex.getSuperclass(reference.context.getClassEntry());
                     if (superclassEntry != null && superclassEntry.equals(calledClassEntry)) {
                         // it's a super call, skip
                         continue;
@@ -360,7 +360,7 @@ public class JarIndex {
         }
 
         // is the outer class in the jar?
-        return m_obfClassEntries.contains(outerClassEntry);
+        return this.obfClassEntries.contains(outerClassEntry);
 
     }
 
@@ -500,31 +500,31 @@ public class JarIndex {
     }
 
     public Set<ClassEntry> getObfClassEntries() {
-        return m_obfClassEntries;
+        return this.obfClassEntries;
     }
 
     public Collection<FieldEntry> getObfFieldEntries() {
-        return m_fields.values();
+        return this.fields.values();
     }
 
     public Collection<FieldEntry> getObfFieldEntries(ClassEntry classEntry) {
-        return m_fields.get(classEntry);
+        return this.fields.get(classEntry);
     }
 
     public Collection<BehaviorEntry> getObfBehaviorEntries() {
-        return m_behaviors.values();
+        return this.behaviors.values();
     }
 
     public Collection<BehaviorEntry> getObfBehaviorEntries(ClassEntry classEntry) {
-        return m_behaviors.get(classEntry);
+        return this.behaviors.get(classEntry);
     }
 
     public TranslationIndex getTranslationIndex() {
-        return m_translationIndex;
+        return this.translationIndex;
     }
 
     public Access getAccess(Entry entry) {
-        return m_access.get(entry);
+        return this.access.get(entry);
     }
 
     public ClassInheritanceTreeNode getClassInheritance(Translator deobfuscatingTranslator, ClassEntry obfClassEntry) {
@@ -532,7 +532,7 @@ public class JarIndex {
         // get the root node
         List<String> ancestry = Lists.newArrayList();
         ancestry.add(obfClassEntry.getName());
-        for (ClassEntry classEntry : m_translationIndex.getAncestry(obfClassEntry)) {
+        for (ClassEntry classEntry : this.translationIndex.getAncestry(obfClassEntry)) {
             if (containsObfClass(classEntry)) {
                 ancestry.add(classEntry.getName());
             }
@@ -543,7 +543,7 @@ public class JarIndex {
         );
 
         // expand all children recursively
-        rootNode.load(m_translationIndex, true);
+        rootNode.load(this.translationIndex, true);
 
         return rootNode;
     }
@@ -563,7 +563,7 @@ public class JarIndex {
 
         // travel to the ancestor implementation
         ClassEntry baseImplementationClassEntry = obfMethodEntry.getClassEntry();
-        for (ClassEntry ancestorClassEntry : m_translationIndex.getAncestry(obfMethodEntry.getClassEntry())) {
+        for (ClassEntry ancestorClassEntry : this.translationIndex.getAncestry(obfMethodEntry.getClassEntry())) {
             MethodEntry ancestorMethodEntry = new MethodEntry(
                     new ClassEntry(ancestorClassEntry),
                     obfMethodEntry.getName(),
@@ -664,13 +664,13 @@ public class JarIndex {
     }
 
     public Collection<EntryReference<FieldEntry, BehaviorEntry>> getFieldReferences(FieldEntry fieldEntry) {
-        return m_fieldReferences.get(fieldEntry);
+        return this.fieldReferences.get(fieldEntry);
     }
 
     public Collection<FieldEntry> getReferencedFields(BehaviorEntry behaviorEntry) {
         // linear search is fast enough for now
         Set<FieldEntry> fieldEntries = Sets.newHashSet();
-        for (EntryReference<FieldEntry, BehaviorEntry> reference : m_fieldReferences.values()) {
+        for (EntryReference<FieldEntry, BehaviorEntry> reference : this.fieldReferences.values()) {
             if (reference.context == behaviorEntry) {
                 fieldEntries.add(reference.entry);
             }
@@ -679,13 +679,13 @@ public class JarIndex {
     }
 
     public Collection<EntryReference<BehaviorEntry, BehaviorEntry>> getBehaviorReferences(BehaviorEntry behaviorEntry) {
-        return m_behaviorReferences.get(behaviorEntry);
+        return this.behaviorReferences.get(behaviorEntry);
     }
 
     public Collection<BehaviorEntry> getReferencedBehaviors(BehaviorEntry behaviorEntry) {
         // linear search is fast enough for now
         Set<BehaviorEntry> behaviorEntries = Sets.newHashSet();
-        for (EntryReference<BehaviorEntry, BehaviorEntry> reference : m_behaviorReferences.values()) {
+        for (EntryReference<BehaviorEntry, BehaviorEntry> reference : this.behaviorReferences.values()) {
             if (reference.context == behaviorEntry) {
                 behaviorEntries.add(reference.entry);
             }
@@ -694,27 +694,27 @@ public class JarIndex {
     }
 
     public Collection<ClassEntry> getInnerClasses(ClassEntry obfOuterClassEntry) {
-        return m_innerClassesByOuter.get(obfOuterClassEntry);
+        return this.innerClassesByOuter.get(obfOuterClassEntry);
     }
 
     public ClassEntry getOuterClass(ClassEntry obfInnerClassEntry) {
-        return m_outerClassesByInner.get(obfInnerClassEntry);
+        return this.outerClassesByInner.get(obfInnerClassEntry);
     }
 
     public boolean isAnonymousClass(ClassEntry obfInnerClassEntry) {
-        return m_anonymousClasses.containsKey(obfInnerClassEntry);
+        return this.anonymousClasses.containsKey(obfInnerClassEntry);
     }
 
     public BehaviorEntry getAnonymousClassCaller(ClassEntry obfInnerClassName) {
-        return m_anonymousClasses.get(obfInnerClassName);
+        return this.anonymousClasses.get(obfInnerClassName);
     }
 
     public Set<ClassEntry> getInterfaces(String className) {
         ClassEntry classEntry = new ClassEntry(className);
         Set<ClassEntry> interfaces = new HashSet<ClassEntry>();
-        interfaces.addAll(m_translationIndex.getInterfaces(classEntry));
-        for (ClassEntry ancestor : m_translationIndex.getAncestry(classEntry)) {
-            interfaces.addAll(m_translationIndex.getInterfaces(ancestor));
+        interfaces.addAll(this.translationIndex.getInterfaces(classEntry));
+        for (ClassEntry ancestor : this.translationIndex.getAncestry(classEntry)) {
+            interfaces.addAll(this.translationIndex.getInterfaces(ancestor));
         }
         return interfaces;
     }
@@ -723,31 +723,31 @@ public class JarIndex {
 
         // linear search is fast enough for now
         Set<String> classNames = Sets.newHashSet();
-        for (Map.Entry<ClassEntry, ClassEntry> entry : m_translationIndex.getClassInterfaces()) {
+        for (Map.Entry<ClassEntry, ClassEntry> entry : this.translationIndex.getClassInterfaces()) {
             ClassEntry classEntry = entry.getKey();
             ClassEntry interfaceEntry = entry.getValue();
             if (interfaceEntry.getName().equals(targetInterfaceName)) {
                 classNames.add(classEntry.getClassName());
-                m_translationIndex.getSubclassNamesRecursively(classNames, classEntry);
+                this.translationIndex.getSubclassNamesRecursively(classNames, classEntry);
             }
         }
         return classNames;
     }
 
     public boolean isInterface(String className) {
-        return m_translationIndex.isInterface(new ClassEntry(className));
+        return this.translationIndex.isInterface(new ClassEntry(className));
     }
 
     public boolean containsObfClass(ClassEntry obfClassEntry) {
-        return m_obfClassEntries.contains(obfClassEntry);
+        return this.obfClassEntries.contains(obfClassEntry);
     }
 
     public boolean containsObfField(FieldEntry obfFieldEntry) {
-        return m_access.containsKey(obfFieldEntry);
+        return this.access.containsKey(obfFieldEntry);
     }
 
     public boolean containsObfBehavior(BehaviorEntry obfBehaviorEntry) {
-        return m_access.containsKey(obfBehaviorEntry);
+        return this.access.containsKey(obfBehaviorEntry);
     }
 
     public boolean containsObfArgument(ArgumentEntry obfArgumentEntry) {
@@ -776,7 +776,7 @@ public class JarIndex {
     }
 
     public MethodEntry getBridgedMethod(MethodEntry bridgeMethodEntry) {
-        return m_bridgedMethods.get(bridgeMethodEntry);
+        return this.bridgedMethods.get(bridgeMethodEntry);
     }
 
     public List<ClassEntry> getObfClassChain(ClassEntry obfClassEntry) {
diff --git a/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java b/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
index 2ee3ec1f..1cf80d91 100644
--- a/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
+++ b/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
@@ -24,40 +24,40 @@ public class MethodImplementationsTreeNode extends DefaultMutableTreeNode {
 
     private static final long serialVersionUID = 3781080657461899915L;
 
-    private Translator m_deobfuscatingTranslator;
-    private MethodEntry m_entry;
+    private Translator deobfuscatingTranslator;
+    private MethodEntry entry;
 
     public MethodImplementationsTreeNode(Translator deobfuscatingTranslator, MethodEntry entry) {
         if (entry == null) {
-            throw new IllegalArgumentException("entry cannot be null!");
+            throw new IllegalArgumentException("Entry cannot be null!");
         }
 
-        m_deobfuscatingTranslator = deobfuscatingTranslator;
-        m_entry = entry;
+        this.deobfuscatingTranslator = deobfuscatingTranslator;
+        this.entry = entry;
     }
 
     public MethodEntry getMethodEntry() {
-        return m_entry;
+        return this.entry;
     }
 
     public String getDeobfClassName() {
-        return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        return this.deobfuscatingTranslator.translateClass(this.entry.getClassName());
     }
 
     public String getDeobfMethodName() {
-        return m_deobfuscatingTranslator.translate(m_entry);
+        return this.deobfuscatingTranslator.translate(this.entry);
     }
 
     @Override
     public String toString() {
         String className = getDeobfClassName();
         if (className == null) {
-            className = m_entry.getClassName();
+            className = this.entry.getClassName();
         }
 
         String methodName = getDeobfMethodName();
         if (methodName == null) {
-            methodName = m_entry.getName();
+            methodName = this.entry.getName();
         }
         return className + "." + methodName + "()";
     }
@@ -66,14 +66,11 @@ public class MethodImplementationsTreeNode extends DefaultMutableTreeNode {
 
         // get all method implementations
         List<MethodImplementationsTreeNode> nodes = Lists.newArrayList();
-        for (String implementingClassName : index.getImplementingClasses(m_entry.getClassName())) {
-            MethodEntry methodEntry = new MethodEntry(
-                    new ClassEntry(implementingClassName),
-                    m_entry.getName(),
-                    m_entry.getSignature()
+        for (String implementingClassName : index.getImplementingClasses(this.entry.getClassName())) {
+            MethodEntry methodEntry = new MethodEntry(new ClassEntry(implementingClassName), this.entry.getName(), this.entry.getSignature()
             );
             if (index.containsObfBehavior(methodEntry)) {
-                nodes.add(new MethodImplementationsTreeNode(m_deobfuscatingTranslator, methodEntry));
+                nodes.add(new MethodImplementationsTreeNode(this.deobfuscatingTranslator, methodEntry));
             }
         }
 
diff --git a/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
index cf42ac77..a3bed6ed 100644
--- a/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
+++ b/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
@@ -24,45 +24,45 @@ public class MethodInheritanceTreeNode extends DefaultMutableTreeNode {
 
     private static final long serialVersionUID = 1096677030991810007L;
 
-    private Translator m_deobfuscatingTranslator;
-    private MethodEntry m_entry;
-    private boolean m_isImplemented;
+    private Translator deobfuscatingTranslator;
+    private MethodEntry entry;
+    private boolean isImplemented;
 
     public MethodInheritanceTreeNode(Translator deobfuscatingTranslator, MethodEntry entry, boolean isImplemented) {
-        m_deobfuscatingTranslator = deobfuscatingTranslator;
-        m_entry = entry;
-        m_isImplemented = isImplemented;
+        this.deobfuscatingTranslator = deobfuscatingTranslator;
+        this.entry = entry;
+        this.isImplemented = isImplemented;
     }
 
     public MethodEntry getMethodEntry() {
-        return m_entry;
+        return this.entry;
     }
 
     public String getDeobfClassName() {
-        return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        return this.deobfuscatingTranslator.translateClass(this.entry.getClassName());
     }
 
     public String getDeobfMethodName() {
-        return m_deobfuscatingTranslator.translate(m_entry);
+        return this.deobfuscatingTranslator.translate(this.entry);
     }
 
     public boolean isImplemented() {
-        return m_isImplemented;
+        return this.isImplemented;
     }
 
     @Override
     public String toString() {
         String className = getDeobfClassName();
         if (className == null) {
-            className = m_entry.getClassName();
+            className = this.entry.getClassName();
         }
 
-        if (!m_isImplemented) {
+        if (!this.isImplemented) {
             return className;
         } else {
             String methodName = getDeobfMethodName();
             if (methodName == null) {
-                methodName = m_entry.getName();
+                methodName = this.entry.getName();
             }
             return className + "." + methodName + "()";
         }
@@ -71,16 +71,10 @@ public class MethodInheritanceTreeNode extends DefaultMutableTreeNode {
     public void load(JarIndex index, boolean recurse) {
         // get all the child nodes
         List<MethodInheritanceTreeNode> nodes = Lists.newArrayList();
-        for (ClassEntry subclassEntry : index.getTranslationIndex().getSubclass(m_entry.getClassEntry())) {
-            MethodEntry methodEntry = new MethodEntry(
-                    subclassEntry,
-                    m_entry.getName(),
-                    m_entry.getSignature()
+        for (ClassEntry subclassEntry : index.getTranslationIndex().getSubclass(this.entry.getClassEntry())) {
+            MethodEntry methodEntry = new MethodEntry(subclassEntry, this.entry.getName(), this.entry.getSignature()
             );
-            nodes.add(new MethodInheritanceTreeNode(
-                    m_deobfuscatingTranslator,
-                    methodEntry,
-                    index.containsObfBehavior(methodEntry)
+            nodes.add(new MethodInheritanceTreeNode(this.deobfuscatingTranslator, methodEntry, index.containsObfBehavior(methodEntry)
             ));
         }
 
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndex.java b/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
index a20fbb44..cbc2945c 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
@@ -28,36 +28,36 @@ import cuchaz.enigma.mapping.Entry;
 
 public class SourceIndex {
 
-    private String m_source;
-    private TreeMap<Token, EntryReference<Entry, Entry>> m_tokenToReference;
-    private Multimap<EntryReference<Entry, Entry>, Token> m_referenceToTokens;
-    private Map<Entry, Token> m_declarationToToken;
-    private List<Integer> m_lineOffsets;
-    private boolean m_ignoreBadTokens;
+    private String source;
+    private TreeMap<Token, EntryReference<Entry, Entry>> tokenToReference;
+    private Multimap<EntryReference<Entry, Entry>, Token> referenceToTokens;
+    private Map<Entry, Token> declarationToToken;
+    private List<Integer> lineOffsets;
+    private boolean ignoreBadTokens;
 
     public SourceIndex(String source) {
         this(source, true);
     }
 
     public SourceIndex(String source, boolean ignoreBadTokens) {
-        m_source = source;
-        m_ignoreBadTokens = ignoreBadTokens;
-        m_tokenToReference = Maps.newTreeMap();
-        m_referenceToTokens = HashMultimap.create();
-        m_declarationToToken = Maps.newHashMap();
-        m_lineOffsets = Lists.newArrayList();
+        this.source = source;
+        this.ignoreBadTokens = ignoreBadTokens;
+        this.tokenToReference = Maps.newTreeMap();
+        this.referenceToTokens = HashMultimap.create();
+        this.declarationToToken = Maps.newHashMap();
+        this.lineOffsets = Lists.newArrayList();
 
         // count the lines
-        m_lineOffsets.add(0);
+        this.lineOffsets.add(0);
         for (int i = 0; i < source.length(); i++) {
             if (source.charAt(i) == '\n') {
-                m_lineOffsets.add(i + 1);
+                this.lineOffsets.add(i + 1);
             }
         }
     }
 
     public String getSource() {
-        return m_source;
+        return this.source;
     }
 
     public Token getToken(AstNode node) {
@@ -75,11 +75,7 @@ public class SourceIndex {
             System.err.println(String.format("WARNING: %s \"%s\" has invalid region: %s", node.getNodeType(), name, region));
             return null;
         }
-        Token token = new Token(
-                toPos(region.getBeginLine(), region.getBeginColumn()),
-                toPos(region.getEndLine(), region.getEndColumn()),
-                m_source
-        );
+        Token token = new Token(toPos(region.getBeginLine(), region.getBeginColumn()), toPos(region.getEndLine(), region.getEndColumn()), this.source);
         if (token.start == 0) {
             // DEBUG
             System.err.println(String.format("WARNING: %s \"%s\" has invalid start: %s", node.getNodeType(), name, region));
@@ -90,7 +86,7 @@ public class SourceIndex {
         // System.out.println( String.format( "%s \"%s\" region: %s", node.getNodeType(), name, region ) );
 
         // if the token has a $ in it, something's wrong. Ignore this token
-        if (name.lastIndexOf('$') >= 0 && m_ignoreBadTokens) {
+        if (name.lastIndexOf('$') >= 0 && this.ignoreBadTokens) {
             // DEBUG
             System.err.println(String.format("WARNING: %s \"%s\" is probably a bad token. It was ignored", node.getNodeType(), name));
             return null;
@@ -103,8 +99,8 @@ public class SourceIndex {
         Token token = getToken(node);
         if (token != null) {
             EntryReference<Entry, Entry> deobfReference = new EntryReference<Entry, Entry>(deobfEntry, token.text, deobfContext);
-            m_tokenToReference.put(token, deobfReference);
-            m_referenceToTokens.put(deobfReference, token);
+            this.tokenToReference.put(token, deobfReference);
+            this.referenceToTokens.put(deobfReference, token);
         }
     }
 
@@ -112,14 +108,14 @@ public class SourceIndex {
         Token token = getToken(node);
         if (token != null) {
             EntryReference<Entry, Entry> reference = new EntryReference<Entry, Entry>(deobfEntry, token.text);
-            m_tokenToReference.put(token, reference);
-            m_referenceToTokens.put(reference, token);
-            m_declarationToToken.put(deobfEntry, token);
+            this.tokenToReference.put(token, reference);
+            this.referenceToTokens.put(reference, token);
+            this.declarationToToken.put(deobfEntry, token);
         }
     }
 
     public Token getReferenceToken(int pos) {
-        Token token = m_tokenToReference.floorKey(new Token(pos, pos, null));
+        Token token = this.tokenToReference.floorKey(new Token(pos, pos, null));
         if (token != null && token.contains(pos)) {
             return token;
         }
@@ -127,44 +123,44 @@ public class SourceIndex {
     }
 
     public Collection<Token> getReferenceTokens(EntryReference<Entry, Entry> deobfReference) {
-        return m_referenceToTokens.get(deobfReference);
+        return this.referenceToTokens.get(deobfReference);
     }
 
     public EntryReference<Entry, Entry> getDeobfReference(Token token) {
         if (token == null) {
             return null;
         }
-        return m_tokenToReference.get(token);
+        return this.tokenToReference.get(token);
     }
 
     public void replaceDeobfReference(Token token, EntryReference<Entry, Entry> newDeobfReference) {
-        EntryReference<Entry, Entry> oldDeobfReference = m_tokenToReference.get(token);
-        m_tokenToReference.put(token, newDeobfReference);
-        Collection<Token> tokens = m_referenceToTokens.get(oldDeobfReference);
-        m_referenceToTokens.removeAll(oldDeobfReference);
-        m_referenceToTokens.putAll(newDeobfReference, tokens);
+        EntryReference<Entry, Entry> oldDeobfReference = this.tokenToReference.get(token);
+        this.tokenToReference.put(token, newDeobfReference);
+        Collection<Token> tokens = this.referenceToTokens.get(oldDeobfReference);
+        this.referenceToTokens.removeAll(oldDeobfReference);
+        this.referenceToTokens.putAll(newDeobfReference, tokens);
     }
 
     public Iterable<Token> referenceTokens() {
-        return m_tokenToReference.keySet();
+        return this.tokenToReference.keySet();
     }
 
     public Iterable<Token> declarationTokens() {
-        return m_declarationToToken.values();
+        return this.declarationToToken.values();
     }
 
     public Iterable<Entry> declarations() {
-        return m_declarationToToken.keySet();
+        return this.declarationToToken.keySet();
     }
 
     public Token getDeclarationToken(Entry deobfEntry) {
-        return m_declarationToToken.get(deobfEntry);
+        return this.declarationToToken.get(deobfEntry);
     }
 
     public int getLineNumber(int pos) {
         // line number is 1-based
         int line = 0;
-        for (Integer offset : m_lineOffsets) {
+        for (Integer offset : this.lineOffsets) {
             if (offset > pos) {
                 break;
             }
@@ -175,11 +171,11 @@ public class SourceIndex {
 
     public int getColumnNumber(int pos) {
         // column number is 1-based
-        return pos - m_lineOffsets.get(getLineNumber(pos) - 1) + 1;
+        return pos - this.lineOffsets.get(getLineNumber(pos) - 1) + 1;
     }
 
     private int toPos(int line, int col) {
         // line and col are 1-based
-        return m_lineOffsets.get(line - 1) + col - 1;
+        return this.lineOffsets.get(line - 1) + col - 1;
     }
 }
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
index e2b567e8..4a468e7e 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
@@ -14,16 +14,16 @@ import com.strobel.assembler.metadata.*;
 import com.strobel.decompiler.languages.TextLocation;
 import com.strobel.decompiler.languages.java.ast.*;
 
-import cuchaz.enigma.mapping.*;
-
 import java.lang.Error;
 
+import cuchaz.enigma.mapping.*;
+
 public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
 
-    private BehaviorEntry m_behaviorEntry;
+    private BehaviorEntry behaviorEntry;
 
     public SourceIndexBehaviorVisitor(BehaviorEntry behaviorEntry) {
-        m_behaviorEntry = behaviorEntry;
+        this.behaviorEntry = behaviorEntry;
     }
 
     @Override
@@ -54,7 +54,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
                 tokenNode = node.getTarget();
             }
             if (tokenNode != null) {
-                index.addReference(tokenNode, behaviorEntry, m_behaviorEntry);
+                index.addReference(tokenNode, behaviorEntry, this.behaviorEntry);
             }
         }
 
@@ -72,7 +72,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
 
             ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
             FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new Type(ref.getErasedSignature()));
-            index.addReference(node.getMemberNameToken(), fieldEntry, m_behaviorEntry);
+            index.addReference(node.getMemberNameToken(), fieldEntry, this.behaviorEntry);
         }
 
         return recurse(node, index);
@@ -83,7 +83,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
         TypeReference ref = node.getUserData(Keys.TYPE_REFERENCE);
         if (node.getIdentifierToken().getStartLocation() != TextLocation.EMPTY) {
             ClassEntry classEntry = new ClassEntry(ref.getInternalName());
-            index.addReference(node.getIdentifierToken(), classEntry, m_behaviorEntry);
+            index.addReference(node.getIdentifierToken(), classEntry, this.behaviorEntry);
         }
 
         return recurse(node, index);
@@ -108,7 +108,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
         if (ref != null) {
             ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
             FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new Type(ref.getErasedSignature()));
-            index.addReference(node.getIdentifierToken(), fieldEntry, m_behaviorEntry);
+            index.addReference(node.getIdentifierToken(), fieldEntry, this.behaviorEntry);
         }
 
         return recurse(node, index);
@@ -122,7 +122,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
             ConstructorEntry constructorEntry = new ConstructorEntry(classEntry, new Signature(ref.getErasedSignature()));
             if (node.getType() instanceof SimpleType) {
                 SimpleType simpleTypeNode = (SimpleType) node.getType();
-                index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, m_behaviorEntry);
+                index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, this.behaviorEntry);
             }
         }
 
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
index 0a3bad51..06ce042b 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
@@ -21,10 +21,10 @@ import cuchaz.enigma.mapping.*;
 
 public class SourceIndexClassVisitor extends SourceIndexVisitor {
 
-    private ClassEntry m_classEntry;
+    private ClassEntry classEntry;
 
     public SourceIndexClassVisitor(ClassEntry classEntry) {
-        m_classEntry = classEntry;
+        this.classEntry = classEntry;
     }
 
     @Override
@@ -32,7 +32,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
         // is this this class, or a subtype?
         TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
         ClassEntry classEntry = new ClassEntry(def.getInternalName());
-        if (!classEntry.equals(m_classEntry)) {
+        if (!classEntry.equals(this.classEntry)) {
             // it's a sub-type, recurse
             index.addDeclaration(node.getNameToken(), classEntry);
             return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
@@ -46,7 +46,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
         TypeReference ref = node.getUserData(Keys.TYPE_REFERENCE);
         if (node.getIdentifierToken().getStartLocation() != TextLocation.EMPTY) {
             ClassEntry classEntry = new ClassEntry(ref.getInternalName());
-            index.addReference(node.getIdentifierToken(), classEntry, m_classEntry);
+            index.addReference(node.getIdentifierToken(), classEntry, this.classEntry);
         }
 
         return recurse(node, index);
diff --git a/src/main/java/cuchaz/enigma/analysis/Token.java b/src/main/java/cuchaz/enigma/analysis/Token.java
index 0103df2e..575c373f 100644
--- a/src/main/java/cuchaz/enigma/analysis/Token.java
+++ b/src/main/java/cuchaz/enigma/analysis/Token.java
@@ -39,10 +39,7 @@ public class Token implements Comparable<Token> {
 
     @Override
     public boolean equals(Object other) {
-        if (other instanceof Token) {
-            return equals((Token) other);
-        }
-        return false;
+        return other instanceof Token && equals((Token) other);
     }
 
     public boolean equals(Token other) {
diff --git a/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java b/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
index 0261a96a..f020ae2c 100644
--- a/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
@@ -30,50 +30,47 @@ public class TranslationIndex implements Serializable {
 
     private static final long serialVersionUID = 738687982126844179L;
 
-    private Map<ClassEntry, ClassEntry> m_superclasses;
-    private Multimap<ClassEntry, FieldEntry> m_fieldEntries;
-    private Multimap<ClassEntry, BehaviorEntry> m_behaviorEntries;
-    private Multimap<ClassEntry, ClassEntry> m_interfaces;
+    private Map<ClassEntry, ClassEntry> superclasses;
+    private Multimap<ClassEntry, FieldEntry> fieldEntries;
+    private Multimap<ClassEntry, BehaviorEntry> behaviorEntries;
+    private Multimap<ClassEntry, ClassEntry> interfaces;
 
     public TranslationIndex() {
-        m_superclasses = Maps.newHashMap();
-        m_fieldEntries = HashMultimap.create();
-        m_behaviorEntries = HashMultimap.create();
-        m_interfaces = HashMultimap.create();
+        this.superclasses = Maps.newHashMap();
+        this.fieldEntries = HashMultimap.create();
+        this.behaviorEntries = HashMultimap.create();
+        this.interfaces = HashMultimap.create();
     }
 
     public TranslationIndex(TranslationIndex other, Translator translator) {
 
         // translate the superclasses
-        m_superclasses = Maps.newHashMap();
-        for (Map.Entry<ClassEntry, ClassEntry> mapEntry : other.m_superclasses.entrySet()) {
-            m_superclasses.put(
-                    translator.translateEntry(mapEntry.getKey()),
-                    translator.translateEntry(mapEntry.getValue())
-            );
+        this.superclasses = Maps.newHashMap();
+        for (Map.Entry<ClassEntry, ClassEntry> mapEntry : other.superclasses.entrySet()) {
+            this.superclasses.put(translator.translateEntry(mapEntry.getKey()), translator.translateEntry(mapEntry.getValue()));
         }
 
         // translate the interfaces
-        m_interfaces = HashMultimap.create();
-        for (Map.Entry<ClassEntry, ClassEntry> mapEntry : other.m_interfaces.entries()) {
-            m_interfaces.put(
+        this.interfaces = HashMultimap.create();
+        for (Map.Entry<ClassEntry, ClassEntry> mapEntry : other.interfaces.entries()) {
+            this.interfaces.put(
                     translator.translateEntry(mapEntry.getKey()),
                     translator.translateEntry(mapEntry.getValue())
             );
         }
 
         // translate the fields
-        m_fieldEntries = HashMultimap.create();
-        for (Map.Entry<ClassEntry, FieldEntry> mapEntry : other.m_fieldEntries.entries()) {
-            m_fieldEntries.put(
+        this.fieldEntries = HashMultimap.create();
+        for (Map.Entry<ClassEntry, FieldEntry> mapEntry : other.fieldEntries.entries()) {
+            this.fieldEntries.put(
                     translator.translateEntry(mapEntry.getKey()),
                     translator.translateEntry(mapEntry.getValue())
             );
         }
 
-        m_behaviorEntries = HashMultimap.create();
-        for (Map.Entry<ClassEntry, BehaviorEntry> mapEntry : other.m_behaviorEntries.entries()) {
-            m_behaviorEntries.put(
+        this.behaviorEntries = HashMultimap.create();
+        for (Map.Entry<ClassEntry, BehaviorEntry> mapEntry : other.behaviorEntries.entries()) {
+            this.behaviorEntries.put(
                     translator.translateEntry(mapEntry.getKey()),
                     translator.translateEntry(mapEntry.getValue())
             );
@@ -94,14 +91,14 @@ public class TranslationIndex implements Serializable {
         // add the superclass
         ClassEntry superclassEntry = EntryFactory.getSuperclassEntry(c);
         if (superclassEntry != null) {
-            m_superclasses.put(classEntry, superclassEntry);
+            this.superclasses.put(classEntry, superclassEntry);
         }
 
         // add the interfaces
         for (String interfaceClassName : c.getClassFile().getInterfaces()) {
             ClassEntry interfaceClassEntry = new ClassEntry(Descriptor.toJvmName(interfaceClassName));
             if (!isJre(interfaceClassEntry)) {
-                m_interfaces.put(classEntry, interfaceClassEntry);
+                this.interfaces.put(classEntry, interfaceClassEntry);
             }
         }
 
@@ -109,25 +106,25 @@ public class TranslationIndex implements Serializable {
             // add fields
             for (CtField field : c.getDeclaredFields()) {
                 FieldEntry fieldEntry = EntryFactory.getFieldEntry(field);
-                m_fieldEntries.put(fieldEntry.getClassEntry(), fieldEntry);
+                this.fieldEntries.put(fieldEntry.getClassEntry(), fieldEntry);
             }
 
             // add behaviors
             for (CtBehavior behavior : c.getDeclaredBehaviors()) {
                 BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior);
-                m_behaviorEntries.put(behaviorEntry.getClassEntry(), behaviorEntry);
+                this.behaviorEntries.put(behaviorEntry.getClassEntry(), behaviorEntry);
             }
         }
     }
 
     public void renameClasses(Map<String, String> renames) {
-        EntryRenamer.renameClassesInMap(renames, m_superclasses);
-        EntryRenamer.renameClassesInMultimap(renames, m_fieldEntries);
-        EntryRenamer.renameClassesInMultimap(renames, m_behaviorEntries);
+        EntryRenamer.renameClassesInMap(renames, this.superclasses);
+        EntryRenamer.renameClassesInMultimap(renames,this.fieldEntries);
+        EntryRenamer.renameClassesInMultimap(renames, this.behaviorEntries);
     }
 
     public ClassEntry getSuperclass(ClassEntry classEntry) {
-        return m_superclasses.get(classEntry);
+        return this.superclasses.get(classEntry);
     }
 
     public List<ClassEntry> getAncestry(ClassEntry classEntry) {
@@ -145,7 +142,7 @@ public class TranslationIndex implements Serializable {
 
         // linear search is fast enough for now
         List<ClassEntry> subclasses = Lists.newArrayList();
-        for (Map.Entry<ClassEntry, ClassEntry> entry : m_superclasses.entrySet()) {
+        for (Map.Entry<ClassEntry, ClassEntry> entry : this.superclasses.entrySet()) {
             ClassEntry subclass = entry.getKey();
             ClassEntry superclass = entry.getValue();
             if (classEntry.equals(superclass)) {
@@ -170,15 +167,15 @@ public class TranslationIndex implements Serializable {
     }
 
     public Collection<Map.Entry<ClassEntry, ClassEntry>> getClassInterfaces() {
-        return m_interfaces.entries();
+        return this.interfaces.entries();
     }
 
     public Collection<ClassEntry> getInterfaces(ClassEntry classEntry) {
-        return m_interfaces.get(classEntry);
+        return this.interfaces.get(classEntry);
     }
 
     public boolean isInterface(ClassEntry classEntry) {
-        return m_interfaces.containsValue(classEntry);
+        return this.interfaces.containsValue(classEntry);
     }
 
     public boolean entryExists(Entry entry) {
@@ -193,11 +190,11 @@ public class TranslationIndex implements Serializable {
     }
 
     public boolean fieldExists(FieldEntry fieldEntry) {
-        return m_fieldEntries.containsEntry(fieldEntry.getClassEntry(), fieldEntry);
+        return this.fieldEntries.containsEntry(fieldEntry.getClassEntry(), fieldEntry);
     }
 
     public boolean behaviorExists(BehaviorEntry behaviorEntry) {
-        return m_behaviorEntries.containsEntry(behaviorEntry.getClassEntry(), behaviorEntry);
+        return this.behaviorEntries.containsEntry(behaviorEntry.getClassEntry(), behaviorEntry);
     }
 
     public ClassEntry resolveEntryClass(Entry entry) {
@@ -243,7 +240,7 @@ public class TranslationIndex implements Serializable {
 
         // the interfaces for any class is a forest
         // so let's look at all the trees
-        for (ClassEntry interfaceEntry : m_interfaces.get(entry.getClassEntry())) {
+        for (ClassEntry interfaceEntry : this.interfaces.get(entry.getClassEntry())) {
             ClassEntry resolvedClassEntry = resolveSuperclass(entry.cloneToNewClass(interfaceEntry));
             if (resolvedClassEntry != null) {
                 return resolvedClassEntry;
@@ -261,9 +258,9 @@ public class TranslationIndex implements Serializable {
             throws IOException {
         GZIPOutputStream gzipout = new GZIPOutputStream(out);
         ObjectOutputStream oout = new ObjectOutputStream(gzipout);
-        oout.writeObject(m_superclasses);
-        oout.writeObject(m_fieldEntries);
-        oout.writeObject(m_behaviorEntries);
+        oout.writeObject(this.superclasses);
+        oout.writeObject(this.fieldEntries);
+        oout.writeObject(this.behaviorEntries);
         gzipout.finish();
     }
 
@@ -272,9 +269,9 @@ public class TranslationIndex implements Serializable {
             throws IOException {
         try {
             ObjectInputStream oin = new ObjectInputStream(new GZIPInputStream(in));
-            m_superclasses = (HashMap<ClassEntry, ClassEntry>) oin.readObject();
-            m_fieldEntries = (HashMultimap<ClassEntry, FieldEntry>) oin.readObject();
-            m_behaviorEntries = (HashMultimap<ClassEntry, BehaviorEntry>) oin.readObject();
+            this.superclasses = (HashMap<ClassEntry, ClassEntry>) oin.readObject();
+            this.fieldEntries = (HashMultimap<ClassEntry, FieldEntry>) oin.readObject();
+            this.behaviorEntries = (HashMultimap<ClassEntry, BehaviorEntry>) oin.readObject();
         } catch (ClassNotFoundException ex) {
             throw new Error(ex);
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java b/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java
index 8058d0ea..19c39d3c 100644
--- a/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java
+++ b/src/main/java/cuchaz/enigma/bytecode/CheckCastIterator.java
@@ -31,29 +31,29 @@ public class CheckCastIterator implements Iterator<CheckCast> {
         }
     }
 
-    private ConstPool m_constants;
-    private CodeAttribute m_attribute;
-    private CodeIterator m_iter;
-    private CheckCast m_next;
+    private ConstPool constants;
+    private CodeAttribute attribute;
+    private CodeIterator iter;
+    private CheckCast next;
 
     public CheckCastIterator(CodeAttribute codeAttribute) throws BadBytecode {
-        m_constants = codeAttribute.getConstPool();
-        m_attribute = codeAttribute;
-        m_iter = m_attribute.iterator();
+        this.constants = codeAttribute.getConstPool();
+        this.attribute = codeAttribute;
+        this.iter = this.attribute.iterator();
 
-        m_next = getNext();
+        this.next = getNext();
     }
 
     @Override
     public boolean hasNext() {
-        return m_next != null;
+        return this.next != null;
     }
 
     @Override
     public CheckCast next() {
-        CheckCast out = m_next;
+        CheckCast out = this.next;
         try {
-            m_next = getNext();
+            this.next = getNext();
         } catch (BadBytecode ex) {
             throw new Error(ex);
         }
@@ -67,16 +67,16 @@ public class CheckCastIterator implements Iterator<CheckCast> {
 
     private CheckCast getNext() throws BadBytecode {
         int prevPos = 0;
-        while (m_iter.hasNext()) {
-            int pos = m_iter.next();
-            int opcode = m_iter.byteAt(pos);
+        while (this.iter.hasNext()) {
+            int pos = this.iter.next();
+            int opcode = this.iter.byteAt(pos);
             switch (opcode) {
                 case Opcode.CHECKCAST:
 
                     // get the type of this op code (next two bytes are a classinfo index)
                     MethodEntry prevMethodEntry = getMethodEntry(prevPos);
                     if (prevMethodEntry != null) {
-                        return new CheckCast(m_constants.getClassInfo(m_iter.s16bitAt(pos + 1)), prevMethodEntry);
+                        return new CheckCast(this.constants.getClassInfo(this.iter.s16bitAt(pos + 1)), prevMethodEntry);
                     }
                     break;
             }
@@ -86,25 +86,25 @@ public class CheckCastIterator implements Iterator<CheckCast> {
     }
 
     private MethodEntry getMethodEntry(int pos) {
-        switch (m_iter.byteAt(pos)) {
+        switch (this.iter.byteAt(pos)) {
             case Opcode.INVOKEVIRTUAL:
             case Opcode.INVOKESTATIC:
             case Opcode.INVOKEDYNAMIC:
             case Opcode.INVOKESPECIAL: {
-                int index = m_iter.s16bitAt(pos + 1);
+                int index = this.iter.s16bitAt(pos + 1);
                 return new MethodEntry(
-                        new ClassEntry(Descriptor.toJvmName(m_constants.getMethodrefClassName(index))),
-                        m_constants.getMethodrefName(index),
-                        new Signature(m_constants.getMethodrefType(index))
+                        new ClassEntry(Descriptor.toJvmName(this.constants.getMethodrefClassName(index))),
+                        this.constants.getMethodrefName(index),
+                        new Signature(this.constants.getMethodrefType(index))
                 );
             }
 
             case Opcode.INVOKEINTERFACE: {
-                int index = m_iter.s16bitAt(pos + 1);
+                int index = this.iter.s16bitAt(pos + 1);
                 return new MethodEntry(
-                        new ClassEntry(Descriptor.toJvmName(m_constants.getInterfaceMethodrefClassName(index))),
-                        m_constants.getInterfaceMethodrefName(index),
-                        new Signature(m_constants.getInterfaceMethodrefType(index))
+                        new ClassEntry(Descriptor.toJvmName(this.constants.getInterfaceMethodrefClassName(index))),
+                        this.constants.getInterfaceMethodrefName(index),
+                        new Signature(this.constants.getInterfaceMethodrefType(index))
                 );
             }
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java b/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java
index 548bea75..d8e79711 100644
--- a/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java
+++ b/src/main/java/cuchaz/enigma/bytecode/ClassRenamer.java
@@ -51,8 +51,6 @@ public class ClassRenamer {
 
     private static class ReplacerClassMap extends HashMap<String, String> {
 
-        private static final long serialVersionUID = 317915213205066168L;
-
         private ClassNameReplacer m_replacer;
 
         public ReplacerClassMap(ClassNameReplacer replacer) {
@@ -151,7 +149,7 @@ public class ClassRenamer {
                 }
 
                                 /* DEBUG
-                                System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i)));
+                System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i)));
                                 */
             }
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java b/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java
index ef197cbe..8fdd8513 100644
--- a/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java
+++ b/src/main/java/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -22,10 +22,10 @@ import javassist.bytecode.SourceFileAttribute;
 
 public class ClassTranslator {
 
-    private Translator m_translator;
+    private Translator translator;
 
     public ClassTranslator(Translator translator) {
-        m_translator = translator;
+        this.translator = translator;
     }
 
     public void translate(CtClass c) {
@@ -46,7 +46,7 @@ public class ClassTranslator {
                             constants.getFieldrefName(i),
                             constants.getFieldrefType(i)
                     );
-                    FieldEntry translatedEntry = m_translator.translateEntry(entry);
+                    FieldEntry translatedEntry = this.translator.translateEntry(entry);
                     if (!entry.equals(translatedEntry)) {
                         editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getType().toString());
                     }
@@ -62,7 +62,7 @@ public class ClassTranslator {
                             editor.getMemberrefName(i),
                             editor.getMemberrefType(i)
                     );
-                    BehaviorEntry translatedEntry = m_translator.translateEntry(entry);
+                    BehaviorEntry translatedEntry = this.translator.translateEntry(entry);
                     if (!entry.equals(translatedEntry)) {
                         editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getSignature().toString());
                     }
@@ -78,13 +78,13 @@ public class ClassTranslator {
 
             // translate the name
             FieldEntry entry = EntryFactory.getFieldEntry(field);
-            String translatedName = m_translator.translate(entry);
+            String translatedName = this.translator.translate(entry);
             if (translatedName != null) {
                 field.setName(translatedName);
             }
 
             // translate the type
-            Type translatedType = m_translator.translateType(entry.getType());
+            Type translatedType = this.translator.translateType(entry.getType());
             field.getFieldInfo().setDescriptor(translatedType.toString());
         }
 
@@ -97,7 +97,7 @@ public class ClassTranslator {
                 CtMethod method = (CtMethod) behavior;
 
                 // translate the name
-                String translatedName = m_translator.translate(entry);
+                String translatedName = this.translator.translate(entry);
                 if (translatedName != null) {
                     method.setName(translatedName);
                 }
@@ -105,7 +105,7 @@ public class ClassTranslator {
 
             if (entry.getSignature() != null) {
                 // translate the signature
-                Signature translatedSignature = m_translator.translateSignature(entry.getSignature());
+                Signature translatedSignature = this.translator.translateSignature(entry.getSignature());
                 behavior.getMethodInfo().setDescriptor(translatedSignature.toString());
             }
         }
@@ -116,7 +116,7 @@ public class ClassTranslator {
 
             if (enclosingMethodAttr.methodIndex() == 0) {
                 BehaviorEntry obfBehaviorEntry = EntryFactory.getBehaviorEntry(Descriptor.toJvmName(enclosingMethodAttr.className()));
-                BehaviorEntry deobfBehaviorEntry = m_translator.translateEntry(obfBehaviorEntry);
+                BehaviorEntry deobfBehaviorEntry = this.translator.translateEntry(obfBehaviorEntry);
                 c.getClassFile().addAttribute(new EnclosingMethodAttribute(
                         constants,
                         deobfBehaviorEntry.getClassName()
@@ -127,7 +127,7 @@ public class ClassTranslator {
                         enclosingMethodAttr.methodName(),
                         enclosingMethodAttr.methodDescriptor()
                 );
-                BehaviorEntry deobfBehaviorEntry = m_translator.translateEntry(obfBehaviorEntry);
+                BehaviorEntry deobfBehaviorEntry = this.translator.translateEntry(obfBehaviorEntry);
                 c.getClassFile().addAttribute(new EnclosingMethodAttribute(
                         constants,
                         deobfBehaviorEntry.getClassName(),
@@ -139,10 +139,10 @@ public class ClassTranslator {
 
         // translate all the class names referenced in the code
         // the above code only changed method/field/reference names and types, but not the rest of the class references
-        ClassRenamer.renameClasses(c, m_translator);
+        ClassRenamer.renameClasses(c, this.translator);
 
         // translate the source file attribute too
-        ClassEntry deobfClassEntry = m_translator.translateEntry(classEntry);
+        ClassEntry deobfClassEntry = this.translator.translateEntry(classEntry);
         if (deobfClassEntry != null) {
             String sourceFile = Descriptor.toJvmName(deobfClassEntry.getOutermostClassEntry().getSimpleName()) + ".java";
             c.getClassFile().addAttribute(new SourceFileAttribute(constants, sourceFile));
diff --git a/src/main/java/cuchaz/enigma/bytecode/ConstPoolEditor.java b/src/main/java/cuchaz/enigma/bytecode/ConstPoolEditor.java
index 0082a72c..256df61e 100644
--- a/src/main/java/cuchaz/enigma/bytecode/ConstPoolEditor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/ConstPoolEditor.java
@@ -25,62 +25,62 @@ import javassist.bytecode.Descriptor;
 
 public class ConstPoolEditor {
 
-    private static Method m_getItem;
-    private static Method m_addItem;
-    private static Method m_addItem0;
-    private static Field m_items;
-    private static Field m_cache;
-    private static Field m_numItems;
-    private static Field m_objects;
-    private static Field m_elements;
-    private static Method m_methodWritePool;
-    private static Constructor<ConstPool> m_constructorPool;
+    private static Method getItem;
+    private static Method addItem;
+    private static Method addItem0;
+    private static Field items;
+    private static Field cache;
+    private static Field numItems;
+    private static Field objects;
+    private static Field elements;
+    private static Method methodWritePool;
+    private static Constructor<ConstPool> constructorPool;
 
     static {
         try {
-            m_getItem = ConstPool.class.getDeclaredMethod("getItem", int.class);
-            m_getItem.setAccessible(true);
+            getItem = ConstPool.class.getDeclaredMethod("getItem", int.class);
+            getItem.setAccessible(true);
 
-            m_addItem = ConstPool.class.getDeclaredMethod("addItem", Class.forName("javassist.bytecode.ConstInfo"));
-            m_addItem.setAccessible(true);
+            addItem = ConstPool.class.getDeclaredMethod("addItem", Class.forName("javassist.bytecode.ConstInfo"));
+            addItem.setAccessible(true);
 
-            m_addItem0 = ConstPool.class.getDeclaredMethod("addItem0", Class.forName("javassist.bytecode.ConstInfo"));
-            m_addItem0.setAccessible(true);
+            addItem0 = ConstPool.class.getDeclaredMethod("addItem0", Class.forName("javassist.bytecode.ConstInfo"));
+            addItem0.setAccessible(true);
 
-            m_items = ConstPool.class.getDeclaredField("items");
-            m_items.setAccessible(true);
+            items = ConstPool.class.getDeclaredField("items");
+            items.setAccessible(true);
 
-            m_cache = ConstPool.class.getDeclaredField("itemsCache");
-            m_cache.setAccessible(true);
+            cache = ConstPool.class.getDeclaredField("itemsCache");
+            cache.setAccessible(true);
 
-            m_numItems = ConstPool.class.getDeclaredField("numOfItems");
-            m_numItems.setAccessible(true);
+            numItems = ConstPool.class.getDeclaredField("numOfItems");
+            numItems.setAccessible(true);
 
-            m_objects = Class.forName("javassist.bytecode.LongVector").getDeclaredField("objects");
-            m_objects.setAccessible(true);
+            objects = Class.forName("javassist.bytecode.LongVector").getDeclaredField("objects");
+            objects.setAccessible(true);
 
-            m_elements = Class.forName("javassist.bytecode.LongVector").getDeclaredField("elements");
-            m_elements.setAccessible(true);
+            elements = Class.forName("javassist.bytecode.LongVector").getDeclaredField("elements");
+            elements.setAccessible(true);
 
-            m_methodWritePool = ConstPool.class.getDeclaredMethod("write", DataOutputStream.class);
-            m_methodWritePool.setAccessible(true);
+            methodWritePool = ConstPool.class.getDeclaredMethod("write", DataOutputStream.class);
+            methodWritePool.setAccessible(true);
 
-            m_constructorPool = ConstPool.class.getDeclaredConstructor(DataInputStream.class);
-            m_constructorPool.setAccessible(true);
+            constructorPool = ConstPool.class.getDeclaredConstructor(DataInputStream.class);
+            constructorPool.setAccessible(true);
         } catch (Exception ex) {
             throw new Error(ex);
         }
     }
 
-    private ConstPool m_pool;
+    private ConstPool pool;
 
     public ConstPoolEditor(ConstPool pool) {
-        m_pool = pool;
+        this.pool = pool;
     }
 
     public void writePool(DataOutputStream out) {
         try {
-            m_methodWritePool.invoke(m_pool, out);
+            methodWritePool.invoke(this.pool, out);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -88,27 +88,27 @@ public class ConstPoolEditor {
 
     public static ConstPool readPool(DataInputStream in) {
         try {
-            return m_constructorPool.newInstance(in);
+            return constructorPool.newInstance(in);
         } catch (Exception ex) {
             throw new Error(ex);
         }
     }
 
     public String getMemberrefClassname(int memberrefIndex) {
-        return Descriptor.toJvmName(m_pool.getClassInfo(m_pool.getMemberClass(memberrefIndex)));
+        return Descriptor.toJvmName(this.pool.getClassInfo(this.pool.getMemberClass(memberrefIndex)));
     }
 
     public String getMemberrefName(int memberrefIndex) {
-        return m_pool.getUtf8Info(m_pool.getNameAndTypeName(m_pool.getMemberNameAndType(memberrefIndex)));
+        return this.pool.getUtf8Info(this.pool.getNameAndTypeName(this.pool.getMemberNameAndType(memberrefIndex)));
     }
 
     public String getMemberrefType(int memberrefIndex) {
-        return m_pool.getUtf8Info(m_pool.getNameAndTypeDescriptor(m_pool.getMemberNameAndType(memberrefIndex)));
+        return this.pool.getUtf8Info(this.pool.getNameAndTypeDescriptor(this.pool.getMemberNameAndType(memberrefIndex)));
     }
 
     public ConstInfoAccessor getItem(int index) {
         try {
-            Object entry = m_getItem.invoke(m_pool, index);
+            Object entry = getItem.invoke(this.pool, index);
             if (entry == null) {
                 return null;
             }
@@ -120,7 +120,7 @@ public class ConstPoolEditor {
 
     public int addItem(Object item) {
         try {
-            return (Integer) m_addItem.invoke(m_pool, item);
+            return (Integer) addItem.invoke(this.pool, item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -128,7 +128,7 @@ public class ConstPoolEditor {
 
     public int addItemForceNew(Object item) {
         try {
-            return (Integer) m_addItem0.invoke(m_pool, item);
+            return (Integer) addItem0.invoke(this.pool, item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -140,22 +140,22 @@ public class ConstPoolEditor {
             // remove the item from the cache
             HashMap cache = getCache();
             if (cache != null) {
-                Object item = getItem(m_pool.getSize() - 1);
+                Object item = getItem(this.pool.getSize() - 1);
                 cache.remove(item);
             }
 
             // remove the actual item
             // based off of LongVector.addElement()
-            Object items = m_items.get(m_pool);
-            Object[][] objects = (Object[][]) m_objects.get(items);
-            int numElements = (Integer) m_elements.get(items) - 1;
+            Object item = items.get(this.pool);
+            Object[][] object = (Object[][]) objects.get(items);
+            int numElements = (Integer) elements.get(items) - 1;
             int nth = numElements >> 7;
             int offset = numElements & (128 - 1);
-            objects[nth][offset] = null;
+            object[nth][offset] = null;
 
             // decrement the number of items
-            m_elements.set(items, numElements);
-            m_numItems.set(m_pool, (Integer) m_numItems.get(m_pool) - 1);
+            elements.set(item, numElements);
+            numItems.set(this.pool, (Integer) numItems.get(this.pool) - 1);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -164,7 +164,7 @@ public class ConstPoolEditor {
     @SuppressWarnings("rawtypes")
     public HashMap getCache() {
         try {
-            return (HashMap) m_cache.get(m_pool);
+            return (HashMap) cache.get(this.pool);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -183,7 +183,7 @@ public class ConstPoolEditor {
                 cache.remove(item);
             }
 
-            new MemberRefInfoAccessor(item).setNameAndTypeIndex(m_pool.addNameAndTypeInfo(newName, newType));
+            new MemberRefInfoAccessor(item).setNameAndTypeIndex(this.pool.addNameAndTypeInfo(newName, newType));
 
             // update the cache
             if (cache != null) {
@@ -212,7 +212,7 @@ public class ConstPoolEditor {
             }
 
             // add the new name and repoint the name-and-type to it
-            new ClassInfoAccessor(item).setNameIndex(m_pool.addUtf8Info(newName));
+            new ClassInfoAccessor(item).setNameIndex(this.pool.addUtf8Info(newName));
 
             // update the cache
             if (cache != null) {
@@ -252,7 +252,7 @@ public class ConstPoolEditor {
 
     public String dump() {
         StringBuilder buf = new StringBuilder();
-        for (int i = 1; i < m_pool.getSize(); i++) {
+        for (int i = 1; i < this.pool.getSize(); i++) {
             buf.append(String.format("%4d", i));
             buf.append("   ");
             buf.append(getItem(i).toString());
diff --git a/src/main/java/cuchaz/enigma/bytecode/InfoType.java b/src/main/java/cuchaz/enigma/bytecode/InfoType.java
index 89940d9e..86e57ab5 100644
--- a/src/main/java/cuchaz/enigma/bytecode/InfoType.java
+++ b/src/main/java/cuchaz/enigma/bytecode/InfoType.java
@@ -213,29 +213,29 @@ public enum InfoType {
         }
     };
 
-    private static Map<Integer, InfoType> m_types;
+    private static Map<Integer, InfoType> types;
 
     static {
-        m_types = Maps.newTreeMap();
+        types = Maps.newTreeMap();
         for (InfoType type : values()) {
-            m_types.put(type.getTag(), type);
+            types.put(type.getTag(), type);
         }
     }
 
-    private int m_tag;
-    private int m_level;
+    private int tag;
+    private int level;
 
     InfoType(int tag, int level) {
-        m_tag = tag;
-        m_level = level;
+        this.tag = tag;
+        this.level = level;
     }
 
     public int getTag() {
-        return m_tag;
+        return this.tag;
     }
 
     public int getLevel() {
-        return m_level;
+        return this.level;
     }
 
     public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
@@ -260,7 +260,7 @@ public enum InfoType {
     }
 
     public static InfoType getByTag(int tag) {
-        return m_types.get(tag);
+        return types.get(tag);
     }
 
     public static List<InfoType> getByLevel(int level) {
diff --git a/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java b/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java
index 25ac7d67..6d926106 100644
--- a/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java
+++ b/src/main/java/cuchaz/enigma/bytecode/InnerClassWriter.java
@@ -27,10 +27,10 @@ import javassist.bytecode.InnerClassesAttribute;
 
 public class InnerClassWriter {
 
-    private JarIndex m_index;
+    private JarIndex index;
 
     public InnerClassWriter(JarIndex index) {
-        m_index = index;
+        this.index = index;
     }
 
     public void write(CtClass c) {
@@ -43,7 +43,7 @@ public class InnerClassWriter {
         }
 
         ClassEntry obfClassEntry = EntryFactory.getClassEntry(c);
-        List<ClassEntry> obfClassChain = m_index.getObfClassChain(obfClassEntry);
+        List<ClassEntry> obfClassChain = this.index.getObfClassChain(obfClassEntry);
 
         boolean isInnerClass = obfClassChain.size() > 1;
         if (isInnerClass) {
@@ -51,7 +51,7 @@ public class InnerClassWriter {
             // it's an inner class, rename it to the fully qualified name
             c.setName(obfClassEntry.buildClassEntry(obfClassChain).getName());
 
-            BehaviorEntry caller = m_index.getAnonymousClassCaller(obfClassEntry);
+            BehaviorEntry caller = this.index.getAnonymousClassCaller(obfClassEntry);
             if (caller != null) {
 
                 // write the enclosing method attribute
@@ -64,7 +64,7 @@ public class InnerClassWriter {
         }
 
         // does this class have any inner classes?
-        Collection<ClassEntry> obfInnerClassEntries = m_index.getInnerClasses(obfClassEntry);
+        Collection<ClassEntry> obfInnerClassEntries = this.index.getInnerClasses(obfClassEntry);
 
         if (isInnerClass || !obfInnerClassEntries.isEmpty()) {
 
@@ -112,14 +112,14 @@ public class InnerClassWriter {
         int innerClassNameIndex = 0;
         int accessFlags = AccessFlag.PUBLIC;
         // TODO: need to figure out if we can put static or not
-        if (!m_index.isAnonymousClass(obfClassEntry)) {
+        if (!this.index.isAnonymousClass(obfClassEntry)) {
             innerClassNameIndex = constPool.addUtf8Info(obfInnerClassEntry.getInnermostClassName());
         }
 
         attr.append(innerClassIndex, parentClassIndex, innerClassNameIndex, accessFlags);
 
                 /* DEBUG 
-                System.out.println(String.format("\tOBF: %s -> ATTR: %s,%s,%s (replace %s with %s)",
+        System.out.println(String.format("\tOBF: %s -> ATTR: %s,%s,%s (replace %s with %s)",
                         obfClassEntry,
                         attr.innerClass(attr.tableLength() - 1),
                         attr.outerClass(attr.tableLength() - 1),
diff --git a/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java b/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java
index d0ce107f..8edea16e 100644
--- a/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java
+++ b/src/main/java/cuchaz/enigma/bytecode/LocalVariableRenamer.java
@@ -21,10 +21,10 @@ import javassist.bytecode.*;
 
 public class LocalVariableRenamer {
 
-    private Translator m_translator;
+    private Translator translator;
 
     public LocalVariableRenamer(Translator translator) {
-        m_translator = translator;
+        this.translator = translator;
     }
 
     public void rename(CtClass c) {
@@ -81,7 +81,7 @@ public class LocalVariableRenamer {
             numArgs = behaviorEntry.getSignature().getArgumentTypes().size();
             for (int i = starti; i < starti + numArgs && i < table.tableLength(); i++) {
                 int argi = i - starti;
-                String argName = m_translator.translate(new ArgumentEntry(behaviorEntry, argi, ""));
+                String argName = this.translator.translate(new ArgumentEntry(behaviorEntry, argi, ""));
                 if (argName == null) {
                     argName = "a" + (argi + 1);
                 }
diff --git a/src/main/java/cuchaz/enigma/bytecode/MethodParameterWriter.java b/src/main/java/cuchaz/enigma/bytecode/MethodParameterWriter.java
index e53e8e70..17ecbbe9 100644
--- a/src/main/java/cuchaz/enigma/bytecode/MethodParameterWriter.java
+++ b/src/main/java/cuchaz/enigma/bytecode/MethodParameterWriter.java
@@ -21,10 +21,10 @@ import javassist.bytecode.LocalVariableAttribute;
 
 public class MethodParameterWriter {
 
-    private Translator m_translator;
+    private Translator translator;
 
     public MethodParameterWriter(Translator translator) {
-        m_translator = translator;
+        this.translator = translator;
     }
 
     public void writeMethodArguments(CtClass c) {
@@ -56,7 +56,7 @@ public class MethodParameterWriter {
             // get the list of argument names
             List<String> names = new ArrayList<String>(numParams);
             for (int i = 0; i < numParams; i++) {
-                names.add(m_translator.translate(new ArgumentEntry(behaviorEntry, i, "")));
+                names.add(this.translator.translate(new ArgumentEntry(behaviorEntry, i, "")));
             }
 
             // save the mappings to the class
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
index fd987f53..66f22839 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
@@ -14,32 +14,18 @@ import java.lang.reflect.Field;
 
 public class ClassInfoAccessor {
 
-    private static Class<?> m_class;
-    private static Field m_nameIndex;
+    private Object item;
 
-    static {
-        try {
-            m_class = Class.forName("javassist.bytecode.ClassInfo");
-            m_nameIndex = m_class.getDeclaredField("name");
-            m_nameIndex.setAccessible(true);
-        } catch (Exception ex) {
-            throw new Error(ex);
-        }
-    }
-
-    public static boolean isType(ConstInfoAccessor accessor) {
-        return m_class.isAssignableFrom(accessor.getItem().getClass());
-    }
-
-    private Object m_item;
+    private static Class<?> clazz;
+    private static Field nameIndex;
 
     public ClassInfoAccessor(Object item) {
-        m_item = item;
+        this.item = item;
     }
 
     public int getNameIndex() {
         try {
-            return (Integer) m_nameIndex.get(m_item);
+            return (Integer) nameIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -47,7 +33,21 @@ public class ClassInfoAccessor {
 
     public void setNameIndex(int val) {
         try {
-            m_nameIndex.set(m_item, val);
+            nameIndex.set(this.item, val);
+        } catch (Exception ex) {
+            throw new Error(ex);
+        }
+    }
+
+    public static boolean isType(ConstInfoAccessor accessor) {
+        return clazz.isAssignableFrom(accessor.getItem().getClass());
+    }
+
+    static {
+        try {
+            clazz = Class.forName("javassist.bytecode.ClassInfo");
+            nameIndex = clazz.getDeclaredField("name");
+            nameIndex.setAccessible(true);
         } catch (Exception ex) {
             throw new Error(ex);
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
index 2692c069..ea775e9c 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
@@ -19,29 +19,17 @@ import cuchaz.enigma.bytecode.InfoType;
 
 public class ConstInfoAccessor {
 
-    private static Class<?> m_class;
-    private static Field m_index;
-    private static Method m_getTag;
+    private static Class<?> clazz;
+    private static Field index;
+    private static Method getTag;
 
-    static {
-        try {
-            m_class = Class.forName("javassist.bytecode.ConstInfo");
-            m_index = m_class.getDeclaredField("index");
-            m_index.setAccessible(true);
-            m_getTag = m_class.getMethod("getTag");
-            m_getTag.setAccessible(true);
-        } catch (Exception ex) {
-            throw new Error(ex);
-        }
-    }
-
-    private Object m_item;
+    private Object item;
 
     public ConstInfoAccessor(Object item) {
         if (item == null) {
             throw new IllegalArgumentException("item cannot be null!");
         }
-        m_item = item;
+        this.item = item;
     }
 
     public ConstInfoAccessor(DataInputStream in) throws IOException {
@@ -56,7 +44,7 @@ public class ConstInfoAccessor {
 
             Constructor<?> constructor = Class.forName(className).getConstructor(DataInputStream.class, int.class);
             constructor.setAccessible(true);
-            m_item = constructor.newInstance(in, oldIndex);
+            this.item = constructor.newInstance(in, oldIndex);
         } catch (IOException ex) {
             throw ex;
         } catch (Exception ex) {
@@ -65,12 +53,12 @@ public class ConstInfoAccessor {
     }
 
     public Object getItem() {
-        return m_item;
+        return this.item;
     }
 
     public int getIndex() {
         try {
-            return (Integer) m_index.get(m_item);
+            return (Integer) index.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -78,7 +66,7 @@ public class ConstInfoAccessor {
 
     public void setIndex(int val) {
         try {
-            m_index.set(m_item, val);
+            index.set(this.item, val);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -86,7 +74,7 @@ public class ConstInfoAccessor {
 
     public int getTag() {
         try {
-            return (Integer) m_getTag.invoke(m_item);
+            return (Integer) getTag.invoke(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -117,12 +105,12 @@ public class ConstInfoAccessor {
 
     public void write(DataOutputStream out) throws IOException {
         try {
-            out.writeUTF(m_item.getClass().getName());
+            out.writeUTF(this.item.getClass().getName());
             out.writeInt(getIndex());
 
-            Method method = m_item.getClass().getMethod("write", DataOutputStream.class);
+            Method method = this.item.getClass().getMethod("write", DataOutputStream.class);
             method.setAccessible(true);
-            method.invoke(m_item, out);
+            method.invoke(this.item, out);
         } catch (IOException ex) {
             throw ex;
         } catch (Exception ex) {
@@ -135,9 +123,9 @@ public class ConstInfoAccessor {
         try {
             ByteArrayOutputStream buf = new ByteArrayOutputStream();
             PrintWriter out = new PrintWriter(buf);
-            Method print = m_item.getClass().getMethod("print", PrintWriter.class);
+            Method print = this.item.getClass().getMethod("print", PrintWriter.class);
             print.setAccessible(true);
-            print.invoke(m_item, out);
+            print.invoke(this.item, out);
             out.close();
             return buf.toString().replace("\n", "");
         } catch (Exception ex) {
@@ -148,4 +136,16 @@ public class ConstInfoAccessor {
     public InfoType getType() {
         return InfoType.getByTag(getTag());
     }
+
+    static {
+        try {
+            clazz = Class.forName("javassist.bytecode.ConstInfo");
+            index = clazz.getDeclaredField("index");
+            index.setAccessible(true);
+            getTag = clazz.getMethod("getTag");
+            getTag.setAccessible(true);
+        } catch (Exception ex) {
+            throw new Error(ex);
+        }
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
index 0ca82b78..69aee160 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
@@ -14,35 +14,20 @@ import java.lang.reflect.Field;
 
 public class InvokeDynamicInfoAccessor {
 
-    private static Class<?> m_class;
-    private static Field m_bootstrapIndex;
-    private static Field m_nameAndTypeIndex;
+    private static Class<?> clazz;
+    private static Field bootstrapIndex;
+    private static Field nameAndTypeIndex;
 
-    static {
-        try {
-            m_class = Class.forName("javassist.bytecode.InvokeDynamicInfo");
-            m_bootstrapIndex = m_class.getDeclaredField("bootstrap");
-            m_bootstrapIndex.setAccessible(true);
-            m_nameAndTypeIndex = m_class.getDeclaredField("nameAndType");
-            m_nameAndTypeIndex.setAccessible(true);
-        } catch (Exception ex) {
-            throw new Error(ex);
-        }
-    }
 
-    public static boolean isType(ConstInfoAccessor accessor) {
-        return m_class.isAssignableFrom(accessor.getItem().getClass());
-    }
-
-    private Object m_item;
+    private Object item;
 
     public InvokeDynamicInfoAccessor(Object item) {
-        m_item = item;
+        this.item = item;
     }
 
     public int getBootstrapIndex() {
         try {
-            return (Integer) m_bootstrapIndex.get(m_item);
+            return (Integer) bootstrapIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -50,7 +35,7 @@ public class InvokeDynamicInfoAccessor {
 
     public void setBootstrapIndex(int val) {
         try {
-            m_bootstrapIndex.set(m_item, val);
+            bootstrapIndex.set(this.item, val);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -58,7 +43,7 @@ public class InvokeDynamicInfoAccessor {
 
     public int getNameAndTypeIndex() {
         try {
-            return (Integer) m_nameAndTypeIndex.get(m_item);
+            return (Integer) nameAndTypeIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -66,7 +51,23 @@ public class InvokeDynamicInfoAccessor {
 
     public void setNameAndTypeIndex(int val) {
         try {
-            m_nameAndTypeIndex.set(m_item, val);
+            nameAndTypeIndex.set(this.item, val);
+        } catch (Exception ex) {
+            throw new Error(ex);
+        }
+    }
+
+    public static boolean isType(ConstInfoAccessor accessor) {
+        return clazz.isAssignableFrom(accessor.getItem().getClass());
+    }
+
+    static {
+        try {
+            clazz = Class.forName("javassist.bytecode.InvokeDynamicInfo");
+            bootstrapIndex = clazz.getDeclaredField("bootstrap");
+            bootstrapIndex.setAccessible(true);
+            nameAndTypeIndex = clazz.getDeclaredField("nameAndType");
+            nameAndTypeIndex.setAccessible(true);
         } catch (Exception ex) {
             throw new Error(ex);
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
index bb9d16bc..0e0297be 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
@@ -14,35 +14,19 @@ import java.lang.reflect.Field;
 
 public class MemberRefInfoAccessor {
 
-    private static Class<?> m_class;
-    private static Field m_classIndex;
-    private static Field m_nameAndTypeIndex;
+    private static Class<?> clazz;
+    private static Field classIndex;
+    private static Field nameAndTypeIndex;
 
-    static {
-        try {
-            m_class = Class.forName("javassist.bytecode.MemberrefInfo");
-            m_classIndex = m_class.getDeclaredField("classIndex");
-            m_classIndex.setAccessible(true);
-            m_nameAndTypeIndex = m_class.getDeclaredField("nameAndTypeIndex");
-            m_nameAndTypeIndex.setAccessible(true);
-        } catch (Exception ex) {
-            throw new Error(ex);
-        }
-    }
-
-    public static boolean isType(ConstInfoAccessor accessor) {
-        return m_class.isAssignableFrom(accessor.getItem().getClass());
-    }
-
-    private Object m_item;
+    private Object item;
 
     public MemberRefInfoAccessor(Object item) {
-        m_item = item;
+        this.item = item;
     }
 
     public int getClassIndex() {
         try {
-            return (Integer) m_classIndex.get(m_item);
+            return (Integer) classIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -50,7 +34,7 @@ public class MemberRefInfoAccessor {
 
     public void setClassIndex(int val) {
         try {
-            m_classIndex.set(m_item, val);
+            classIndex.set(this.item, val);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -58,7 +42,7 @@ public class MemberRefInfoAccessor {
 
     public int getNameAndTypeIndex() {
         try {
-            return (Integer) m_nameAndTypeIndex.get(m_item);
+            return (Integer) nameAndTypeIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -66,7 +50,23 @@ public class MemberRefInfoAccessor {
 
     public void setNameAndTypeIndex(int val) {
         try {
-            m_nameAndTypeIndex.set(m_item, val);
+            nameAndTypeIndex.set(this.item, val);
+        } catch (Exception ex) {
+            throw new Error(ex);
+        }
+    }
+
+    public static boolean isType(ConstInfoAccessor accessor) {
+        return clazz.isAssignableFrom(accessor.getItem().getClass());
+    }
+
+    static {
+        try {
+            clazz = Class.forName("javassist.bytecode.MemberrefInfo");
+            classIndex = clazz.getDeclaredField("classIndex");
+            classIndex.setAccessible(true);
+            nameAndTypeIndex = clazz.getDeclaredField("nameAndTypeIndex");
+            nameAndTypeIndex.setAccessible(true);
         } catch (Exception ex) {
             throw new Error(ex);
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
index 88e42f46..9a7dd698 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
@@ -14,35 +14,19 @@ import java.lang.reflect.Field;
 
 public class MethodHandleInfoAccessor {
 
-    private static Class<?> m_class;
-    private static Field m_kindIndex;
-    private static Field m_indexIndex;
+    private static Class<?> clazz;
+    private static Field kindIndex;
+    private static Field indexIndex;
 
-    static {
-        try {
-            m_class = Class.forName("javassist.bytecode.MethodHandleInfo");
-            m_kindIndex = m_class.getDeclaredField("refKind");
-            m_kindIndex.setAccessible(true);
-            m_indexIndex = m_class.getDeclaredField("refIndex");
-            m_indexIndex.setAccessible(true);
-        } catch (Exception ex) {
-            throw new Error(ex);
-        }
-    }
-
-    public static boolean isType(ConstInfoAccessor accessor) {
-        return m_class.isAssignableFrom(accessor.getItem().getClass());
-    }
-
-    private Object m_item;
+    private Object item;
 
     public MethodHandleInfoAccessor(Object item) {
-        m_item = item;
+        this.item = item;
     }
 
     public int getTypeIndex() {
         try {
-            return (Integer) m_kindIndex.get(m_item);
+            return (Integer) kindIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -50,7 +34,7 @@ public class MethodHandleInfoAccessor {
 
     public void setTypeIndex(int val) {
         try {
-            m_kindIndex.set(m_item, val);
+            kindIndex.set(this.item, val);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -58,7 +42,7 @@ public class MethodHandleInfoAccessor {
 
     public int getMethodRefIndex() {
         try {
-            return (Integer) m_indexIndex.get(m_item);
+            return (Integer) indexIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -66,7 +50,23 @@ public class MethodHandleInfoAccessor {
 
     public void setMethodRefIndex(int val) {
         try {
-            m_indexIndex.set(m_item, val);
+            indexIndex.set(this.item, val);
+        } catch (Exception ex) {
+            throw new Error(ex);
+        }
+    }
+
+    public static boolean isType(ConstInfoAccessor accessor) {
+        return clazz.isAssignableFrom(accessor.getItem().getClass());
+    }
+
+    static {
+        try {
+            clazz = Class.forName("javassist.bytecode.MethodHandleInfo");
+            kindIndex = clazz.getDeclaredField("refKind");
+            kindIndex.setAccessible(true);
+            indexIndex = clazz.getDeclaredField("refIndex");
+            indexIndex.setAccessible(true);
         } catch (Exception ex) {
             throw new Error(ex);
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
index 1d039f6c..5ec9c3b4 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
@@ -14,32 +14,18 @@ import java.lang.reflect.Field;
 
 public class MethodTypeInfoAccessor {
 
-    private static Class<?> m_class;
-    private static Field m_descriptorIndex;
+    private static Class<?> clazz;
+    private static Field descriptorIndex;
 
-    static {
-        try {
-            m_class = Class.forName("javassist.bytecode.MethodTypeInfo");
-            m_descriptorIndex = m_class.getDeclaredField("descriptor");
-            m_descriptorIndex.setAccessible(true);
-        } catch (Exception ex) {
-            throw new Error(ex);
-        }
-    }
-
-    public static boolean isType(ConstInfoAccessor accessor) {
-        return m_class.isAssignableFrom(accessor.getItem().getClass());
-    }
-
-    private Object m_item;
+    private Object item;
 
     public MethodTypeInfoAccessor(Object item) {
-        m_item = item;
+        this.item = item;
     }
 
     public int getTypeIndex() {
         try {
-            return (Integer) m_descriptorIndex.get(m_item);
+            return (Integer) descriptorIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -47,9 +33,24 @@ public class MethodTypeInfoAccessor {
 
     public void setTypeIndex(int val) {
         try {
-            m_descriptorIndex.set(m_item, val);
+            descriptorIndex.set(this.item, val);
         } catch (Exception ex) {
             throw new Error(ex);
         }
     }
+
+    public static boolean isType(ConstInfoAccessor accessor) {
+        return clazz.isAssignableFrom(accessor.getItem().getClass());
+    }
+
+    static {
+        try {
+            clazz = Class.forName("javassist.bytecode.MethodTypeInfo");
+            descriptorIndex = clazz.getDeclaredField("descriptor");
+            descriptorIndex.setAccessible(true);
+        } catch (Exception ex) {
+            throw new Error(ex);
+        }
+    }
+
 }
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
index acba7799..95df37c1 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
@@ -14,35 +14,19 @@ import java.lang.reflect.Field;
 
 public class NameAndTypeInfoAccessor {
 
-    private static Class<?> m_class;
-    private static Field m_nameIndex;
-    private static Field m_typeIndex;
+    private static Class<?> clazz;
+    private static Field nameIndex;
+    private static Field typeIndex;
 
-    static {
-        try {
-            m_class = Class.forName("javassist.bytecode.NameAndTypeInfo");
-            m_nameIndex = m_class.getDeclaredField("memberName");
-            m_nameIndex.setAccessible(true);
-            m_typeIndex = m_class.getDeclaredField("typeDescriptor");
-            m_typeIndex.setAccessible(true);
-        } catch (Exception ex) {
-            throw new Error(ex);
-        }
-    }
-
-    public static boolean isType(ConstInfoAccessor accessor) {
-        return m_class.isAssignableFrom(accessor.getItem().getClass());
-    }
-
-    private Object m_item;
+    private Object item;
 
     public NameAndTypeInfoAccessor(Object item) {
-        m_item = item;
+        this.item = item;
     }
 
     public int getNameIndex() {
         try {
-            return (Integer) m_nameIndex.get(m_item);
+            return (Integer) nameIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -50,7 +34,7 @@ public class NameAndTypeInfoAccessor {
 
     public void setNameIndex(int val) {
         try {
-            m_nameIndex.set(m_item, val);
+            nameIndex.set(this.item, val);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -58,7 +42,7 @@ public class NameAndTypeInfoAccessor {
 
     public int getTypeIndex() {
         try {
-            return (Integer) m_typeIndex.get(m_item);
+            return (Integer) typeIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -66,7 +50,23 @@ public class NameAndTypeInfoAccessor {
 
     public void setTypeIndex(int val) {
         try {
-            m_typeIndex.set(m_item, val);
+            typeIndex.set(this.item, val);
+        } catch (Exception ex) {
+            throw new Error(ex);
+        }
+    }
+
+    public static boolean isType(ConstInfoAccessor accessor) {
+        return clazz.isAssignableFrom(accessor.getItem().getClass());
+    }
+
+    static {
+        try {
+            clazz = Class.forName("javassist.bytecode.NameAndTypeInfo");
+            nameIndex = clazz.getDeclaredField("memberName");
+            nameIndex.setAccessible(true);
+            typeIndex = clazz.getDeclaredField("typeDescriptor");
+            typeIndex.setAccessible(true);
         } catch (Exception ex) {
             throw new Error(ex);
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
index b40e0eb2..1c55a443 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
@@ -14,32 +14,18 @@ import java.lang.reflect.Field;
 
 public class StringInfoAccessor {
 
-    private static Class<?> m_class;
-    private static Field m_stringIndex;
+    private static Class<?> clazz;
+    private static Field stringIndex;
 
-    static {
-        try {
-            m_class = Class.forName("javassist.bytecode.StringInfo");
-            m_stringIndex = m_class.getDeclaredField("string");
-            m_stringIndex.setAccessible(true);
-        } catch (Exception ex) {
-            throw new Error(ex);
-        }
-    }
-
-    public static boolean isType(ConstInfoAccessor accessor) {
-        return m_class.isAssignableFrom(accessor.getItem().getClass());
-    }
-
-    private Object m_item;
+    private Object item;
 
     public StringInfoAccessor(Object item) {
-        m_item = item;
+        this.item = item;
     }
 
     public int getStringIndex() {
         try {
-            return (Integer) m_stringIndex.get(m_item);
+            return (Integer) stringIndex.get(this.item);
         } catch (Exception ex) {
             throw new Error(ex);
         }
@@ -47,7 +33,21 @@ public class StringInfoAccessor {
 
     public void setStringIndex(int val) {
         try {
-            m_stringIndex.set(m_item, val);
+            stringIndex.set(this.item, val);
+        } catch (Exception ex) {
+            throw new Error(ex);
+        }
+    }
+
+    public static boolean isType(ConstInfoAccessor accessor) {
+        return clazz.isAssignableFrom(accessor.getItem().getClass());
+    }
+
+    static {
+        try {
+            clazz = Class.forName("javassist.bytecode.StringInfo");
+            stringIndex = clazz.getDeclaredField("string");
+            stringIndex.setAccessible(true);
         } catch (Exception ex) {
             throw new Error(ex);
         }
diff --git a/src/main/java/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java b/src/main/java/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
index 9303b41a..7a2cb667 100644
--- a/src/main/java/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
@@ -12,17 +12,17 @@ package cuchaz.enigma.bytecode.accessors;
 
 public class Utf8InfoAccessor {
 
-    private static Class<?> m_class;
+    private static Class<?> clazz;
 
     static {
         try {
-            m_class = Class.forName("javassist.bytecode.Utf8Info");
+            clazz = Class.forName("javassist.bytecode.Utf8Info");
         } catch (Exception ex) {
             throw new Error(ex);
         }
     }
 
     public static boolean isType(ConstInfoAccessor accessor) {
-        return m_class.isAssignableFrom(accessor.getItem().getClass());
+        return clazz.isAssignableFrom(accessor.getItem().getClass());
     }
 }
diff --git a/src/main/java/cuchaz/enigma/convert/ClassForest.java b/src/main/java/cuchaz/enigma/convert/ClassForest.java
index 7123bbfb..b08d48fb 100644
--- a/src/main/java/cuchaz/enigma/convert/ClassForest.java
+++ b/src/main/java/cuchaz/enigma/convert/ClassForest.java
@@ -20,12 +20,12 @@ import cuchaz.enigma.mapping.ClassEntry;
 
 public class ClassForest {
 
-    private ClassIdentifier m_identifier;
-    private Multimap<ClassIdentity, ClassEntry> m_forest;
+    private ClassIdentifier identifier;
+    private Multimap<ClassIdentity, ClassEntry> forest;
 
     public ClassForest(ClassIdentifier identifier) {
-        m_identifier = identifier;
-        m_forest = HashMultimap.create();
+        this.identifier = identifier;
+        this.forest = HashMultimap.create();
     }
 
     public void addAll(Iterable<ClassEntry> entries) {
@@ -36,25 +36,25 @@ public class ClassForest {
 
     public void add(ClassEntry entry) {
         try {
-            m_forest.put(m_identifier.identify(entry), entry);
+            this.forest.put(this.identifier.identify(entry), entry);
         } catch (ClassNotFoundException ex) {
             throw new Error("Unable to find class " + entry.getName());
         }
     }
 
     public Collection<ClassIdentity> identities() {
-        return m_forest.keySet();
+        return this.forest.keySet();
     }
 
     public Collection<ClassEntry> classes() {
-        return m_forest.values();
+        return this.forest.values();
     }
 
     public Collection<ClassEntry> getClasses(ClassIdentity identity) {
-        return m_forest.get(identity);
+        return this.forest.get(identity);
     }
 
     public boolean containsIdentity(ClassIdentity identity) {
-        return m_forest.containsKey(identity);
+        return this.forest.containsKey(identity);
     }
 }
diff --git a/src/main/java/cuchaz/enigma/convert/ClassIdentifier.java b/src/main/java/cuchaz/enigma/convert/ClassIdentifier.java
index e1153a6d..cc7f25b8 100644
--- a/src/main/java/cuchaz/enigma/convert/ClassIdentifier.java
+++ b/src/main/java/cuchaz/enigma/convert/ClassIdentifier.java
@@ -24,30 +24,30 @@ import javassist.CtClass;
 
 public class ClassIdentifier {
 
-    private JarIndex m_index;
-    private SidedClassNamer m_namer;
-    private boolean m_useReferences;
-    private TranslatingTypeLoader m_loader;
-    private Map<ClassEntry, ClassIdentity> m_cache;
+    private JarIndex index;
+    private SidedClassNamer namer;
+    private boolean useReferences;
+    private TranslatingTypeLoader loader;
+    private Map<ClassEntry, ClassIdentity> cache;
 
     public ClassIdentifier(JarFile jar, JarIndex index, SidedClassNamer namer, boolean useReferences) {
-        m_index = index;
-        m_namer = namer;
-        m_useReferences = useReferences;
-        m_loader = new TranslatingTypeLoader(jar, index);
-        m_cache = Maps.newHashMap();
+        this.index = index;
+        this.namer = namer;
+        this.useReferences = useReferences;
+        this.loader = new TranslatingTypeLoader(jar, index);
+        this.cache = Maps.newHashMap();
     }
 
     public ClassIdentity identify(ClassEntry classEntry)
             throws ClassNotFoundException {
-        ClassIdentity identity = m_cache.get(classEntry);
+        ClassIdentity identity = this.cache.get(classEntry);
         if (identity == null) {
-            CtClass c = m_loader.loadClass(classEntry.getName());
+            CtClass c = this.loader.loadClass(classEntry.getName());
             if (c == null) {
                 throw new ClassNotFoundException(classEntry.getName());
             }
-            identity = new ClassIdentity(c, m_namer, m_index, m_useReferences);
-            m_cache.put(classEntry, identity);
+            identity = new ClassIdentity(c, this.namer, this.index, this.useReferences);
+            this.cache.put(classEntry, identity);
         }
         return identity;
     }
diff --git a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java
index 76c48ab6..2317a3d9 100644
--- a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java
+++ b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java
@@ -36,18 +36,18 @@ import javassist.expr.*;
 
 public class ClassIdentity {
 
-    private ClassEntry m_classEntry;
-    private SidedClassNamer m_namer;
-    private Multiset<String> m_fields;
-    private Multiset<String> m_methods;
-    private Multiset<String> m_constructors;
-    private String m_staticInitializer;
-    private String m_extends;
-    private Multiset<String> m_implements;
-    private Set<String> m_stringLiterals;
-    private Multiset<String> m_implementations;
-    private Multiset<String> m_references;
-    private String m_outer;
+    private ClassEntry classEntry;
+    private SidedClassNamer namer;
+    private Multiset<String> fields;
+    private Multiset<String> methods;
+    private Multiset<String> constructors;
+    private String staticInitializer;
+    private String extendz;
+    private Multiset<String> implementz;
+    private Set<String> stringLiterals;
+    private Multiset<String> implementations;
+    private Multiset<String> references;
+    private String outer;
 
     private final ClassNameReplacer m_classNameReplacer = new ClassNameReplacer() {
 
@@ -63,13 +63,13 @@ public class ClassIdentity {
             }
 
             // is this class ourself?
-            if (className.equals(m_classEntry.getName())) {
+            if (className.equals(classEntry.getName())) {
                 return "CSelf";
             }
 
             // try the namer
-            if (m_namer != null) {
-                String newName = m_namer.getName(className);
+            if (namer != null) {
+                String newName = namer.getName(className);
                 if (newName != null) {
                     return newName;
                 }
@@ -88,58 +88,58 @@ public class ClassIdentity {
     };
 
     public ClassIdentity(CtClass c, SidedClassNamer namer, JarIndex index, boolean useReferences) {
-        m_namer = namer;
+        this.namer = namer;
 
         // stuff from the bytecode
 
-        m_classEntry = EntryFactory.getClassEntry(c);
-        m_fields = HashMultiset.create();
+        this.classEntry = EntryFactory.getClassEntry(c);
+        this.fields = HashMultiset.create();
         for (CtField field : c.getDeclaredFields()) {
-            m_fields.add(scrubType(field.getSignature()));
+            this.fields.add(scrubType(field.getSignature()));
         }
-        m_methods = HashMultiset.create();
+        this.methods = HashMultiset.create();
         for (CtMethod method : c.getDeclaredMethods()) {
-            m_methods.add(scrubSignature(method.getSignature()) + "0x" + getBehaviorSignature(method));
+            this.methods.add(scrubSignature(method.getSignature()) + "0x" + getBehaviorSignature(method));
         }
-        m_constructors = HashMultiset.create();
+        this.constructors = HashMultiset.create();
         for (CtConstructor constructor : c.getDeclaredConstructors()) {
-            m_constructors.add(scrubSignature(constructor.getSignature()) + "0x" + getBehaviorSignature(constructor));
+            this.constructors.add(scrubSignature(constructor.getSignature()) + "0x" + getBehaviorSignature(constructor));
         }
-        m_staticInitializer = "";
+        this.staticInitializer = "";
         if (c.getClassInitializer() != null) {
-            m_staticInitializer = getBehaviorSignature(c.getClassInitializer());
+            this.staticInitializer = getBehaviorSignature(c.getClassInitializer());
         }
-        m_extends = "";
+        this.extendz = "";
         if (c.getClassFile().getSuperclass() != null) {
-            m_extends = scrubClassName(Descriptor.toJvmName(c.getClassFile().getSuperclass()));
+            this.extendz = scrubClassName(Descriptor.toJvmName(c.getClassFile().getSuperclass()));
         }
-        m_implements = HashMultiset.create();
+        this.implementz = HashMultiset.create();
         for (String interfaceName : c.getClassFile().getInterfaces()) {
-            m_implements.add(scrubClassName(Descriptor.toJvmName(interfaceName)));
+            this.implementz.add(scrubClassName(Descriptor.toJvmName(interfaceName)));
         }
 
-        m_stringLiterals = Sets.newHashSet();
+        this.stringLiterals = Sets.newHashSet();
         ConstPool constants = c.getClassFile().getConstPool();
         for (int i = 1; i < constants.getSize(); i++) {
             if (constants.getTag(i) == ConstPool.CONST_String) {
-                m_stringLiterals.add(constants.getStringInfo(i));
+                this.stringLiterals.add(constants.getStringInfo(i));
             }
         }
 
         // stuff from the jar index
 
-        m_implementations = HashMultiset.create();
-        ClassImplementationsTreeNode implementationsNode = index.getClassImplementations(null, m_classEntry);
+        this.implementations = HashMultiset.create();
+        ClassImplementationsTreeNode implementationsNode = index.getClassImplementations(null, this.classEntry);
         if (implementationsNode != null) {
             @SuppressWarnings("unchecked")
             Enumeration<ClassImplementationsTreeNode> implementations = implementationsNode.children();
             while (implementations.hasMoreElements()) {
                 ClassImplementationsTreeNode node = implementations.nextElement();
-                m_implementations.add(scrubClassName(node.getClassEntry().getName()));
+                this.implementations.add(scrubClassName(node.getClassEntry().getName()));
             }
         }
 
-        m_references = HashMultiset.create();
+        this.references = HashMultiset.create();
         if (useReferences) {
             for (CtField field : c.getDeclaredFields()) {
                 FieldEntry fieldEntry = EntryFactory.getFieldEntry(field);
@@ -151,79 +151,79 @@ public class ClassIdentity {
             }
         }
 
-        m_outer = null;
-        if (m_classEntry.isInnerClass()) {
-            m_outer = m_classEntry.getOuterClassName();
+        this.outer = null;
+        if (this.classEntry.isInnerClass()) {
+            this.outer = this.classEntry.getOuterClassName();
         }
     }
 
     private void addReference(EntryReference<? extends Entry, BehaviorEntry> reference) {
         if (reference.context.getSignature() != null) {
-            m_references.add(String.format("%s_%s",
+            this.references.add(String.format("%s_%s",
                     scrubClassName(reference.context.getClassName()),
                     scrubSignature(reference.context.getSignature())
             ));
         } else {
-            m_references.add(String.format("%s_<clinit>",
+            this.references.add(String.format("%s_<clinit>",
                     scrubClassName(reference.context.getClassName())
             ));
         }
     }
 
     public ClassEntry getClassEntry() {
-        return m_classEntry;
+        return this.classEntry;
     }
 
     @Override
     public String toString() {
         StringBuilder buf = new StringBuilder();
         buf.append("class: ");
-        buf.append(m_classEntry.getName());
+        buf.append(this.classEntry.getName());
         buf.append(" ");
         buf.append(hashCode());
         buf.append("\n");
-        for (String field : m_fields) {
+        for (String field : this.fields) {
             buf.append("\tfield ");
             buf.append(field);
             buf.append("\n");
         }
-        for (String method : m_methods) {
+        for (String method : this.methods) {
             buf.append("\tmethod ");
             buf.append(method);
             buf.append("\n");
         }
-        for (String constructor : m_constructors) {
+        for (String constructor : this.constructors) {
             buf.append("\tconstructor ");
             buf.append(constructor);
             buf.append("\n");
         }
-        if (m_staticInitializer.length() > 0) {
+        if (this.staticInitializer.length() > 0) {
             buf.append("\tinitializer ");
-            buf.append(m_staticInitializer);
+            buf.append(this.staticInitializer);
             buf.append("\n");
         }
-        if (m_extends.length() > 0) {
+        if (this.extendz.length() > 0) {
             buf.append("\textends ");
-            buf.append(m_extends);
+            buf.append(this.extendz);
             buf.append("\n");
         }
-        for (String interfaceName : m_implements) {
+        for (String interfaceName : this.implementz) {
             buf.append("\timplements ");
             buf.append(interfaceName);
             buf.append("\n");
         }
-        for (String implementation : m_implementations) {
+        for (String implementation : this.implementations) {
             buf.append("\timplemented by ");
             buf.append(implementation);
             buf.append("\n");
         }
-        for (String reference : m_references) {
+        for (String reference : this.references) {
             buf.append("\treference ");
             buf.append(reference);
             buf.append("\n");
         }
         buf.append("\touter ");
-        buf.append(m_outer);
+        buf.append(this.outer);
         buf.append("\n");
         return buf.toString();
     }
@@ -253,7 +253,7 @@ public class ClassIdentity {
     }
 
     private boolean isClassMatchedUniquely(String className) {
-        return m_namer != null && m_namer.getName(Descriptor.toJvmName(className)) != null;
+        return this.namer != null && this.namer.getName(Descriptor.toJvmName(className)) != null;
     }
 
     private String getBehaviorSignature(CtBehavior behavior) {
@@ -361,56 +361,53 @@ public class ClassIdentity {
 
     @Override
     public boolean equals(Object other) {
-        if (other instanceof ClassIdentity) {
-            return equals((ClassIdentity) other);
-        }
-        return false;
+        return other instanceof ClassIdentity && equals((ClassIdentity) other);
     }
 
     public boolean equals(ClassIdentity other) {
-        return m_fields.equals(other.m_fields)
-                && m_methods.equals(other.m_methods)
-                && m_constructors.equals(other.m_constructors)
-                && m_staticInitializer.equals(other.m_staticInitializer)
-                && m_extends.equals(other.m_extends)
-                && m_implements.equals(other.m_implements)
-                && m_implementations.equals(other.m_implementations)
-                && m_references.equals(other.m_references);
+        return this.fields.equals(other.fields)
+                && this.methods.equals(other.methods)
+                && this.constructors.equals(other.constructors)
+                && this.staticInitializer.equals(other.staticInitializer)
+                && this.extendz.equals(other.extendz)
+                && this.implementz.equals(other.implementz)
+                && this.implementations.equals(other.implementations)
+                && this.references.equals(other.references);
     }
 
     @Override
     public int hashCode() {
         List<Object> objs = Lists.newArrayList();
-        objs.addAll(m_fields);
-        objs.addAll(m_methods);
-        objs.addAll(m_constructors);
-        objs.add(m_staticInitializer);
-        objs.add(m_extends);
-        objs.addAll(m_implements);
-        objs.addAll(m_implementations);
-        objs.addAll(m_references);
+        objs.addAll(this.fields);
+        objs.addAll(this.methods);
+        objs.addAll(this.constructors);
+        objs.add(this.staticInitializer);
+        objs.add(this.extendz);
+        objs.addAll(this.implementz);
+        objs.addAll(this.implementations);
+        objs.addAll(this.references);
         return Util.combineHashesOrdered(objs);
     }
 
     public int getMatchScore(ClassIdentity other) {
-        return 2 * getNumMatches(m_extends, other.m_extends)
-                + 2 * getNumMatches(m_outer, other.m_outer)
-                + 2 * getNumMatches(m_implements, other.m_implements)
-                + getNumMatches(m_stringLiterals, other.m_stringLiterals)
-                + getNumMatches(m_fields, other.m_fields)
-                + getNumMatches(m_methods, other.m_methods)
-                + getNumMatches(m_constructors, other.m_constructors);
+        return 2 * getNumMatches(this.extendz, other.extendz)
+                + 2 * getNumMatches(this.outer, other.outer)
+                + 2 * getNumMatches(this.implementz, other.implementz)
+                + getNumMatches(this.stringLiterals, other.stringLiterals)
+                + getNumMatches(this.fields, other.fields)
+                + getNumMatches(this.methods, other.methods)
+                + getNumMatches(this.constructors, other.constructors);
     }
 
     public int getMaxMatchScore() {
-        return 2 + 2 + 2 * m_implements.size() + m_stringLiterals.size() + m_fields.size() + m_methods.size() + m_constructors.size();
+        return 2 + 2 + 2 * this.implementz.size() + this.stringLiterals.size() + this.fields.size() + this.methods.size() + this.constructors.size();
     }
 
     public boolean matches(CtClass c) {
         // just compare declaration counts
-        return m_fields.size() == c.getDeclaredFields().length
-                && m_methods.size() == c.getDeclaredMethods().length
-                && m_constructors.size() == c.getDeclaredConstructors().length;
+        return this.fields.size() == c.getDeclaredFields().length
+                && this.methods.size() == c.getDeclaredMethods().length
+                && this.constructors.size() == c.getDeclaredConstructors().length;
     }
 
     private int getNumMatches(Set<String> a, Set<String> b) {
diff --git a/src/main/java/cuchaz/enigma/convert/ClassMatch.java b/src/main/java/cuchaz/enigma/convert/ClassMatch.java
index f3530ed4..422529ec 100644
--- a/src/main/java/cuchaz/enigma/convert/ClassMatch.java
+++ b/src/main/java/cuchaz/enigma/convert/ClassMatch.java
@@ -75,14 +75,10 @@ public class ClassMatch {
 
     @Override
     public boolean equals(Object other) {
-        if (other instanceof ClassMatch) {
-            return equals((ClassMatch) other);
-        }
-        return false;
+        return other instanceof ClassMatch && equals((ClassMatch) other);
     }
 
     public boolean equals(ClassMatch other) {
-        return this.sourceClasses.equals(other.sourceClasses)
-                && this.destClasses.equals(other.destClasses);
+        return this.sourceClasses.equals(other.sourceClasses) && this.destClasses.equals(other.destClasses);
     }
 }
diff --git a/src/main/java/cuchaz/enigma/convert/ClassMatches.java b/src/main/java/cuchaz/enigma/convert/ClassMatches.java
index 2c5f6a57..3a254357 100644
--- a/src/main/java/cuchaz/enigma/convert/ClassMatches.java
+++ b/src/main/java/cuchaz/enigma/convert/ClassMatches.java
@@ -32,7 +32,7 @@ public class ClassMatches implements Iterable<ClassMatch> {
     Set<ClassEntry> m_unmatchedDestClasses;
 
     public ClassMatches() {
-        this(new ArrayList<ClassMatch>());
+        this(new ArrayList<>());
     }
 
     public ClassMatches(Collection<ClassMatch> matches) {
diff --git a/src/main/java/cuchaz/enigma/convert/ClassMatching.java b/src/main/java/cuchaz/enigma/convert/ClassMatching.java
index 14f8e2a3..9350ea7f 100644
--- a/src/main/java/cuchaz/enigma/convert/ClassMatching.java
+++ b/src/main/java/cuchaz/enigma/convert/ClassMatching.java
@@ -69,7 +69,7 @@ public class ClassMatching {
         for (ClassIdentity identity : m_destClasses.identities()) {
             if (!m_sourceClasses.containsIdentity(identity)) {
                 matches.add(new ClassMatch(
-                        new ArrayList<ClassEntry>(),
+                        new ArrayList<>(),
                         m_destClasses.getClasses(identity)
                 ));
             }
diff --git a/src/main/java/cuchaz/enigma/convert/ClassNamer.java b/src/main/java/cuchaz/enigma/convert/ClassNamer.java
index f1d98200..e471c7dd 100644
--- a/src/main/java/cuchaz/enigma/convert/ClassNamer.java
+++ b/src/main/java/cuchaz/enigma/convert/ClassNamer.java
@@ -23,27 +23,27 @@ public class ClassNamer {
         String getName(String name);
     }
 
-    private Map<String, String> m_sourceNames;
-    private Map<String, String> m_destNames;
+    private Map<String, String> sourceNames;
+    private Map<String, String> destNames;
 
     public ClassNamer(BiMap<ClassEntry, ClassEntry> mappings) {
         // convert the identity mappings to name maps
-        m_sourceNames = Maps.newHashMap();
-        m_destNames = Maps.newHashMap();
+        this.sourceNames = Maps.newHashMap();
+        this.destNames = Maps.newHashMap();
         int i = 0;
         for (Map.Entry<ClassEntry, ClassEntry> entry : mappings.entrySet()) {
             String name = String.format("M%04d", i++);
-            m_sourceNames.put(entry.getKey().getName(), name);
-            m_destNames.put(entry.getValue().getName(), name);
+            this.sourceNames.put(entry.getKey().getName(), name);
+            this.destNames.put(entry.getValue().getName(), name);
         }
     }
 
     public String getSourceName(String name) {
-        return m_sourceNames.get(name);
+        return this.sourceNames.get(name);
     }
 
     public String getDestName(String name) {
-        return m_destNames.get(name);
+        return this.destNames.get(name);
     }
 
     public SidedClassNamer getSourceNamer() {
diff --git a/src/main/java/cuchaz/enigma/gui/GuiController.java b/src/main/java/cuchaz/enigma/gui/GuiController.java
index aa6acdc5..a6a2ec52 100644
--- a/src/main/java/cuchaz/enigma/gui/GuiController.java
+++ b/src/main/java/cuchaz/enigma/gui/GuiController.java
@@ -17,7 +17,6 @@ import com.strobel.decompiler.languages.java.ast.CompilationUnit;
 
 import java.io.File;
 import java.io.FileReader;
-import java.io.FileWriter;
 import java.io.IOException;
 import java.util.Collection;
 import java.util.Deque;
diff --git a/src/main/java/cuchaz/enigma/json/JsonConstructor.java b/src/main/java/cuchaz/enigma/json/JsonConstructor.java
index cfac372a..8cbecf7b 100644
--- a/src/main/java/cuchaz/enigma/json/JsonConstructor.java
+++ b/src/main/java/cuchaz/enigma/json/JsonConstructor.java
@@ -8,7 +8,7 @@ public class JsonConstructor {
     private boolean statics;
 
     public JsonConstructor(String signature, List<JsonArgument> args, boolean statics) {
-        this.signature=signature;
+        this.signature = signature;
         this.args = args;
         this.statics = statics;
     }
diff --git a/src/main/java/cuchaz/enigma/json/JsonField.java b/src/main/java/cuchaz/enigma/json/JsonField.java
index 195f2874..c55a5e93 100644
--- a/src/main/java/cuchaz/enigma/json/JsonField.java
+++ b/src/main/java/cuchaz/enigma/json/JsonField.java
@@ -8,18 +8,18 @@ public class JsonField {
     public JsonField(String obf, String name, String type) {
         this.obf = obf;
         this.name = name;
-        this.type=type;
+        this.type = type;
     }
 
     public String getObf() {
-        return obf;
+        return this.obf;
     }
 
     public String getName() {
-        return name;
+        return this.name;
     }
 
     public String getType() {
-        return type;
+        return this.type;
     }
 }
diff --git a/src/main/java/cuchaz/enigma/mapping/ClassEntry.java b/src/main/java/cuchaz/enigma/mapping/ClassEntry.java
index 2e7711b7..c9304d45 100644
--- a/src/main/java/cuchaz/enigma/mapping/ClassEntry.java
+++ b/src/main/java/cuchaz/enigma/mapping/ClassEntry.java
@@ -67,10 +67,7 @@ public class ClassEntry implements Entry, Serializable {
 
     @Override
     public boolean equals(Object other) {
-        if (other instanceof ClassEntry) {
-            return equals((ClassEntry) other);
-        }
-        return false;
+        return other instanceof ClassEntry && equals((ClassEntry) other);
     }
 
     public boolean equals(ClassEntry other) {
diff --git a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
index 9258ec78..84fb6dd8 100644
--- a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
@@ -403,7 +403,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping> {
     public boolean renameObfClass(String oldObfClassName, String newObfClassName) {
 
         // rename inner classes
-        for (ClassMapping innerClassMapping : new ArrayList<ClassMapping>(m_innerClassesByObfSimple.values())) {
+        for (ClassMapping innerClassMapping : new ArrayList<>(m_innerClassesByObfSimple.values())) {
             if (innerClassMapping.renameObfClass(oldObfClassName, newObfClassName)) {
                 boolean wasRemoved = m_innerClassesByObfSimple.remove(oldObfClassName) != null;
                 assert (wasRemoved);
@@ -413,7 +413,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping> {
         }
 
         // rename field types
-        for (FieldMapping fieldMapping : new ArrayList<FieldMapping>(m_fieldsByObf.values())) {
+        for (FieldMapping fieldMapping : new ArrayList<>(m_fieldsByObf.values())) {
             String oldFieldKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType());
             if (fieldMapping.renameObfClass(oldObfClassName, newObfClassName)) {
                 boolean wasRemoved = m_fieldsByObf.remove(oldFieldKey) != null;
@@ -424,7 +424,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping> {
         }
 
         // rename method signatures
-        for (MethodMapping methodMapping : new ArrayList<MethodMapping>(m_methodsByObf.values())) {
+        for (MethodMapping methodMapping : new ArrayList<>(m_methodsByObf.values())) {
             String oldMethodKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature());
             if (methodMapping.renameObfClass(oldObfClassName, newObfClassName)) {
                 boolean wasRemoved = m_methodsByObf.remove(oldMethodKey) != null;
diff --git a/src/main/java/cuchaz/enigma/mapping/FieldEntry.java b/src/main/java/cuchaz/enigma/mapping/FieldEntry.java
index 3de72239..bebc5045 100644
--- a/src/main/java/cuchaz/enigma/mapping/FieldEntry.java
+++ b/src/main/java/cuchaz/enigma/mapping/FieldEntry.java
@@ -80,10 +80,7 @@ public class FieldEntry implements Entry, Serializable {
 
     @Override
     public boolean equals(Object other) {
-        if (other instanceof FieldEntry) {
-            return equals((FieldEntry) other);
-        }
-        return false;
+        return other instanceof FieldEntry && equals((FieldEntry) other);
     }
 
     public boolean equals(FieldEntry other) {
diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsChecker.java b/src/main/java/cuchaz/enigma/mapping/MappingsChecker.java
index ab686827..5e2b40b2 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsChecker.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsChecker.java
@@ -90,8 +90,6 @@ public class MappingsChecker {
                 classMapping.removeMethodMapping(methodMapping);
                 m_droppedMethodMappings.put(obfBehaviorEntry, methodMapping);
             }
-
-            m_relatedMethodChecker.checkMethod(classEntry, methodMapping);
         }
 
         // check inner classes
diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsReader.java b/src/main/java/cuchaz/enigma/mapping/MappingsReader.java
index 7110d40c..b2c3a5c0 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsReader.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsReader.java
@@ -42,14 +42,14 @@ public class MappingsReader {
 
     public void readFile(Mappings mappings, BufferedReader in) throws IOException, MappingParseException {
 
-        String builder = "";
+        StringBuffer buf = new StringBuffer();
         String line = null;
         while ((line = in.readLine()) != null) {
-            builder += line;
+            buf.append(line);
         }
 
         Gson gson = new GsonBuilder().setPrettyPrinting().create();
-        JsonClass jsonClass = gson.fromJson(builder, JsonClass.class);
+        JsonClass jsonClass = gson.fromJson(buf.toString(), JsonClass.class);
         load(null, jsonClass, mappings);
     }
 
diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsWriter.java b/src/main/java/cuchaz/enigma/mapping/MappingsWriter.java
index 89fee4e8..aaab22fa 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsWriter.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsWriter.java
@@ -24,7 +24,6 @@ import cuchaz.enigma.json.*;
 
 public class MappingsWriter {
 
-
     public void write(File file, Mappings mappings) throws IOException {
         if (!file.isDirectory()) {
             return;
diff --git a/src/main/java/cuchaz/enigma/mapping/MethodEntry.java b/src/main/java/cuchaz/enigma/mapping/MethodEntry.java
index 301da615..01a5c43d 100644
--- a/src/main/java/cuchaz/enigma/mapping/MethodEntry.java
+++ b/src/main/java/cuchaz/enigma/mapping/MethodEntry.java
@@ -85,10 +85,7 @@ public class MethodEntry implements BehaviorEntry, Serializable {
 
     @Override
     public boolean equals(Object other) {
-        if (other instanceof MethodEntry) {
-            return equals((MethodEntry) other);
-        }
-        return false;
+        return other instanceof MethodEntry && equals((MethodEntry) other);
     }
 
     public boolean equals(MethodEntry other) {
diff --git a/src/main/java/cuchaz/enigma/mapping/MethodMapping.java b/src/main/java/cuchaz/enigma/mapping/MethodMapping.java
index d1beddde..ff14ccd3 100644
--- a/src/main/java/cuchaz/enigma/mapping/MethodMapping.java
+++ b/src/main/java/cuchaz/enigma/mapping/MethodMapping.java
@@ -36,62 +36,62 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>, M
         if (obfSignature == null) {
             throw new IllegalArgumentException("obf signature cannot be null!");
         }
-        m_obfName = obfName;
-        m_deobfName = NameValidator.validateMethodName(deobfName);
-        m_obfSignature = obfSignature;
-        m_arguments = Maps.newTreeMap();
+        this.m_obfName = obfName;
+        this.m_deobfName = NameValidator.validateMethodName(deobfName);
+        this.m_obfSignature = obfSignature;
+        this.m_arguments = Maps.newTreeMap();
     }
 
     public MethodMapping(MethodMapping other, ClassNameReplacer obfClassNameReplacer) {
-        m_obfName = other.m_obfName;
-        m_deobfName = other.m_deobfName;
-        m_obfSignature = new Signature(other.m_obfSignature, obfClassNameReplacer);
-        m_arguments = Maps.newTreeMap();
+        this.m_obfName = other.m_obfName;
+        this.m_deobfName = other.m_deobfName;
+        this.m_obfSignature = new Signature(other.m_obfSignature, obfClassNameReplacer);
+        this.m_arguments = Maps.newTreeMap();
         for (Entry<Integer, ArgumentMapping> entry : other.m_arguments.entrySet()) {
-            m_arguments.put(entry.getKey(), new ArgumentMapping(entry.getValue()));
+            this.m_arguments.put(entry.getKey(), new ArgumentMapping(entry.getValue()));
         }
     }
 
     @Override
     public String getObfName() {
-        return m_obfName;
+        return this.m_obfName;
     }
 
     public void setObfName(String val) {
-        m_obfName = NameValidator.validateMethodName(val);
+        this.m_obfName = NameValidator.validateMethodName(val);
     }
 
     public String getDeobfName() {
-        return m_deobfName;
+        return this.m_deobfName;
     }
 
     public void setDeobfName(String val) {
-        m_deobfName = NameValidator.validateMethodName(val);
+        this.m_deobfName = NameValidator.validateMethodName(val);
     }
 
     public Signature getObfSignature() {
-        return m_obfSignature;
+        return this.m_obfSignature;
     }
 
     public void setObfSignature(Signature val) {
-        m_obfSignature = val;
+        this.m_obfSignature = val;
     }
 
     public Iterable<ArgumentMapping> arguments() {
-        return m_arguments.values();
+        return this.m_arguments.values();
     }
 
     public boolean isConstructor() {
-        return m_obfName.startsWith("<");
+        return this.m_obfName.startsWith("<");
     }
 
     public void addArgumentMapping(ArgumentMapping argumentMapping) {
-        boolean wasAdded = m_arguments.put(argumentMapping.getIndex(), argumentMapping) == null;
+        boolean wasAdded = this.m_arguments.put(argumentMapping.getIndex(), argumentMapping) == null;
         assert (wasAdded);
     }
 
     public String getObfArgumentName(int index) {
-        ArgumentMapping argumentMapping = m_arguments.get(index);
+        ArgumentMapping argumentMapping = this.m_arguments.get(index);
         if (argumentMapping != null) {
             return argumentMapping.getName();
         }
@@ -100,7 +100,7 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>, M
     }
 
     public String getDeobfArgumentName(int index) {
-        ArgumentMapping argumentMapping = m_arguments.get(index);
+        ArgumentMapping argumentMapping = this.m_arguments.get(index);
         if (argumentMapping != null) {
             return argumentMapping.getName();
         }
@@ -109,10 +109,10 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>, M
     }
 
     public void setArgumentName(int index, String name) {
-        ArgumentMapping argumentMapping = m_arguments.get(index);
+        ArgumentMapping argumentMapping = this.m_arguments.get(index);
         if (argumentMapping == null) {
             argumentMapping = new ArgumentMapping(index, name);
-            boolean wasAdded = m_arguments.put(index, argumentMapping) == null;
+            boolean wasAdded = this.m_arguments.put(index, argumentMapping) == null;
             assert (wasAdded);
         } else {
             argumentMapping.setName(name);
@@ -120,7 +120,7 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>, M
     }
 
     public void removeArgumentName(int index) {
-        boolean wasRemoved = m_arguments.remove(index) != null;
+        boolean wasRemoved = this.m_arguments.remove(index) != null;
         assert (wasRemoved);
     }
 
@@ -136,7 +136,7 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>, M
         buf.append(m_obfSignature);
         buf.append("\n");
         buf.append("\tArguments:\n");
-        for (ArgumentMapping argumentMapping : m_arguments.values()) {
+        for (ArgumentMapping argumentMapping : this.m_arguments.values()) {
             buf.append("\t\t");
             buf.append(argumentMapping.getIndex());
             buf.append(" -> ");
@@ -148,31 +148,28 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>, M
 
     @Override
     public int compareTo(MethodMapping other) {
-        return (m_obfName + m_obfSignature).compareTo(other.m_obfName + other.m_obfSignature);
+        return (this.m_obfName + this.m_obfSignature).compareTo(other.m_obfName + other.m_obfSignature);
     }
 
     public boolean renameObfClass(final String oldObfClassName, final String newObfClassName) {
 
         // rename obf classes in the signature
-        Signature newSignature = new Signature(m_obfSignature, new ClassNameReplacer() {
-            @Override
-            public String replace(String className) {
-                if (className.equals(oldObfClassName)) {
-                    return newObfClassName;
-                }
-                return null;
+        Signature newSignature = new Signature(this.m_obfSignature, className -> {
+            if (className.equals(oldObfClassName)) {
+                return newObfClassName;
             }
+            return null;
         });
 
-        if (!newSignature.equals(m_obfSignature)) {
-            m_obfSignature = newSignature;
+        if (!newSignature.equals(this.m_obfSignature)) {
+            this.m_obfSignature = newSignature;
             return true;
         }
         return false;
     }
 
     public boolean containsArgument(String name) {
-        for (ArgumentMapping argumentMapping : m_arguments.values()) {
+        for (ArgumentMapping argumentMapping : this.m_arguments.values()) {
             if (argumentMapping.getName().equals(name)) {
                 return true;
             }
@@ -183,9 +180,9 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>, M
     @Override
     public BehaviorEntry getObfEntry(ClassEntry classEntry) {
         if (isConstructor()) {
-            return new ConstructorEntry(classEntry, m_obfSignature);
+            return new ConstructorEntry(classEntry, this.m_obfSignature);
         } else {
-            return new MethodEntry(classEntry, m_obfName, m_obfSignature);
+            return new MethodEntry(classEntry, this.m_obfName, this.m_obfSignature);
         }
     }
 }