switch all classes to new signature/type system

132 files changed, 15543 insertions, 0 deletions

diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..16e0b31
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+        <classpathentry kind="src" path="src"/>
+        <classpathentry kind="src" path="conf"/>
+        <classpathentry kind="src" path="test"/>
+        <classpathentry exported="true" kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+        <classpathentry combineaccessrules="false" kind="src" path="/procyon"/>
+        <classpathentry kind="lib" path="lib/deps.jar"/>
+        <classpathentry kind="lib" path="lib/test-deps.jar"/>
+        <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/.hgignore b/.hgignore
new file mode 100644
index 0000000..659df81
--- /dev/null
+++ b/.hgignore
@@ -0,0 +1,9 @@
+
+syntax: glob
+bin
+lib
+build
+data
+input
+ivy
+*.pyc
\ No newline at end of file
diff --git a/.project b/.project
new file mode 100644
index 0000000..08dff6c
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+        <name>Enigma</name>
+        <comment></comment>
+        <projects>
+        </projects>
+        <buildSpec>
+                <buildCommand>
+                        <name>org.eclipse.jdt.core.javabuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+        </buildSpec>
+        <natures>
+                <nature>org.eclipse.jdt.core.javanature</nature>
+        </natures>
+</projectDescription>
diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..b5d234f
--- /dev/null
+++ b/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,13 @@
+#
+#Mon Sep 22 22:51:23 EDT 2014
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.source=1.7
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
diff --git a/build.py b/build.py
new file mode 100644
index 0000000..4729498
--- /dev/null
+++ b/build.py
@@ -0,0 +1,120 @@
+
+import os
+import sys
+
+# settings
+PathSsjb = "../ssjb"
+Author = "Cuchaz"
+
+DirBin = "bin"
+DirLib = "lib"
+DirBuild = "build"
+PathLocalMavenRepo = "../maven"
+
+
+# import ssjb
+sys.path.insert(0, PathSsjb)
+import ssjb
+import ssjb.ivy
+
+
+ArtifactStandalone = ssjb.ivy.Dep("cuchaz:enigma:0.6b")
+ArtifactLib = ssjb.ivy.Dep("cuchaz:enigma-lib:0.6b")
+
+# dependencies
+ExtraRepos = [
+        "http://maven.cuchazinteractive.com"
+]
+LibDeps = [
+        ssjb.ivy.Dep("com.google.guava:guava:17.0"),
+        ssjb.ivy.Dep("org.javassist:javassist:3.18.1-GA"),
+        ssjb.ivy.Dep("org.bitbucket.mstrobel:procyon-decompiler:0.5.28-enigma")
+]
+StandaloneDeps = LibDeps + [
+        ssjb.ivy.Dep("de.sciss:jsyntaxpane:1.0.0")
+]
+ProguardDep = ssjb.ivy.Dep("net.sf.proguard:proguard-base:5.1")
+TestDeps = [
+        ssjb.ivy.Dep("junit:junit:4.12"),
+        ssjb.ivy.Dep("org.hamcrest:hamcrest-all:1.3")
+]
+
+# functions
+
+def buildTestJar(name, glob):
+
+        pathJar = os.path.join(DirBuild, "%s.jar" % name)
+        pathObfJar = os.path.join(DirBuild, "%s.obf.jar" % name)
+
+        # build the deobf jar
+        with ssjb.file.TempDir("tmp") as dirTemp:
+                ssjb.file.copyTree(dirTemp, DirBin, ssjb.file.find(DirBin, "cuchaz/enigma/inputs/Keep.class"))
+                ssjb.file.copyTree(dirTemp, DirBin, ssjb.file.find(DirBin, glob))
+                ssjb.jar.makeJar(pathJar, dirTemp)
+
+        # build the obf jar
+        ssjb.callJavaJar(
+                os.path.join(DirLib, "proguard.jar"),
+                ["@proguard.conf", "-injars", pathJar, "-outjars", pathObfJar]
+        )
+
+
+def applyReadme(dirTemp):
+        ssjb.file.copy(dirTemp, "license.APL2.txt")
+        ssjb.file.copy(dirTemp, "license.GPL3.txt")
+        ssjb.file.copy(dirTemp, "readme.txt")
+
+
+def buildStandaloneJar(dirOut):
+        with ssjb.file.TempDir(os.path.join(dirOut, "tmp")) as dirTemp:
+                ssjb.file.copyTree(dirTemp, DirBin, ssjb.file.find(DirBin))
+                for path in ssjb.ivy.getJarPaths(StandaloneDeps, ExtraRepos):
+                        ssjb.jar.unpackJar(dirTemp, path)
+                ssjb.file.delete(os.path.join(dirTemp, "LICENSE.txt"))
+                ssjb.file.delete(os.path.join(dirTemp, "META-INF/maven"))
+                applyReadme(dirTemp)
+                manifest = ssjb.jar.buildManifest(
+                        ArtifactStandalone.artifactId,
+                        ArtifactStandalone.version,
+                        Author,
+                        "cuchaz.enigma.Main"
+                )
+                pathJar = os.path.join(DirBuild, "%s.jar" % ArtifactStandalone.getName()) 
+                ssjb.jar.makeJar(pathJar, dirTemp, manifest=manifest)
+                ssjb.ivy.deployJarToLocalMavenRepo(PathLocalMavenRepo, pathJar, ArtifactStandalone)
+
+def buildLibJar(dirOut):
+        with ssjb.file.TempDir(os.path.join(dirOut, "tmp")) as dirTemp:
+                ssjb.file.copyTree(dirTemp, DirBin, ssjb.file.find(DirBin))
+                applyReadme(dirTemp)
+                pathJar = os.path.join(DirBuild, "%s.jar" % ArtifactLib.getName()) 
+                ssjb.jar.makeJar(pathJar, dirTemp)
+                ssjb.ivy.deployJarToLocalMavenRepo(PathLocalMavenRepo, pathJar, ArtifactLib, deps=LibDeps)
+
+
+# tasks
+
+def taskGetDeps():
+        ssjb.file.mkdir(DirLib)
+        ssjb.ivy.makeLibsJar(os.path.join(DirLib, "deps.jar"), StandaloneDeps, extraRepos=ExtraRepos)
+        ssjb.ivy.makeLibsJar(os.path.join(DirLib, "test-deps.jar"), TestDeps)
+        ssjb.ivy.makeJar(os.path.join(DirLib, "proguard.jar"), ProguardDep)
+
+def taskBuildTestJars():
+        buildTestJar("testLoneClass", "cuchaz/enigma/inputs/loneClass/*.class")
+        buildTestJar("testConstructors", "cuchaz/enigma/inputs/constructors/*.class")
+        buildTestJar("testInheritanceTree", "cuchaz/enigma/inputs/inheritanceTree/*.class")
+        buildTestJar("testInnerClasses", "cuchaz/enigma/inputs/innerClasses/*.class")
+        buildTestJar("testTranslation", "cuchaz/enigma/inputs/translation/*.class")
+
+def taskBuild():
+        ssjb.file.delete(DirBuild)
+        ssjb.file.mkdir(DirBuild)
+        buildStandaloneJar(DirBuild)
+        buildLibJar(DirBuild)
+
+ssjb.registerTask("getDeps", taskGetDeps)
+ssjb.registerTask("buildTestJars", taskBuildTestJars)
+ssjb.registerTask("build", taskBuild)
+ssjb.run()
+
diff --git a/conf/about.html b/conf/about.html
new file mode 100644
index 0000000..b75c1bf
--- /dev/null
+++ b/conf/about.html
@@ -0,0 +1,6 @@
+<html>
+        <h1>%s</h1>
+        <p>A tool for debofuscation of Java code</p>
+        <p>
+        <p>Version: %s</p>
+</html>
\ No newline at end of file
diff --git a/license.APL2.txt b/license.APL2.txt
new file mode 100644
index 0000000..a453e43
--- /dev/null
+++ b/license.APL2.txt
@@ -0,0 +1,55 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/ 
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. 
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. 
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. 
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. 
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. 
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. 
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). 
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. 
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." 
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: 
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; and 
+
+
+You must cause any modified files to carry prominent notices stating that You changed the files; and 
+
+
+You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and 
+
+
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. 
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. 
\ No newline at end of file
diff --git a/license.GPL3.txt b/license.GPL3.txt
new file mode 100644
index 0000000..20d40b6
--- /dev/null
+++ b/license.GPL3.txt
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
\ No newline at end of file
diff --git a/proguard.conf b/proguard.conf
new file mode 100644
index 0000000..e1f04ae
--- /dev/null
+++ b/proguard.conf
@@ -0,0 +1,7 @@
+-libraryjars  <java.home>/lib/rt.jar
+-overloadaggressively
+-repackageclasses
+-allowaccessmodification
+-dontoptimize
+-dontshrink
+-keep class cuchaz.enigma.inputs.Keep
\ No newline at end of file
diff --git a/readme.txt b/readme.txt
new file mode 100644
index 0000000..3844f54
--- /dev/null
+++ b/readme.txt
@@ -0,0 +1,28 @@
+
+Enigma v0.6 beta
+A tool for deobfuscation of Java bytecode
+
+Copyright Jeff Martin, 2014
+
+
+LICENSE
+
+Enigma is distributed under the GNU General Public license version 3
+
+Enigma includes a modified version of Procyon which is distributed under the Apache license version 2. Procyon is copyrighted by Mike Strobel, 2013
+
+Enigma includes unmodified versions of the following libraries which are also released under the Apache license version 2.
+        Guava
+        Javassist
+        JSyntaxPane
+
+Copies of the GNU General Public license verion 3 and the Apache license v2 have been included in this distribution.
+
+
+USING ENIGMA
+
+Launch the GUI:
+        java -jar enigma.jar
+        
+Use Enigma on the command line:
+        java -cp enigma.jar cuchaz.enigma.CommandMain
diff --git a/src/cuchaz/enigma/CommandMain.java b/src/cuchaz/enigma/CommandMain.java
new file mode 100644
index 0000000..1ec2ad2
--- /dev/null
+++ b/src/cuchaz/enigma/CommandMain.java
@@ -0,0 +1,136 @@
+package cuchaz.enigma;
+
+import java.io.File;
+import java.io.FileReader;
+import java.util.jar.JarFile;
+
+import cuchaz.enigma.Deobfuscator.ProgressListener;
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsReader;
+
+public class CommandMain {
+        
+        public static class ConsoleProgressListener implements ProgressListener {
+                
+                private static final int ReportTime = 5000; // 5s
+
+                private int m_totalWork;
+                private long m_startTime;
+                private long m_lastReportTime;
+                
+                @Override
+                public void init(int totalWork, String title) {
+                        m_totalWork = totalWork;
+                        m_startTime = System.currentTimeMillis();
+                        m_lastReportTime = m_startTime;
+                        System.out.println(title);
+                }
+
+                @Override
+                public void onProgress(int numDone, String message) {
+                        
+                        long now = System.currentTimeMillis();
+                        boolean isLastUpdate = numDone == m_totalWork;
+                        boolean shouldReport = isLastUpdate || now - m_lastReportTime > ReportTime;
+                        
+                        if (shouldReport) {
+                                int percent = numDone*100/m_totalWork;
+                                System.out.println(String.format("\tProgress: %3d%%", percent));
+                                m_lastReportTime = now;
+                        }
+                        if (isLastUpdate) {
+                                double elapsedSeconds = (now - m_startTime)/1000;
+                                System.out.println(String.format("Finished in %.1f seconds", elapsedSeconds));
+                        }
+                }
+        }
+        
+        public static void main(String[] args)
+        throws Exception {
+                
+                try {
+                        
+                        // process the command
+                        String command = getArg(args, 0, "command");
+                        if (command.equalsIgnoreCase("deobfuscate")) {
+                                deobfuscate(args);
+                        } else if(command.equalsIgnoreCase("decompile")) {
+                                decompile(args);
+                        } else {
+                                throw new IllegalArgumentException("Command not recognized: " + command);
+                        }
+                } catch (IllegalArgumentException ex) {
+                        System.out.println(ex.getMessage());
+                        printHelp();
+                }
+        }
+
+        private static void printHelp() {
+                System.out.println(String.format("%s - %s", Constants.Name, Constants.Version));
+                System.out.println("Usage:");
+                System.out.println("\tjava -cp enigma.jar cuchaz.enigma.CommandMain <command>");
+                System.out.println("\twhere <command> is one of:");
+                System.out.println("\t\tdeobfuscate <mappings file> <in jar> <out jar>");
+                System.out.println("\t\tdecompile <mappings file> <in jar> <out folder>");
+        }
+        
+        private static void decompile(String[] args)
+        throws Exception {
+                File fileMappings = getReadableFile(getArg(args, 1, "mappings file"));
+                File fileJarIn = getReadableFile(getArg(args, 2, "in jar"));
+                File fileJarOut = getWritableFolder(getArg(args, 3, "out folder"));
+                Deobfuscator deobfuscator = getDeobfuscator(fileMappings, new JarFile(fileJarIn));
+                deobfuscator.writeSources(fileJarOut, new ConsoleProgressListener());
+        }
+
+        private static void deobfuscate(String[] args)
+        throws Exception {
+                File fileMappings = getReadableFile(getArg(args, 1, "mappings file"));
+                File fileJarIn = getReadableFile(getArg(args, 2, "in jar"));
+                File fileJarOut = getWritableFile(getArg(args, 3, "out jar"));
+                Deobfuscator deobfuscator = getDeobfuscator(fileMappings, new JarFile(fileJarIn));
+                deobfuscator.writeJar(fileJarOut, new ConsoleProgressListener());
+        }
+        
+        private static Deobfuscator getDeobfuscator(File fileMappings, JarFile jar)
+        throws Exception {
+                System.out.println("Reading mappings...");
+                Mappings mappings = new MappingsReader().read(new FileReader(fileMappings));
+                System.out.println("Reading jar...");
+                Deobfuscator deobfuscator = new Deobfuscator(jar);
+                deobfuscator.setMappings(mappings);
+                return deobfuscator;
+        }
+        
+        private static String getArg(String[] args, int i, String name) {
+                if (i >= args.length) {
+                        throw new IllegalArgumentException(name + " is required");
+                }
+                return args[i];
+        }
+
+        private static File getWritableFile(String path) {
+                File file = new File(path).getAbsoluteFile();
+                File dir = file.getParentFile();
+                if (dir == null || !dir.exists()) {
+                        throw new IllegalArgumentException("Cannot write to folder: " + file);
+                }
+                return file;
+        }
+
+        private static File getWritableFolder(String path) {
+                File dir = new File(path).getAbsoluteFile();
+                if (!dir.exists()) {
+                        throw new IllegalArgumentException("Cannot write to folder: " + dir);
+                }
+                return dir;
+        }
+        
+        private static File getReadableFile(String path) {
+                File file = new File(path).getAbsoluteFile();
+                if (!file.exists()) {
+                        throw new IllegalArgumentException("Cannot find file: " + file.getAbsolutePath());
+                }
+                return file;
+        }
+}
diff --git a/src/cuchaz/enigma/Constants.java b/src/cuchaz/enigma/Constants.java
new file mode 100644
index 0000000..a1ba2e9
--- /dev/null
+++ b/src/cuchaz/enigma/Constants.java
@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+public class Constants {
+        public static final String Name = "Enigma";
+        public static final String Version = "0.6 beta";
+        public static final String Url = "http://www.cuchazinteractive.com/enigma";
+        public static final int MiB = 1024 * 1024; // 1 mebibyte
+        public static final int KiB = 1024; // 1 kebibyte
+        public static final String NonePackage = "none";
+}
diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
new file mode 100644
index 0000000..5f61686
--- /dev/null
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -0,0 +1,539 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.\
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+
+import javassist.CtClass;
+import javassist.bytecode.Descriptor;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.strobel.assembler.metadata.MetadataSystem;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.decompiler.DecompilerContext;
+import com.strobel.decompiler.DecompilerSettings;
+import com.strobel.decompiler.PlainTextOutput;
+import com.strobel.decompiler.languages.java.JavaOutputVisitor;
+import com.strobel.decompiler.languages.java.ast.AstBuilder;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+import com.strobel.decompiler.languages.java.ast.InsertParenthesesVisitor;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.JarClassIterator;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.analysis.SourceIndex;
+import cuchaz.enigma.analysis.SourceIndexVisitor;
+import cuchaz.enigma.analysis.Token;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassMapping;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.FieldMapping;
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsRenamer;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.MethodMapping;
+import cuchaz.enigma.mapping.TranslationDirection;
+import cuchaz.enigma.mapping.Translator;
+
+public class Deobfuscator {
+        
+        public interface ProgressListener {
+                void init(int totalWork, String title);
+                void onProgress(int numDone, String message);
+        }
+        
+        private JarFile m_jar;
+        private DecompilerSettings m_settings;
+        private JarIndex m_jarIndex;
+        private Mappings m_mappings;
+        private MappingsRenamer m_renamer;
+        private Map<TranslationDirection,Translator> m_translatorCache;
+        
+        public Deobfuscator(JarFile jar) throws IOException {
+                m_jar = jar;
+                
+                // build the jar index
+                m_jarIndex = new JarIndex();
+                m_jarIndex.indexJar(m_jar, true);
+                
+                // config the decompiler
+                m_settings = DecompilerSettings.javaDefaults();
+                m_settings.setMergeVariables(true);
+                m_settings.setForceExplicitImports(true);
+                m_settings.setForceExplicitTypeArguments(true);
+                // DEBUG
+                //m_settings.setShowSyntheticMembers(true);
+                
+                // init defaults
+                m_translatorCache = Maps.newTreeMap();
+                
+                // init mappings
+                setMappings(new Mappings());
+        }
+        
+        public String getJarName() {
+                return m_jar.getName();
+        }
+        
+        public JarIndex getJarIndex() {
+                return m_jarIndex;
+        }
+        
+        public Mappings getMappings() {
+                return m_mappings;
+        }
+        
+        public void setMappings(Mappings val) {
+                if (val == null) {
+                        val = new Mappings();
+                }
+                
+                // pass 1: look for any classes that got moved to inner classes
+                Map<String,String> renames = Maps.newHashMap();
+                for (ClassMapping classMapping : val.classes()) {
+                        // make sure we strip the packages off of obfuscated inner classes
+                        String innerClassName = new ClassEntry(classMapping.getObfName()).getSimpleName();
+                        String outerClassName = m_jarIndex.getOuterClass(innerClassName);
+                        if (outerClassName != null) {
+                                // build the composite class name
+                                String newName = outerClassName + "$" + innerClassName;
+                                
+                                // add a rename
+                                renames.put(classMapping.getObfName(), newName);
+                                
+                                System.out.println(String.format("Converted class mapping %s to %s", classMapping.getObfName(), newName));
+                        }
+                }
+                for (Map.Entry<String,String> entry : renames.entrySet()) {
+                        val.renameObfClass(entry.getKey(), entry.getValue());
+                }
+                
+                // pass 2: look for fields/methods that are actually declared in superclasses
+                MappingsRenamer renamer = new MappingsRenamer(m_jarIndex, val);
+                for (ClassMapping classMapping : Lists.newArrayList(val.classes())) {
+                        ClassEntry obfClassEntry = new ClassEntry(classMapping.getObfName());
+                        
+                        // fields
+                        for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
+                                FieldEntry fieldEntry = new FieldEntry(obfClassEntry, fieldMapping.getObfName());
+                                ClassEntry resolvedObfClassEntry = m_jarIndex.getTranslationIndex().resolveEntryClass(fieldEntry);
+                                if (resolvedObfClassEntry != null && !resolvedObfClassEntry.equals(fieldEntry.getClassEntry())) {
+                                        boolean wasMoved = renamer.moveFieldToObfClass(classMapping, fieldMapping, resolvedObfClassEntry);
+                                        if (wasMoved) {
+                                                System.out.println(String.format("Moved field %s to class %s", fieldEntry, resolvedObfClassEntry));
+                                        } else {
+                                                System.err.println(String.format("WARNING: Would move field %s to class %s but the field was already there. Dropping instead.", fieldEntry, resolvedObfClassEntry));
+                                        }
+                                }
+                        }
+                        
+                        // methods
+                        for (MethodMapping methodMapping : Lists.newArrayList(classMapping.methods())) {
+                                // skip constructors
+                                if (methodMapping.isConstructor()) {
+                                        continue;
+                                }
+                                
+                                MethodEntry methodEntry = new MethodEntry(
+                                        obfClassEntry,
+                                        methodMapping.getObfName(),
+                                        methodMapping.getObfSignature()
+                                );
+                                ClassEntry resolvedObfClassEntry = m_jarIndex.getTranslationIndex().resolveEntryClass(methodEntry);
+                                if (resolvedObfClassEntry != null && !resolvedObfClassEntry.equals(methodEntry.getClassEntry())) {
+                                        boolean wasMoved = renamer.moveMethodToObfClass(classMapping, methodMapping, resolvedObfClassEntry);
+                                        if (wasMoved) {
+                                                System.out.println(String.format("Moved method %s to class %s", methodEntry, resolvedObfClassEntry));
+                                        } else {
+                                                System.err.println(String.format("WARNING: Would move method %s to class %s but the method was already there. Dropping instead.", methodEntry, resolvedObfClassEntry));
+                                        }
+                                }
+                        }
+                        
+                        // TODO: recurse to inner classes?
+                }
+                
+                // drop mappings that don't match the jar
+                List<ClassEntry> unknownClasses = Lists.newArrayList();
+                for (ClassMapping classMapping : val.classes()) {
+                        checkClassMapping(unknownClasses, classMapping);
+                }
+                if (!unknownClasses.isEmpty()) {
+                        throw new Error("Unable to find classes in jar: " + unknownClasses);
+                }
+                
+                m_mappings = val;
+                m_renamer = renamer;
+                m_translatorCache.clear();
+        }
+        
+        private void checkClassMapping(List<ClassEntry> unknownClasses, ClassMapping classMapping) {
+                // check the class
+                ClassEntry classEntry = new ClassEntry(classMapping.getObfName());
+                String outerClassName = m_jarIndex.getOuterClass(classEntry.getSimpleName());
+                if (outerClassName != null) {
+                        classEntry = new ClassEntry(outerClassName + "$" + classMapping.getObfName());
+                }
+                if (!m_jarIndex.getObfClassEntries().contains(classEntry)) {
+                        unknownClasses.add(classEntry);
+                }
+                
+                // check the fields
+                for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, fieldMapping.getObfName());
+                        if (!m_jarIndex.containsObfField(fieldEntry)) {
+                                System.err.println("WARNING: unable to find field " + fieldEntry + ". dropping mapping.");
+                                classMapping.removeFieldMapping(fieldMapping);
+                        }
+                }
+                
+                // check methods
+                for (MethodMapping methodMapping : Lists.newArrayList(classMapping.methods())) {
+                        BehaviorEntry obfBehaviorEntry = BehaviorEntryFactory.createObf(classEntry, methodMapping);
+                        if (!m_jarIndex.containsObfBehavior(obfBehaviorEntry)) {
+                                System.err.println("WARNING: unable to find behavior " + obfBehaviorEntry + ". dropping mapping.");
+                                classMapping.removeMethodMapping(methodMapping);
+                        }
+                }
+                
+                // check inner classes
+                for (ClassMapping innerClassMapping : classMapping.innerClasses()) {
+                        checkClassMapping(unknownClasses, innerClassMapping);
+                }
+        }
+        
+        public Translator getTranslator(TranslationDirection direction) {
+                Translator translator = m_translatorCache.get(direction);
+                if (translator == null) {
+                        translator = m_mappings.getTranslator(direction, m_jarIndex.getTranslationIndex());
+                        m_translatorCache.put(direction, translator);
+                }
+                return translator;
+        }
+        
+        public void getSeparatedClasses(List<ClassEntry> obfClasses, List<ClassEntry> deobfClasses) {
+                for (ClassEntry obfClassEntry : m_jarIndex.getObfClassEntries()) {
+                        // skip inner classes
+                        if (obfClassEntry.isInnerClass()) {
+                                continue;
+                        }
+                        
+                        // separate the classes
+                        ClassEntry deobfClassEntry = deobfuscateEntry(obfClassEntry);
+                        if (!deobfClassEntry.equals(obfClassEntry)) {
+                                // if the class has a mapping, clearly it's deobfuscated
+                                deobfClasses.add(deobfClassEntry);
+                        } else if (!obfClassEntry.getPackageName().equals(Constants.NonePackage)) {
+                                // also call it deobufscated if it's not in the none package
+                                deobfClasses.add(obfClassEntry);
+                        } else {
+                                // otherwise, assume it's still obfuscated
+                                obfClasses.add(obfClassEntry);
+                        }
+                }
+        }
+        
+        public CompilationUnit getSourceTree(String obfClassName) {
+                // is this class deobfuscated?
+                // we need to tell the decompiler the deobfuscated name so it doesn't get freaked out
+                // the decompiler only sees the deobfuscated class, so we need to load it by the deobfuscated name
+                String lookupClassName = obfClassName;
+                ClassMapping classMapping = m_mappings.getClassByObf(obfClassName);
+                if (classMapping != null && classMapping.getDeobfName() != null) {
+                        lookupClassName = classMapping.getDeobfName();
+                }
+                
+                // is this class even in the jar?
+                if (!m_jarIndex.containsObfClass(new ClassEntry(obfClassName))) {
+                        return null;
+                }
+                
+                // set the type loader
+                m_settings.setTypeLoader(new TranslatingTypeLoader(
+                        m_jar,
+                        m_jarIndex,
+                        getTranslator(TranslationDirection.Obfuscating),
+                        getTranslator(TranslationDirection.Deobfuscating)
+                ));
+                
+                // decompile it!
+                TypeDefinition resolvedType = new MetadataSystem(m_settings.getTypeLoader()).lookupType(lookupClassName).resolve();
+                DecompilerContext context = new DecompilerContext();
+                context.setCurrentType(resolvedType);
+                context.setSettings(m_settings);
+                AstBuilder builder = new AstBuilder(context);
+                builder.addType(resolvedType);
+                builder.runTransformations(null);
+                return builder.getCompilationUnit();
+        }
+        
+        public SourceIndex getSourceIndex(CompilationUnit sourceTree, String source) {
+                // build the source index
+                SourceIndex index = new SourceIndex(source);
+                sourceTree.acceptVisitor(new SourceIndexVisitor(), index);
+                
+                // DEBUG
+                // sourceTree.acceptVisitor( new TreeDumpVisitor( new File( "tree.txt" ) ), null );
+                
+                // resolve all the classes in the source references
+                for (Token token : index.referenceTokens()) {
+                        EntryReference<Entry,Entry> deobfReference = index.getDeobfReference(token);
+                        
+                        // get the obfuscated entry
+                        Entry obfEntry = obfuscateEntry(deobfReference.entry);
+                        
+                        // try to resolve the class
+                        ClassEntry resolvedObfClassEntry = m_jarIndex.getTranslationIndex().resolveEntryClass(obfEntry);
+                        if (resolvedObfClassEntry != null && !resolvedObfClassEntry.equals(obfEntry.getClassEntry())) {
+                                // change the class of the entry
+                                obfEntry = obfEntry.cloneToNewClass(resolvedObfClassEntry);
+                                
+                                // save the new deobfuscated reference
+                                deobfReference.entry = deobfuscateEntry(obfEntry);
+                                index.replaceDeobfReference(token, deobfReference);
+                        }
+                        
+                        // DEBUG
+                        // System.out.println( token + " -> " + reference + " -> " + index.getReferenceToken( reference ) );
+                }
+                
+                return index;
+        }
+        
+        public String getSource(CompilationUnit sourceTree) {
+                // render the AST into source
+                StringWriter buf = new StringWriter();
+                sourceTree.acceptVisitor(new InsertParenthesesVisitor(), null);
+                sourceTree.acceptVisitor(new JavaOutputVisitor(new PlainTextOutput(buf), m_settings), null);
+                return buf.toString();
+        }
+        
+        public void writeSources(File dirOut, ProgressListener progress) throws IOException {
+                // get the classes to decompile
+                Set<ClassEntry> classEntries = Sets.newHashSet();
+                for (ClassEntry obfClassEntry : m_jarIndex.getObfClassEntries()) {
+                        // skip inner classes
+                        if (obfClassEntry.isInnerClass()) {
+                                continue;
+                        }
+                        
+                        classEntries.add(obfClassEntry);
+                }
+                
+                if (progress != null) {
+                        progress.init(classEntries.size(), "Decompiling classes...");
+                }
+                
+                // DEOBFUSCATE ALL THE THINGS!! @_@
+                int i = 0;
+                for (ClassEntry obfClassEntry : classEntries) {
+                        ClassEntry deobfClassEntry = deobfuscateEntry(new ClassEntry(obfClassEntry));
+                        if (progress != null) {
+                                progress.onProgress(i++, deobfClassEntry.toString());
+                        }
+                        
+                        try {
+                                // get the source
+                                String source = getSource(getSourceTree(obfClassEntry.getName()));
+                                
+                                // write the file
+                                File file = new File(dirOut, deobfClassEntry.getName().replace('.', '/') + ".java");
+                                file.getParentFile().mkdirs();
+                                try (FileWriter out = new FileWriter(file)) {
+                                        out.write(source);
+                                }
+                        } catch (Throwable t) {
+                                throw new Error("Unable to deobfuscate class " + deobfClassEntry.toString() + " (" + obfClassEntry.toString() + ")", t);
+                        }
+                }
+                if (progress != null) {
+                        progress.onProgress(i, "Done!");
+                }
+        }
+        
+        public void writeJar(File out, ProgressListener progress) {
+                try (JarOutputStream outJar = new JarOutputStream(new FileOutputStream(out))) {
+                        if (progress != null) {
+                                progress.init(JarClassIterator.getClassEntries(m_jar).size(), "Translating classes...");
+                        }
+                        
+                        // prep the loader
+                        TranslatingTypeLoader loader = new TranslatingTypeLoader(
+                                m_jar,
+                                m_jarIndex,
+                                getTranslator(TranslationDirection.Obfuscating),
+                                getTranslator(TranslationDirection.Deobfuscating)
+                        );
+                        
+                        int i = 0;
+                        for (CtClass c : JarClassIterator.classes(m_jar)) {
+                                if (progress != null) {
+                                        progress.onProgress(i++, c.getName());
+                                }
+                                
+                                try {
+                                        c = loader.transformClass(c);
+                                        outJar.putNextEntry(new JarEntry(c.getName().replace('.', '/') + ".class"));
+                                        outJar.write(c.toBytecode());
+                                        outJar.closeEntry();
+                                } catch (Throwable t) {
+                                        throw new Error("Unable to deobfuscate class " + c.getName(), t);
+                                }
+                        }
+                        if (progress != null) {
+                                progress.onProgress(i, "Done!");
+                        }
+                        
+                        outJar.close();
+                } catch (IOException ex) {
+                        throw new Error("Unable to write to Jar file!");
+                }
+        }
+        
+        public <T extends Entry> T obfuscateEntry(T deobfEntry) {
+                if (deobfEntry == null) {
+                        return null;
+                }
+                return getTranslator(TranslationDirection.Obfuscating).translateEntry(deobfEntry);
+        }
+        
+        public <T extends Entry> T deobfuscateEntry(T obfEntry) {
+                if (obfEntry == null) {
+                        return null;
+                }
+                return getTranslator(TranslationDirection.Deobfuscating).translateEntry(obfEntry);
+        }
+        
+        public <E extends Entry,C extends Entry> EntryReference<E,C> obfuscateReference(EntryReference<E,C> deobfReference) {
+                if (deobfReference == null) {
+                        return null;
+                }
+                return new EntryReference<E,C>(
+                        obfuscateEntry(deobfReference.entry),
+                        obfuscateEntry(deobfReference.context),
+                        deobfReference
+                );
+        }
+        
+        public <E extends Entry,C extends Entry> EntryReference<E,C> deobfuscateReference(EntryReference<E,C> obfReference) {
+                if (obfReference == null) {
+                        return null;
+                }
+                return new EntryReference<E,C>(
+                        deobfuscateEntry(obfReference.entry),
+                        deobfuscateEntry(obfReference.context),
+                        obfReference
+                );
+        }
+        
+        public boolean isObfuscatedIdentifier(Entry obfEntry) {
+                return m_jarIndex.containsObfEntry(obfEntry);
+        }
+        
+        public boolean isRenameable(EntryReference<Entry,Entry> obfReference) {
+                return obfReference.isNamed() && isObfuscatedIdentifier(obfReference.getNameableEntry());
+        }
+        
+        // NOTE: these methods are a bit messy... oh well
+        
+        public boolean hasDeobfuscatedName(Entry obfEntry) {
+                Translator translator = getTranslator(TranslationDirection.Deobfuscating);
+                if (obfEntry instanceof ClassEntry) {
+                        return translator.translate((ClassEntry)obfEntry) != null;
+                } else if (obfEntry instanceof FieldEntry) {
+                        return translator.translate((FieldEntry)obfEntry) != null;
+                } else if (obfEntry instanceof MethodEntry) {
+                        return translator.translate((MethodEntry)obfEntry) != null;
+                } else if (obfEntry instanceof ConstructorEntry) {
+                        // constructors have no names
+                        return false;
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        return translator.translate((ArgumentEntry)obfEntry) != null;
+                } else {
+                        throw new Error("Unknown entry type: " + obfEntry.getClass().getName());
+                }
+        }
+        
+        public void rename(Entry obfEntry, String newName) {
+                if (obfEntry instanceof ClassEntry) {
+                        m_renamer.setClassName((ClassEntry)obfEntry, Descriptor.toJvmName(newName));
+                } else if (obfEntry instanceof FieldEntry) {
+                        m_renamer.setFieldName((FieldEntry)obfEntry, newName);
+                } else if (obfEntry instanceof MethodEntry) {
+                        m_renamer.setMethodTreeName((MethodEntry)obfEntry, newName);
+                } else if (obfEntry instanceof ConstructorEntry) {
+                        throw new IllegalArgumentException("Cannot rename constructors");
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        m_renamer.setArgumentName((ArgumentEntry)obfEntry, newName);
+                } else {
+                        throw new Error("Unknown entry type: " + obfEntry.getClass().getName());
+                }
+                
+                // clear caches
+                m_translatorCache.clear();
+        }
+        
+        public void removeMapping(Entry obfEntry) {
+                if (obfEntry instanceof ClassEntry) {
+                        m_renamer.removeClassMapping((ClassEntry)obfEntry);
+                } else if (obfEntry instanceof FieldEntry) {
+                        m_renamer.removeFieldMapping((FieldEntry)obfEntry);
+                } else if (obfEntry instanceof MethodEntry) {
+                        m_renamer.removeMethodTreeMapping((MethodEntry)obfEntry);
+                } else if (obfEntry instanceof ConstructorEntry) {
+                        throw new IllegalArgumentException("Cannot rename constructors");
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        m_renamer.removeArgumentMapping((ArgumentEntry)obfEntry);
+                } else {
+                        throw new Error("Unknown entry type: " + obfEntry);
+                }
+                
+                // clear caches
+                m_translatorCache.clear();
+        }
+        
+        public void markAsDeobfuscated(Entry obfEntry) {
+                if (obfEntry instanceof ClassEntry) {
+                        m_renamer.markClassAsDeobfuscated((ClassEntry)obfEntry);
+                } else if (obfEntry instanceof FieldEntry) {
+                        m_renamer.markFieldAsDeobfuscated((FieldEntry)obfEntry);
+                } else if (obfEntry instanceof MethodEntry) {
+                        m_renamer.markMethodTreeAsDeobfuscated((MethodEntry)obfEntry);
+                } else if (obfEntry instanceof ConstructorEntry) {
+                        throw new IllegalArgumentException("Cannot rename constructors");
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        m_renamer.markArgumentAsDeobfuscated((ArgumentEntry)obfEntry);
+                } else {
+                        throw new Error("Unknown entry type: " + obfEntry);
+                }
+                
+                // clear caches
+                m_translatorCache.clear();
+        }
+}
diff --git a/src/cuchaz/enigma/Main.java b/src/cuchaz/enigma/Main.java
new file mode 100644
index 0000000..acae94b
--- /dev/null
+++ b/src/cuchaz/enigma/Main.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.io.File;
+import java.util.jar.JarFile;
+
+import cuchaz.enigma.gui.Gui;
+
+public class Main {
+        
+        public static void main(String[] args) throws Exception {
+                Gui gui = new Gui();
+                
+                // parse command-line args
+                if (args.length >= 1) {
+                        gui.getController().openJar(new JarFile(getFile(args[0])));
+                }
+                if (args.length >= 2) {
+                        gui.getController().openMappings(getFile(args[1]));
+                }
+                
+                // DEBUG
+                //gui.getController().openDeclaration(new ClassEntry("none/bxq"));
+        }
+        
+        private static File getFile(String path) {
+                // expand ~ to the home dir
+                if (path.startsWith("~")) {
+                        // get the home dir
+                        File dirHome = new File(System.getProperty("user.home"));
+                        
+                        // is the path just ~/ or is it ~user/ ?
+                        if (path.startsWith("~/")) {
+                                return new File(dirHome, path.substring(2));
+                        } else {
+                                return new File(dirHome.getParentFile(), path.substring(1));
+                        }
+                }
+                
+                return new File(path);
+        }
+}
diff --git a/src/cuchaz/enigma/TranslatingTypeLoader.java b/src/cuchaz/enigma/TranslatingTypeLoader.java
new file mode 100644
index 0000000..cfa03a1
--- /dev/null
+++ b/src/cuchaz/enigma/TranslatingTypeLoader.java
@@ -0,0 +1,211 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import javassist.ByteArrayClassPath;
+import javassist.CannotCompileException;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+import javassist.bytecode.Descriptor;
+
+import com.google.common.collect.Maps;
+import com.strobel.assembler.metadata.Buffer;
+import com.strobel.assembler.metadata.ClasspathTypeLoader;
+import com.strobel.assembler.metadata.ITypeLoader;
+
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.bytecode.ClassRenamer;
+import cuchaz.enigma.bytecode.ClassTranslator;
+import cuchaz.enigma.bytecode.InnerClassWriter;
+import cuchaz.enigma.bytecode.MethodParameterWriter;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class TranslatingTypeLoader implements ITypeLoader {
+        
+        private JarFile m_jar;
+        private JarIndex m_jarIndex;
+        private Translator m_obfuscatingTranslator;
+        private Translator m_deobfuscatingTranslator;
+        private Map<String,byte[]> m_cache;
+        private ClasspathTypeLoader m_defaultTypeLoader;
+        
+        public TranslatingTypeLoader(JarFile jar, JarIndex jarIndex) {
+                this(jar, jarIndex, new Translator(), new Translator());
+        }
+        
+        public TranslatingTypeLoader(JarFile jar, JarIndex jarIndex, Translator obfuscatingTranslator, Translator deobfuscatingTranslator) {
+                m_jar = jar;
+                m_jarIndex = jarIndex;
+                m_obfuscatingTranslator = obfuscatingTranslator;
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_cache = Maps.newHashMap();
+                m_defaultTypeLoader = new ClasspathTypeLoader();
+        }
+        
+        public void clearCache() {
+                m_cache.clear();
+        }
+        
+        @Override
+        public boolean tryLoadType(String deobfClassName, Buffer out) {
+                // check the cache
+                byte[] data;
+                if (m_cache.containsKey(deobfClassName)) {
+                        data = m_cache.get(deobfClassName);
+                } else {
+                        data = loadType(deobfClassName);
+                        m_cache.put(deobfClassName, data);
+                }
+                
+                if (data == null) {
+                        // chain to default type loader
+                        return m_defaultTypeLoader.tryLoadType(deobfClassName, out);
+                }
+                
+                // send the class to the decompiler
+                out.reset(data.length);
+                System.arraycopy(data, 0, out.array(), out.position(), data.length);
+                out.position(0);
+                return true;
+        }
+        
+        public CtClass loadClass(String deobfClassName) {
+                byte[] data = loadType(deobfClassName);
+                if (data == null) {
+                        return null;
+                }
+                
+                // return a javassist handle for the class
+                String javaClassFileName = Descriptor.toJavaName(deobfClassName);
+                ClassPool classPool = new ClassPool();
+                classPool.insertClassPath(new ByteArrayClassPath(javaClassFileName, data));
+                try {
+                        return classPool.get(javaClassFileName);
+                } catch (NotFoundException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private byte[] loadType(String deobfClassName) {
+                ClassEntry deobfClassEntry = new ClassEntry(deobfClassName);
+                ClassEntry obfClassEntry = m_obfuscatingTranslator.translateEntry(deobfClassEntry);
+                
+                // is this an inner class referenced directly?
+                String obfOuterClassName = m_jarIndex.getOuterClass(obfClassEntry.getSimpleName());
+                if (obfOuterClassName != null) {
+                        // this class doesn't really exist. Reference it by outer$inner instead
+                        System.err.println(String.format("WARNING: class %s referenced by bare inner name instead of via outer class %s", deobfClassName, obfOuterClassName));
+                        return null;
+                }
+                
+                /* DEBUG
+                if( !Arrays.asList( "java", "org", "io" ).contains( deobfClassName.split( "/" )[0] ) ) {
+                        System.out.println( String.format( "Looking for %s (%s)", deobfClassEntry.getName(), obfClassEntry.getName() ) );
+                }
+                */
+                
+                // get the jar entry
+                String classFileName;
+                if (obfClassEntry.isInnerClass()) {
+                        // use just the inner class name for inner classes
+                        classFileName = obfClassEntry.getInnerClassName();
+                } else if (obfClassEntry.getPackageName().equals(Constants.NonePackage)) {
+                        // use the outer class simple name for classes in the none package
+                        classFileName = obfClassEntry.getSimpleName();
+                } else {
+                        // otherwise, just use the class name (ie for classes in packages)
+                        classFileName = obfClassEntry.getName();
+                }
+                
+                JarEntry entry = m_jar.getJarEntry(classFileName + ".class");
+                if (entry == null) {
+                        return null;
+                }
+                
+                try {
+                        // read the class file into a buffer
+                        ByteArrayOutputStream data = new ByteArrayOutputStream();
+                        byte[] buf = new byte[1024 * 1024]; // 1 KiB
+                        InputStream in = m_jar.getInputStream(entry);
+                        while (true) {
+                                int bytesRead = in.read(buf);
+                                if (bytesRead <= 0) {
+                                        break;
+                                }
+                                data.write(buf, 0, bytesRead);
+                        }
+                        data.close();
+                        in.close();
+                        buf = data.toByteArray();
+                        
+                        // load the javassist handle to the raw class
+                        String javaClassFileName = Descriptor.toJavaName(classFileName);
+                        ClassPool classPool = new ClassPool();
+                        classPool.insertClassPath(new ByteArrayClassPath(javaClassFileName, buf));
+                        CtClass c = classPool.get(javaClassFileName);
+                        
+                        c = transformClass(c);
+                        
+                        // sanity checking
+                        assertClassName(c, deobfClassEntry);
+                        
+                        // DEBUG
+                        //Util.writeClass( c );
+                        
+                        // we have a transformed class!
+                        return c.toBytecode();
+                } catch (IOException | NotFoundException | CannotCompileException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public CtClass transformClass(CtClass c) throws IOException, NotFoundException, CannotCompileException {
+                // we moved a lot of classes out of the default package into the none package
+                // make sure all the class references are consistent
+                ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                
+                // reconstruct inner classes
+                new InnerClassWriter(m_jarIndex).write(c);
+                
+                // re-get the javassist handle since we changed class names
+                ClassEntry obfClassEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                String javaClassReconstructedName = Descriptor.toJavaName(obfClassEntry.getName());
+                ClassPool classPool = new ClassPool();
+                classPool.insertClassPath(new ByteArrayClassPath(javaClassReconstructedName, c.toBytecode()));
+                c = classPool.get(javaClassReconstructedName);
+                
+                // check that the file is correct after inner class reconstruction (ie cause Javassist to fail fast if something is wrong)
+                assertClassName(c, obfClassEntry);
+                
+                // do all kinds of deobfuscating transformations on the class
+                new MethodParameterWriter(m_deobfuscatingTranslator).writeMethodArguments(c);
+                new ClassTranslator(m_deobfuscatingTranslator).translate(c);
+                
+                return c;
+        }
+        
+        private void assertClassName(CtClass c, ClassEntry obfClassEntry) {
+                String name1 = Descriptor.toJvmName(c.getName());
+                assert (name1.equals(obfClassEntry.getName())) : String.format("Looking for %s, instead found %s", obfClassEntry.getName(), name1);
+                
+                String name2 = Descriptor.toJvmName(c.getClassFile().getName());
+                assert (name2.equals(obfClassEntry.getName())) : String.format("Looking for %s, instead found %s", obfClassEntry.getName(), name2);
+        }
+}
diff --git a/src/cuchaz/enigma/Util.java b/src/cuchaz/enigma/Util.java
new file mode 100644
index 0000000..7f04bda
--- /dev/null
+++ b/src/cuchaz/enigma/Util.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.awt.Desktop;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.jar.JarFile;
+
+import javassist.CannotCompileException;
+import javassist.CtClass;
+import javassist.bytecode.Descriptor;
+
+import com.google.common.io.CharStreams;
+
+public class Util {
+        
+        public static int combineHashesOrdered(Object... objs) {
+                return combineHashesOrdered(Arrays.asList(objs));
+        }
+        
+        public static int combineHashesOrdered(Iterable<Object> objs) {
+                final int prime = 67;
+                int result = 1;
+                for (Object obj : objs) {
+                        result *= prime;
+                        if (obj != null) {
+                                result += obj.hashCode();
+                        }
+                }
+                return result;
+        }
+        
+        public static void closeQuietly(Closeable closeable) {
+                if (closeable != null) {
+                        try {
+                                closeable.close();
+                        } catch (IOException ex) {
+                                // just ignore any further exceptions
+                        }
+                }
+        }
+        
+        public static void closeQuietly(JarFile jarFile) {
+                // silly library should implement Closeable...
+                if (jarFile != null) {
+                        try {
+                                jarFile.close();
+                        } catch (IOException ex) {
+                                // just ignore any further exceptions
+                        }
+                }
+        }
+        
+        public static String readStreamToString(InputStream in) throws IOException {
+                return CharStreams.toString(new InputStreamReader(in, "UTF-8"));
+        }
+        
+        public static String readResourceToString(String path) throws IOException {
+                InputStream in = Util.class.getResourceAsStream(path);
+                if (in == null) {
+                        throw new IllegalArgumentException("Resource not found! " + path);
+                }
+                return readStreamToString(in);
+        }
+        
+        public static void openUrl(String url) {
+                if (Desktop.isDesktopSupported()) {
+                        Desktop desktop = Desktop.getDesktop();
+                        try {
+                                desktop.browse(new URI(url));
+                        } catch (IOException ex) {
+                                throw new Error(ex);
+                        } catch (URISyntaxException ex) {
+                                throw new IllegalArgumentException(ex);
+                        }
+                }
+        }
+        
+        public static void writeClass(CtClass c) {
+                String name = Descriptor.toJavaName(c.getName());
+                File file = new File(name + ".class");
+                try (FileOutputStream out = new FileOutputStream(file)) {
+                        out.write(c.toBytecode());
+                } catch (IOException | CannotCompileException ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/Access.java b/src/cuchaz/enigma/analysis/Access.java
new file mode 100644
index 0000000..8d3409a
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/Access.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.lang.reflect.Modifier;
+
+import javassist.CtBehavior;
+import javassist.CtField;
+
+public enum Access {
+        
+        Public,
+        Protected,
+        Private;
+        
+        public static Access get(CtBehavior behavior) {
+                return get(behavior.getModifiers());
+        }
+        
+        public static Access get(CtField field) {
+                return get(field.getModifiers());
+        }
+        
+        public static Access get(int modifiers) {
+                if (Modifier.isPublic(modifiers)) {
+                        return Public;
+                } else if (Modifier.isProtected(modifiers)) {
+                        return Protected;
+                } else if (Modifier.isPrivate(modifiers)) {
+                        return Private;
+                }
+                // assume public by default
+                return Public;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java b/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java
new file mode 100644
index 0000000..9adac5e
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java
@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.Set;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreeNode;
+
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.Translator;
+
+public class BehaviorReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode<BehaviorEntry,BehaviorEntry> {
+        
+        private static final long serialVersionUID = -3658163700783307520L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private BehaviorEntry m_entry;
+        private EntryReference<BehaviorEntry,BehaviorEntry> m_reference;
+        private Access m_access;
+        
+        public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, BehaviorEntry entry) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+                m_reference = null;
+        }
+        
+        public BehaviorReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference<BehaviorEntry,BehaviorEntry> reference, Access access) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = reference.entry;
+                m_reference = reference;
+                m_access = access;
+        }
+        
+        @Override
+        public BehaviorEntry getEntry() {
+                return m_entry;
+        }
+        
+        @Override
+        public EntryReference<BehaviorEntry,BehaviorEntry> getReference() {
+                return m_reference;
+        }
+        
+        @Override
+        public String toString() {
+                if (m_reference != null) {
+                        return String.format("%s (%s)", m_deobfuscatingTranslator.translateEntry(m_reference.context), m_access);
+                }
+                return m_deobfuscatingTranslator.translateEntry(m_entry).toString();
+        }
+        
+        public void load(JarIndex index, boolean recurse) {
+                // get all the child nodes
+                for (EntryReference<BehaviorEntry,BehaviorEntry> reference : index.getBehaviorReferences(m_entry)) {
+                        add(new BehaviorReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_entry)));
+                }
+                
+                if (recurse && children != null) {
+                        for (Object child : children) {
+                                if (child instanceof BehaviorReferenceTreeNode) {
+                                        BehaviorReferenceTreeNode node = (BehaviorReferenceTreeNode)child;
+                                        
+                                        // don't recurse into ancestor
+                                        Set<Entry> ancestors = Sets.newHashSet();
+                                        TreeNode n = (TreeNode)node;
+                                        while (n.getParent() != null) {
+                                                n = n.getParent();
+                                                if (n instanceof BehaviorReferenceTreeNode) {
+                                                        ancestors.add( ((BehaviorReferenceTreeNode)n).getEntry());
+                                                }
+                                        }
+                                        if (ancestors.contains(node.getEntry())) {
+                                                continue;
+                                        }
+                                        
+                                        node.load(index, true);
+                                }
+                        }
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java b/src/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
new file mode 100644
index 0000000..49aac5f
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class ClassImplementationsTreeNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = 3112703459157851912L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private ClassEntry m_entry;
+        
+        public ClassImplementationsTreeNode(Translator deobfuscatingTranslator, ClassEntry entry) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+        }
+        
+        public ClassEntry getClassEntry() {
+                return m_entry;
+        }
+        
+        public String getDeobfClassName() {
+                return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        }
+        
+        @Override
+        public String toString() {
+                String className = getDeobfClassName();
+                if (className == null) {
+                        className = m_entry.getClassName();
+                }
+                return className;
+        }
+        
+        public void load(JarIndex index) {
+                // get all method implementations
+                List<ClassImplementationsTreeNode> nodes = Lists.newArrayList();
+                for (String implementingClassName : index.getImplementingClasses(m_entry.getClassName())) {
+                        nodes.add(new ClassImplementationsTreeNode(m_deobfuscatingTranslator, new ClassEntry(implementingClassName)));
+                }
+                
+                // add them to this node
+                for (ClassImplementationsTreeNode node : nodes) {
+                        this.add(node);
+                }
+        }
+        
+        public static ClassImplementationsTreeNode findNode(ClassImplementationsTreeNode node, MethodEntry entry) {
+                // is this the node?
+                if (node.m_entry.equals(entry)) {
+                        return node;
+                }
+                
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        ClassImplementationsTreeNode foundNode = findNode((ClassImplementationsTreeNode)node.getChildAt(i), entry);
+                        if (foundNode != null) {
+                                return foundNode;
+                        }
+                }
+                return null;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java b/src/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
new file mode 100644
index 0000000..3eaa391
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class ClassInheritanceTreeNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = 4432367405826178490L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private String m_obfClassName;
+        
+        public ClassInheritanceTreeNode(Translator deobfuscatingTranslator, String obfClassName) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_obfClassName = obfClassName;
+        }
+        
+        public String getObfClassName() {
+                return m_obfClassName;
+        }
+        
+        public String getDeobfClassName() {
+                return m_deobfuscatingTranslator.translateClass(m_obfClassName);
+        }
+        
+        @Override
+        public String toString() {
+                String deobfClassName = getDeobfClassName();
+                if (deobfClassName != null) {
+                        return deobfClassName;
+                }
+                return m_obfClassName;
+        }
+        
+        public void load(TranslationIndex ancestries, boolean recurse) {
+                // get all the child nodes
+                List<ClassInheritanceTreeNode> nodes = Lists.newArrayList();
+                for (ClassEntry subclassEntry : ancestries.getSubclass(new ClassEntry(m_obfClassName))) {
+                        nodes.add(new ClassInheritanceTreeNode(m_deobfuscatingTranslator, subclassEntry.getName()));
+                }
+                
+                // add them to this node
+                for (ClassInheritanceTreeNode node : nodes) {
+                        this.add(node);
+                }
+                
+                if (recurse) {
+                        for (ClassInheritanceTreeNode node : nodes) {
+                                node.load(ancestries, true);
+                        }
+                }
+        }
+        
+        public static ClassInheritanceTreeNode findNode(ClassInheritanceTreeNode node, ClassEntry entry) {
+                // is this the node?
+                if (node.getObfClassName().equals(entry.getName())) {
+                        return node;
+                }
+                
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        ClassInheritanceTreeNode foundNode = findNode((ClassInheritanceTreeNode)node.getChildAt(i), entry);
+                        if (foundNode != null) {
+                                return foundNode;
+                        }
+                }
+                return null;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/EntryReference.java b/src/cuchaz/enigma/analysis/EntryReference.java
new file mode 100644
index 0000000..bb611df
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/EntryReference.java
@@ -0,0 +1,126 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.Arrays;
+import java.util.List;
+
+import cuchaz.enigma.Util;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+
+public class EntryReference<E extends Entry,C extends Entry> {
+        
+        private static final List<String> ConstructorNonNames = Arrays.asList("this", "super", "static");
+        public E entry;
+        public C context;
+        
+        private boolean m_isNamed;
+        
+        public EntryReference(E entry, String sourceName) {
+                this(entry, sourceName, null);
+        }
+        
+        public EntryReference(E entry, String sourceName, C context) {
+                if (entry == null) {
+                        throw new IllegalArgumentException("Entry cannot be null!");
+                }
+                
+                this.entry = entry;
+                this.context = context;
+                
+                m_isNamed = sourceName != null && sourceName.length() > 0;
+                if (entry instanceof ConstructorEntry && ConstructorNonNames.contains(sourceName)) {
+                        m_isNamed = false;
+                }
+        }
+        
+        public EntryReference(E entry, C context, EntryReference<E,C> other) {
+                this.entry = entry;
+                this.context = context;
+                m_isNamed = other.m_isNamed;
+        }
+        
+        public ClassEntry getLocationClassEntry() {
+                if (context != null) {
+                        return context.getClassEntry();
+                }
+                return entry.getClassEntry();
+        }
+        
+        public boolean isNamed() {
+                return m_isNamed;
+        }
+        
+        public Entry getNameableEntry() {
+                if (entry instanceof ConstructorEntry) {
+                        // renaming a constructor really means renaming the class
+                        return entry.getClassEntry();
+                }
+                return entry;
+        }
+        
+        public String getNamableName() {
+                if (getNameableEntry() instanceof ClassEntry) {
+                        ClassEntry classEntry = (ClassEntry)getNameableEntry();
+                        if (classEntry.isInnerClass()) {
+                                // make sure we only rename the inner class name
+                                return classEntry.getInnerClassName();
+                        }
+                }
+                
+                return getNameableEntry().getName();
+        }
+        
+        @Override
+        public int hashCode() {
+                if (context != null) {
+                        return Util.combineHashesOrdered(entry.hashCode(), context.hashCode());
+                }
+                return entry.hashCode();
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof EntryReference) {
+                        return equals((EntryReference<?,?>)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(EntryReference<?,?> other) {
+                // check entry first
+                boolean isEntrySame = entry.equals(other.entry);
+                if (!isEntrySame) {
+                        return false;
+                }
+                
+                // check caller
+                if (context == null && other.context == null) {
+                        return true;
+                } else if (context != null && other.context != null) {
+                        return context.equals(other.context);
+                }
+                return false;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append(entry);
+                if (context != null) {
+                        buf.append(" called from ");
+                        buf.append(context);
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/EntryRenamer.java b/src/cuchaz/enigma/analysis/EntryRenamer.java
new file mode 100644
index 0000000..b54489c
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/EntryRenamer.java
@@ -0,0 +1,171 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.AbstractMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+
+public class EntryRenamer {
+        
+        public static <T> void renameClassesInSet(Map<String,String> renames, Set<T> set) {
+                List<T> entries = Lists.newArrayList();
+                for (T val : set) {
+                        entries.add(renameClassesInThing(renames, val));
+                }
+                set.clear();
+                set.addAll(entries);
+        }
+        
+        public static <Key,Val> void renameClassesInMap(Map<String,String> renames, Map<Key,Val> map) {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for (Map.Entry<Key,Val> entry : map.entrySet()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+                                renameClassesInThing(renames, entry.getKey()),
+                                renameClassesInThing(renames, entry.getValue())
+                        ));
+                }
+                map.clear();
+                for (Map.Entry<Key,Val> entry : entriesToAdd) {
+                        map.put(entry.getKey(), entry.getValue());
+                }
+        }
+        
+        public static <Key,Val> void renameClassesInMultimap(Map<String,String> renames, Multimap<Key,Val> map) {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for (Map.Entry<Key,Val> entry : map.entries()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+                                renameClassesInThing(renames, entry.getKey()),
+                                renameClassesInThing(renames, entry.getValue())
+                        ));
+                }
+                map.clear();
+                for (Map.Entry<Key,Val> entry : entriesToAdd) {
+                        map.put(entry.getKey(), entry.getValue());
+                }
+        }
+        
+        public static <Key,Val> void renameMethodsInMultimap(Map<MethodEntry,MethodEntry> renames, Multimap<Key,Val> map) {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for (Map.Entry<Key,Val> entry : map.entries()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+                                renameMethodsInThing(renames, entry.getKey()),
+                                renameMethodsInThing(renames, entry.getValue())
+                        ));
+                }
+                map.clear();
+                for (Map.Entry<Key,Val> entry : entriesToAdd) {
+                        map.put(entry.getKey(), entry.getValue());
+                }
+        }
+        
+        public static <Key,Val> void renameMethodsInMap(Map<MethodEntry,MethodEntry> renames, Map<Key,Val> map) {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for (Map.Entry<Key,Val> entry : map.entrySet()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+                                renameMethodsInThing(renames, entry.getKey()),
+                                renameMethodsInThing(renames, entry.getValue())
+                        ));
+                }
+                map.clear();
+                for (Map.Entry<Key,Val> entry : entriesToAdd) {
+                        map.put(entry.getKey(), entry.getValue());
+                }
+        }
+        
+        @SuppressWarnings("unchecked")
+        public static <T> T renameMethodsInThing(Map<MethodEntry,MethodEntry> renames, T thing) {
+                if (thing instanceof MethodEntry) {
+                        MethodEntry methodEntry = (MethodEntry)thing;
+                        MethodEntry newMethodEntry = renames.get(methodEntry);
+                        if (newMethodEntry != null) {
+                                return (T)new MethodEntry(
+                                        methodEntry.getClassEntry(),
+                                        newMethodEntry.getName(),
+                                        methodEntry.getSignature()
+                                );
+                        }
+                        return thing;
+                } else if (thing instanceof ArgumentEntry) {
+                        ArgumentEntry argumentEntry = (ArgumentEntry)thing;
+                        return (T)new ArgumentEntry(
+                                renameMethodsInThing(renames, argumentEntry.getBehaviorEntry()),
+                                argumentEntry.getIndex(),
+                                argumentEntry.getName()
+                        );
+                } else if (thing instanceof EntryReference) {
+                        EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
+                        reference.entry = renameMethodsInThing(renames, reference.entry);
+                        reference.context = renameMethodsInThing(renames, reference.context);
+                        return thing;
+                }
+                return thing;
+        }
+        
+        @SuppressWarnings("unchecked")
+        public static <T> T renameClassesInThing(Map<String,String> renames, T thing) {
+                if (thing instanceof String) {
+                        String stringEntry = (String)thing;
+                        if (renames.containsKey(stringEntry)) {
+                                return (T)renames.get(stringEntry);
+                        }
+                } else if (thing instanceof ClassEntry) {
+                        ClassEntry classEntry = (ClassEntry)thing;
+                        return (T)new ClassEntry(renameClassesInThing(renames, classEntry.getClassName()));
+                } else if (thing instanceof FieldEntry) {
+                        FieldEntry fieldEntry = (FieldEntry)thing;
+                        return (T)new FieldEntry(renameClassesInThing(renames, fieldEntry.getClassEntry()), fieldEntry.getName());
+                } else if (thing instanceof ConstructorEntry) {
+                        ConstructorEntry constructorEntry = (ConstructorEntry)thing;
+                        return (T)new ConstructorEntry(
+                                renameClassesInThing(renames, constructorEntry.getClassEntry()),
+                                constructorEntry.getSignature()
+                        );
+                } else if (thing instanceof MethodEntry) {
+                        MethodEntry methodEntry = (MethodEntry)thing;
+                        return (T)new MethodEntry(
+                                renameClassesInThing(renames, methodEntry.getClassEntry()),
+                                methodEntry.getName(),
+                                methodEntry.getSignature()
+                        );
+                } else if (thing instanceof ArgumentEntry) {
+                        ArgumentEntry argumentEntry = (ArgumentEntry)thing;
+                        return (T)new ArgumentEntry(
+                                renameClassesInThing(renames, argumentEntry.getBehaviorEntry()),
+                                argumentEntry.getIndex(),
+                                argumentEntry.getName()
+                        );
+                } else if (thing instanceof EntryReference) {
+                        EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
+                        reference.entry = renameClassesInThing(renames, reference.entry);
+                        reference.context = renameClassesInThing(renames, reference.context);
+                        return thing;
+                }
+                
+                return thing;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java b/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
new file mode 100644
index 0000000..2173eea
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class FieldReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode<FieldEntry,BehaviorEntry> {
+        
+        private static final long serialVersionUID = -7934108091928699835L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private FieldEntry m_entry;
+        private EntryReference<FieldEntry,BehaviorEntry> m_reference;
+        private Access m_access;
+        
+        public FieldReferenceTreeNode(Translator deobfuscatingTranslator, FieldEntry entry) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+                m_reference = null;
+        }
+        
+        private FieldReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference<FieldEntry,BehaviorEntry> reference, Access access) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = reference.entry;
+                m_reference = reference;
+                m_access = access;
+        }
+        
+        @Override
+        public FieldEntry getEntry() {
+                return m_entry;
+        }
+        
+        @Override
+        public EntryReference<FieldEntry,BehaviorEntry> getReference() {
+                return m_reference;
+        }
+        
+        @Override
+        public String toString() {
+                if (m_reference != null) {
+                        return String.format("%s (%s)", m_deobfuscatingTranslator.translateEntry(m_reference.context), m_access);
+                }
+                return m_deobfuscatingTranslator.translateEntry(m_entry).toString();
+        }
+        
+        public void load(JarIndex index, boolean recurse) {
+                // get all the child nodes
+                if (m_reference == null) {
+                        for (EntryReference<FieldEntry,BehaviorEntry> reference : index.getFieldReferences(m_entry)) {
+                                add(new FieldReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_entry)));
+                        }
+                } else {
+                        for (EntryReference<BehaviorEntry,BehaviorEntry> reference : index.getBehaviorReferences(m_reference.context)) {
+                                add(new BehaviorReferenceTreeNode(m_deobfuscatingTranslator, reference, index.getAccess(m_reference.context)));
+                        }
+                }
+                
+                if (recurse && children != null) {
+                        for (Object node : children) {
+                                if (node instanceof BehaviorReferenceTreeNode) {
+                                        ((BehaviorReferenceTreeNode)node).load(index, true);
+                                } else if (node instanceof FieldReferenceTreeNode) {
+                                        ((FieldReferenceTreeNode)node).load(index, true);
+                                }
+                        }
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/JarClassIterator.java b/src/cuchaz/enigma/analysis/JarClassIterator.java
new file mode 100644
index 0000000..72a9912
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/JarClassIterator.java
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import javassist.ByteArrayClassPath;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+import javassist.bytecode.Descriptor;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class JarClassIterator implements Iterator<CtClass> {
+        
+        private JarFile m_jar;
+        private Iterator<JarEntry> m_iter;
+        
+        public JarClassIterator(JarFile jar) {
+                m_jar = jar;
+                
+                // get the jar entries that correspond to classes
+                List<JarEntry> classEntries = Lists.newArrayList();
+                Enumeration<JarEntry> entries = m_jar.entries();
+                while (entries.hasMoreElements()) {
+                        JarEntry entry = entries.nextElement();
+                        
+                        // is this a class file?
+                        if (entry.getName().endsWith(".class")) {
+                                classEntries.add(entry);
+                        }
+                }
+                m_iter = classEntries.iterator();
+        }
+        
+        @Override
+        public boolean hasNext() {
+                return m_iter.hasNext();
+        }
+        
+        @Override
+        public CtClass next() {
+                JarEntry entry = m_iter.next();
+                try {
+                        return getClass(m_jar, entry);
+                } catch (IOException | NotFoundException ex) {
+                        throw new Error("Unable to load class: " + entry.getName());
+                }
+        }
+        
+        @Override
+        public void remove() {
+                throw new UnsupportedOperationException();
+        }
+        
+        public static List<ClassEntry> getClassEntries(JarFile jar) {
+                List<ClassEntry> classEntries = Lists.newArrayList();
+                Enumeration<JarEntry> entries = jar.entries();
+                while (entries.hasMoreElements()) {
+                        JarEntry entry = entries.nextElement();
+                        
+                        // is this a class file?
+                        if (!entry.isDirectory() && entry.getName().endsWith(".class")) {
+                                classEntries.add(getClassEntry(entry));
+                        }
+                }
+                return classEntries;
+        }
+        
+        public static Iterable<CtClass> classes(final JarFile jar) {
+                return new Iterable<CtClass>() {
+                        @Override
+                        public Iterator<CtClass> iterator() {
+                                return new JarClassIterator(jar);
+                        }
+                };
+        }
+        
+        public static CtClass getClass(JarFile jar, ClassEntry classEntry) {
+                try {
+                        return getClass(jar, new JarEntry(classEntry.getName() + ".class"));
+                } catch (IOException | NotFoundException ex) {
+                        throw new Error("Unable to load class: " + classEntry.getName());
+                }
+        }
+        
+        private static CtClass getClass(JarFile jar, JarEntry entry) throws IOException, NotFoundException {
+                // read the class into a buffer
+                ByteArrayOutputStream bos = new ByteArrayOutputStream();
+                byte[] buf = new byte[Constants.KiB];
+                int totalNumBytesRead = 0;
+                InputStream in = jar.getInputStream(entry);
+                while (in.available() > 0) {
+                        int numBytesRead = in.read(buf);
+                        if (numBytesRead < 0) {
+                                break;
+                        }
+                        bos.write(buf, 0, numBytesRead);
+                        
+                        // sanity checking
+                        totalNumBytesRead += numBytesRead;
+                        if (totalNumBytesRead > Constants.MiB) {
+                                throw new Error("Class file " + entry.getName() + " larger than 1 MiB! Something is wrong!");
+                        }
+                }
+                
+                // get a javassist handle for the class
+                String className = Descriptor.toJavaName(getClassEntry(entry).getName());
+                ClassPool classPool = new ClassPool();
+                classPool.appendSystemPath();
+                classPool.insertClassPath(new ByteArrayClassPath(className, bos.toByteArray()));
+                return classPool.get(className);
+        }
+        
+        private static ClassEntry getClassEntry(JarEntry entry) {
+                return new ClassEntry(entry.getName().substring(0, entry.getName().length() - ".class".length()));
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java
new file mode 100644
index 0000000..3aac8bd
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/JarIndex.java
@@ -0,0 +1,734 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.lang.reflect.Modifier;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.jar.JarFile;
+
+import javassist.CannotCompileException;
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtField;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.FieldInfo;
+import javassist.expr.ConstructorCall;
+import javassist.expr.ExprEditor;
+import javassist.expr.FieldAccess;
+import javassist.expr.MethodCall;
+import javassist.expr.NewExpr;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.bytecode.ClassRenamer;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class JarIndex {
+        
+        private Set<ClassEntry> m_obfClassEntries;
+        private TranslationIndex m_translationIndex;
+        private Multimap<String,String> m_interfaces;
+        private Map<Entry,Access> m_access;
+        private Map<FieldEntry,ClassEntry> m_fieldClasses; // TODO: this will become obsolete!
+        private Multimap<String,MethodEntry> m_methodImplementations;
+        private Multimap<BehaviorEntry,EntryReference<BehaviorEntry,BehaviorEntry>> m_behaviorReferences;
+        private Multimap<FieldEntry,EntryReference<FieldEntry,BehaviorEntry>> m_fieldReferences;
+        private Multimap<String,String> m_innerClasses;
+        private Map<String,String> m_outerClasses;
+        private Map<String,BehaviorEntry> m_anonymousClasses;
+        
+        public JarIndex() {
+                m_obfClassEntries = Sets.newHashSet();
+                m_translationIndex = new TranslationIndex();
+                m_interfaces = HashMultimap.create();
+                m_access = Maps.newHashMap();
+                m_fieldClasses = Maps.newHashMap();
+                m_methodImplementations = HashMultimap.create();
+                m_behaviorReferences = HashMultimap.create();
+                m_fieldReferences = HashMultimap.create();
+                m_innerClasses = HashMultimap.create();
+                m_outerClasses = Maps.newHashMap();
+                m_anonymousClasses = Maps.newHashMap();
+        }
+        
+        public void indexJar(JarFile jar, boolean buildInnerClasses) {
+                
+                // step 1: read the class names
+                for (ClassEntry classEntry : JarClassIterator.getClassEntries(jar)) {
+                        if (classEntry.isInDefaultPackage()) {
+                                // move out of default package
+                                classEntry = new ClassEntry(Constants.NonePackage + "/" + classEntry.getName());
+                        }
+                        m_obfClassEntries.add(classEntry);
+                }
+                
+                // step 2: index field/method/constructor access
+                for (CtClass c : JarClassIterator.classes(jar)) {
+                        ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                        for (CtField field : c.getDeclaredFields()) {
+                                m_access.put(JavassistUtil.getFieldEntry(field), Access.get(field));
+                        }
+                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                m_access.put(JavassistUtil.getBehaviorEntry(behavior), Access.get(behavior));
+                        }
+                }
+                
+                // step 3: index extends, implements, fields, and methods
+                for (CtClass c : JarClassIterator.classes(jar)) {
+                        ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                        m_translationIndex.indexClass(c);
+                        String className = Descriptor.toJvmName(c.getName());
+                        for (String interfaceName : c.getClassFile().getInterfaces()) {
+                                className = Descriptor.toJvmName(className);
+                                interfaceName = Descriptor.toJvmName(interfaceName);
+                                if (className.equals(interfaceName)) {
+                                        throw new IllegalArgumentException("Class cannot be its own interface! " + className);
+                                }
+                                m_interfaces.put(className, interfaceName);
+                        }
+                        for (CtField field : c.getDeclaredFields()) {
+                                indexField(field);
+                        }
+                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                indexBehavior(behavior);
+                        }
+                }
+                
+                // step 4: index field, method, constructor references
+                for (CtClass c : JarClassIterator.classes(jar)) {
+                        ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                indexBehaviorReferences(behavior);
+                        }
+                }
+                
+                if (buildInnerClasses) {
+                        // step 5: index inner classes and anonymous classes
+                        for (CtClass c : JarClassIterator.classes(jar)) {
+                                ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NonePackage);
+                                String outerClassName = findOuterClass(c);
+                                if (outerClassName != null) {
+                                        String innerClassName = c.getSimpleName();
+                                        m_innerClasses.put(outerClassName, innerClassName);
+                                        boolean innerWasAdded = m_outerClasses.put(innerClassName, outerClassName) == null;
+                                        assert (innerWasAdded);
+                                        
+                                        BehaviorEntry enclosingBehavior = isAnonymousClass(c, outerClassName);
+                                        if (enclosingBehavior != null) {
+                                                m_anonymousClasses.put(innerClassName, enclosingBehavior);
+                                                
+                                                // DEBUG
+                                                // System.out.println( "ANONYMOUS: " + outerClassName + "$" + innerClassName );
+                                        } else {
+                                                // DEBUG
+                                                // System.out.println( "INNER: " + outerClassName + "$" + innerClassName );
+                                        }
+                                }
+                        }
+                        
+                        // step 6: update other indices with inner class info
+                        Map<String,String> renames = Maps.newHashMap();
+                        for (Map.Entry<String,String> entry : m_outerClasses.entrySet()) {
+                                renames.put(Constants.NonePackage + "/" + entry.getKey(), entry.getValue() + "$" + entry.getKey());
+                        }
+                        EntryRenamer.renameClassesInSet(renames, m_obfClassEntries);
+                        m_translationIndex.renameClasses(renames);
+                        EntryRenamer.renameClassesInMultimap(renames, m_interfaces);
+                        EntryRenamer.renameClassesInMultimap(renames, m_methodImplementations);
+                        EntryRenamer.renameClassesInMultimap(renames, m_behaviorReferences);
+                        EntryRenamer.renameClassesInMultimap(renames, m_fieldReferences);
+                        EntryRenamer.renameClassesInMap(renames, m_access);
+                }
+        }
+        
+        private void indexField(CtField field) {
+                // get the field entry
+                String className = Descriptor.toJvmName(field.getDeclaringClass().getName());
+                FieldEntry fieldEntry = new FieldEntry(new ClassEntry(className), field.getName());
+                
+                // is the field a class type?
+                if (field.getSignature().startsWith("L")) {
+                        ClassEntry fieldTypeEntry = new ClassEntry(field.getSignature().substring(1, field.getSignature().length() - 1));
+                        m_fieldClasses.put(fieldEntry, fieldTypeEntry);
+                }
+        }
+        
+        private void indexBehavior(CtBehavior behavior) {
+                // get the behavior entry
+                final BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(behavior);
+                if (behaviorEntry instanceof MethodEntry) {
+                        MethodEntry methodEntry = (MethodEntry)behaviorEntry;
+                        
+                        // index implementation
+                        m_methodImplementations.put(behaviorEntry.getClassName(), methodEntry);
+                }
+                // looks like we don't care about constructors here
+        }
+        
+        private void indexBehaviorReferences(CtBehavior behavior) {
+                // index method calls
+                final BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(behavior);
+                try {
+                        behavior.instrument(new ExprEditor() {
+                                @Override
+                                public void edit(MethodCall call) {
+                                        MethodEntry calledMethodEntry = JavassistUtil.getMethodEntry(call);
+                                        ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledMethodEntry);
+                                        if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledMethodEntry.getClassEntry())) {
+                                                calledMethodEntry = new MethodEntry(
+                                                        resolvedClassEntry,
+                                                        calledMethodEntry.getName(),
+                                                        calledMethodEntry.getSignature()
+                                                );
+                                        }
+                                        EntryReference<BehaviorEntry,BehaviorEntry> reference = new EntryReference<BehaviorEntry,BehaviorEntry>(
+                                                calledMethodEntry,
+                                                call.getMethodName(),
+                                                behaviorEntry
+                                        );
+                                        m_behaviorReferences.put(calledMethodEntry, reference);
+                                }
+                                
+                                @Override
+                                public void edit(FieldAccess call) {
+                                        FieldEntry calledFieldEntry = JavassistUtil.getFieldEntry(call);
+                                        ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledFieldEntry);
+                                        if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledFieldEntry.getClassEntry())) {
+                                                calledFieldEntry = new FieldEntry(resolvedClassEntry, call.getFieldName());
+                                        }
+                                        EntryReference<FieldEntry,BehaviorEntry> reference = new EntryReference<FieldEntry,BehaviorEntry>(
+                                                calledFieldEntry,
+                                                call.getFieldName(),
+                                                behaviorEntry
+                                        );
+                                        m_fieldReferences.put(calledFieldEntry, reference);
+                                }
+                                
+                                @Override
+                                public void edit(ConstructorCall call) {
+                                        ConstructorEntry calledConstructorEntry = JavassistUtil.getConstructorEntry(call);
+                                        EntryReference<BehaviorEntry,BehaviorEntry> reference = new EntryReference<BehaviorEntry,BehaviorEntry>(
+                                                calledConstructorEntry,
+                                                call.getMethodName(),
+                                                behaviorEntry
+                                        );
+                                        m_behaviorReferences.put(calledConstructorEntry, reference);
+                                }
+                                
+                                @Override
+                                public void edit(NewExpr call) {
+                                        ConstructorEntry calledConstructorEntry = JavassistUtil.getConstructorEntry(call);
+                                        EntryReference<BehaviorEntry,BehaviorEntry> reference = new EntryReference<BehaviorEntry,BehaviorEntry>(
+                                                calledConstructorEntry,
+                                                call.getClassName(),
+                                                behaviorEntry
+                                        );
+                                        m_behaviorReferences.put(calledConstructorEntry, reference);
+                                }
+                        });
+                } catch (CannotCompileException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private String findOuterClass(CtClass c) {
+                
+                // inner classes:
+                // have constructors that can (illegally) set synthetic fields
+                // the outer class is the only class that calls constructors
+                
+                // use the synthetic fields to find the synthetic constructors
+                for (CtConstructor constructor : c.getDeclaredConstructors()) {
+                        Set<String> syntheticFieldTypes = Sets.newHashSet();
+                        if (!isIllegalConstructor(syntheticFieldTypes, constructor)) {
+                                continue;
+                        }
+                        
+                        ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                        ConstructorEntry constructorEntry = JavassistUtil.getConstructorEntry(constructor);
+                        
+                        // gather the classes from the illegally-set synthetic fields
+                        Set<ClassEntry> illegallySetClasses = Sets.newHashSet();
+                        for (String type : syntheticFieldTypes) {
+                                if (type.startsWith("L")) {
+                                        ClassEntry outerClassEntry = new ClassEntry(type.substring(1, type.length() - 1));
+                                        if (isSaneOuterClass(outerClassEntry, classEntry)) {
+                                                illegallySetClasses.add(outerClassEntry);
+                                        }
+                                }
+                        }
+                        
+                        // who calls this constructor?
+                        Set<ClassEntry> callerClasses = Sets.newHashSet();
+                        for (EntryReference<BehaviorEntry,BehaviorEntry> reference : getBehaviorReferences(constructorEntry)) {
+                                
+                                // make sure it's not a call to super
+                                if (reference.entry instanceof ConstructorEntry && reference.context instanceof ConstructorEntry) {
+                                        
+                                        // is the entry a superclass of the context?
+                                        ClassEntry calledClassEntry = reference.entry.getClassEntry();
+                                        ClassEntry superclassEntry = m_translationIndex.getSuperclass(reference.context.getClassEntry());
+                                        if (superclassEntry != null && superclassEntry.equals(calledClassEntry)) {
+                                                // it's a super call, skip
+                                                continue;
+                                        }
+                                }
+                                
+                                if (isSaneOuterClass(reference.context.getClassEntry(), classEntry)) {
+                                        callerClasses.add(reference.context.getClassEntry());
+                                }
+                        }
+                        
+                        // do we have an answer yet?
+                        if (callerClasses.isEmpty()) {
+                                if (illegallySetClasses.size() == 1) {
+                                        return illegallySetClasses.iterator().next().getName();
+                                } else {
+                                        System.out.println(String.format("WARNING: Unable to find outer class for %s. No caller and no illegally set field classes.", classEntry));
+                                }
+                        } else {
+                                if (callerClasses.size() == 1) {
+                                        return callerClasses.iterator().next().getName();
+                                } else {
+                                        // multiple callers, do the illegally set classes narrow it down?
+                                        Set<ClassEntry> intersection = Sets.newHashSet(callerClasses);
+                                        intersection.retainAll(illegallySetClasses);
+                                        if (intersection.size() == 1) {
+                                                return intersection.iterator().next().getName();
+                                        } else {
+                                                System.out.println(String.format("WARNING: Unable to choose outer class for %s among options: %s", classEntry, callerClasses));
+                                        }
+                                }
+                        }
+                }
+                
+                return null;
+        }
+        
+        private boolean isSaneOuterClass(ClassEntry outerClassEntry, ClassEntry innerClassEntry) {
+                
+                // clearly this would be silly
+                if (outerClassEntry.equals(innerClassEntry)) {
+                        return false;
+                }
+                
+                // is the outer class in the jar?
+                if (!m_obfClassEntries.contains(outerClassEntry)) {
+                        return false;
+                }
+                
+                return true;
+        }
+        
+        @SuppressWarnings("unchecked")
+        private boolean isIllegalConstructor(Set<String> syntheticFieldTypes, CtConstructor constructor) {
+                
+                // illegal constructors only set synthetic member fields, then call super()
+                String className = constructor.getDeclaringClass().getName();
+                
+                // collect all the field accesses, constructor calls, and method calls
+                final List<FieldAccess> illegalFieldWrites = Lists.newArrayList();
+                final List<ConstructorCall> constructorCalls = Lists.newArrayList();
+                try {
+                        constructor.instrument(new ExprEditor() {
+                                @Override
+                                public void edit(FieldAccess fieldAccess) {
+                                        if (fieldAccess.isWriter() && constructorCalls.isEmpty()) {
+                                                illegalFieldWrites.add(fieldAccess);
+                                        }
+                                }
+                                
+                                @Override
+                                public void edit(ConstructorCall constructorCall) {
+                                        constructorCalls.add(constructorCall);
+                                }
+                        });
+                } catch (CannotCompileException ex) {
+                        // we're not compiling anything... this is stupid
+                        throw new Error(ex);
+                }
+                
+                // are there any illegal field writes?
+                if (illegalFieldWrites.isEmpty()) {
+                        return false;
+                }
+                
+                // are all the writes to synthetic fields?
+                for (FieldAccess fieldWrite : illegalFieldWrites) {
+                        
+                        // all illegal writes have to be to the local class
+                        if (!fieldWrite.getClassName().equals(className)) {
+                                System.err.println(String.format("WARNING: illegal write to non-member field %s.%s", fieldWrite.getClassName(), fieldWrite.getFieldName()));
+                                return false;
+                        }
+                        
+                        // find the field
+                        FieldInfo fieldInfo = null;
+                        for (FieldInfo info : (List<FieldInfo>)constructor.getDeclaringClass().getClassFile().getFields()) {
+                                if (info.getName().equals(fieldWrite.getFieldName()) && info.getDescriptor().equals(fieldWrite.getSignature())) {
+                                        fieldInfo = info;
+                                        break;
+                                }
+                        }
+                        if (fieldInfo == null) {
+                                // field is in a superclass or something, can't be a local synthetic member
+                                return false;
+                        }
+                        
+                        // is this field synthetic?
+                        boolean isSynthetic = (fieldInfo.getAccessFlags() & AccessFlag.SYNTHETIC) != 0;
+                        if (isSynthetic) {
+                                syntheticFieldTypes.add(fieldInfo.getDescriptor());
+                        } else {
+                                System.err.println(String.format("WARNING: illegal write to non synthetic field %s %s.%s", fieldInfo.getDescriptor(), className, fieldInfo.getName()));
+                                return false;
+                        }
+                }
+                
+                // we passed all the tests!
+                return true;
+        }
+        
+        private BehaviorEntry isAnonymousClass(CtClass c, String outerClassName) {
+                
+                ClassEntry innerClassEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                
+                // anonymous classes:
+                // can't be abstract
+                // have only one constructor
+                // it's called exactly once by the outer class
+                // the type the instance is assigned to can't be this type
+                
+                // is abstract?
+                if (Modifier.isAbstract(c.getModifiers())) {
+                        return null;
+                }
+                
+                // is there exactly one constructor?
+                if (c.getDeclaredConstructors().length != 1) {
+                        return null;
+                }
+                CtConstructor constructor = c.getDeclaredConstructors()[0];
+                
+                // is this constructor called exactly once?
+                ConstructorEntry constructorEntry = JavassistUtil.getConstructorEntry(constructor);
+                Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references = getBehaviorReferences(constructorEntry);
+                if (references.size() != 1) {
+                        return null;
+                }
+                
+                // does the caller use this type?
+                BehaviorEntry caller = references.iterator().next().context;
+                for (FieldEntry fieldEntry : getReferencedFields(caller)) {
+                        ClassEntry fieldClass = getFieldClass(fieldEntry);
+                        if (fieldClass != null && fieldClass.equals(innerClassEntry)) {
+                                // caller references this type, so it can't be anonymous
+                                return null;
+                        }
+                }
+                for (BehaviorEntry behaviorEntry : getReferencedBehaviors(caller)) {
+                        if (behaviorEntry.getSignature().hasClass(innerClassEntry)) {
+                                return null;
+                        }
+                }
+                
+                return caller;
+        }
+        
+        public Set<ClassEntry> getObfClassEntries() {
+                return m_obfClassEntries;
+        }
+        
+        public TranslationIndex getTranslationIndex() {
+                return m_translationIndex;
+        }
+        
+        public Access getAccess(Entry entry) {
+                return m_access.get(entry);
+        }
+        
+        public ClassEntry getFieldClass(FieldEntry fieldEntry) {
+                return m_fieldClasses.get(fieldEntry);
+        }
+        
+        public ClassInheritanceTreeNode getClassInheritance(Translator deobfuscatingTranslator, ClassEntry obfClassEntry) {
+                
+                // get the root node
+                List<String> ancestry = Lists.newArrayList();
+                ancestry.add(obfClassEntry.getName());
+                for (ClassEntry classEntry : m_translationIndex.getAncestry(obfClassEntry)) {
+                        ancestry.add(classEntry.getName());
+                }
+                ClassInheritanceTreeNode rootNode = new ClassInheritanceTreeNode(
+                        deobfuscatingTranslator,
+                        ancestry.get(ancestry.size() - 1)
+                );
+                
+                // expand all children recursively
+                rootNode.load(m_translationIndex, true);
+                
+                return rootNode;
+        }
+        
+        public ClassImplementationsTreeNode getClassImplementations(Translator deobfuscatingTranslator, ClassEntry obfClassEntry) {
+                
+                // is this even an interface?
+                if (isInterface(obfClassEntry.getClassName())) {
+                        ClassImplementationsTreeNode node = new ClassImplementationsTreeNode(deobfuscatingTranslator, obfClassEntry);
+                        node.load(this);
+                        return node;
+                }
+                return null;
+        }
+        
+        public MethodInheritanceTreeNode getMethodInheritance(Translator deobfuscatingTranslator, MethodEntry obfMethodEntry) {
+                
+                // travel to the ancestor implementation
+                ClassEntry baseImplementationClassEntry = obfMethodEntry.getClassEntry();
+                for (ClassEntry ancestorClassEntry : m_translationIndex.getAncestry(obfMethodEntry.getClassEntry())) {
+                        MethodEntry ancestorMethodEntry = new MethodEntry(
+                                new ClassEntry(ancestorClassEntry),
+                                obfMethodEntry.getName(),
+                                obfMethodEntry.getSignature()
+                        );
+                        if (containsObfBehavior(ancestorMethodEntry)) {
+                                baseImplementationClassEntry = ancestorClassEntry;
+                        }
+                }
+                
+                // make a root node at the base
+                MethodEntry methodEntry = new MethodEntry(
+                        baseImplementationClassEntry,
+                        obfMethodEntry.getName(),
+                        obfMethodEntry.getSignature()
+                );
+                MethodInheritanceTreeNode rootNode = new MethodInheritanceTreeNode(
+                        deobfuscatingTranslator,
+                        methodEntry,
+                        containsObfBehavior(methodEntry)
+                );
+                
+                // expand the full tree
+                rootNode.load(this, true);
+                
+                return rootNode;
+        }
+        
+        public MethodImplementationsTreeNode getMethodImplementations(Translator deobfuscatingTranslator, MethodEntry obfMethodEntry) {
+                
+                MethodEntry interfaceMethodEntry;
+                
+                // is this method on an interface?
+                if (isInterface(obfMethodEntry.getClassName())) {
+                        interfaceMethodEntry = obfMethodEntry;
+                } else {
+                        // get the interface class
+                        List<MethodEntry> methodInterfaces = Lists.newArrayList();
+                        for (String interfaceName : getInterfaces(obfMethodEntry.getClassName())) {
+                                // is this method defined in this interface?
+                                MethodEntry methodInterface = new MethodEntry(
+                                        new ClassEntry(interfaceName),
+                                        obfMethodEntry.getName(),
+                                        obfMethodEntry.getSignature()
+                                );
+                                if (containsObfBehavior(methodInterface)) {
+                                        methodInterfaces.add(methodInterface);
+                                }
+                        }
+                        if (methodInterfaces.isEmpty()) {
+                                return null;
+                        }
+                        if (methodInterfaces.size() > 1) {
+                                throw new Error("Too many interfaces define this method! This is not yet supported by Enigma!");
+                        }
+                        interfaceMethodEntry = methodInterfaces.get(0);
+                }
+                
+                MethodImplementationsTreeNode rootNode = new MethodImplementationsTreeNode(deobfuscatingTranslator, interfaceMethodEntry);
+                rootNode.load(this);
+                return rootNode;
+        }
+        
+        public Set<MethodEntry> getRelatedMethodImplementations(MethodEntry obfMethodEntry) {
+                Set<MethodEntry> methodEntries = Sets.newHashSet();
+                getRelatedMethodImplementations(methodEntries, getMethodInheritance(null, obfMethodEntry));
+                return methodEntries;
+        }
+        
+        private void getRelatedMethodImplementations(Set<MethodEntry> methodEntries, MethodInheritanceTreeNode node) {
+                MethodEntry methodEntry = node.getMethodEntry();
+                if (containsObfBehavior(methodEntry)) {
+                        // collect the entry
+                        methodEntries.add(methodEntry);
+                }
+                
+                // look at interface methods too
+                MethodImplementationsTreeNode implementations = getMethodImplementations(null, methodEntry);
+                if (implementations != null) {
+                        getRelatedMethodImplementations(methodEntries, implementations);
+                }
+                
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        getRelatedMethodImplementations(methodEntries, (MethodInheritanceTreeNode)node.getChildAt(i));
+                }
+        }
+        
+        private void getRelatedMethodImplementations(Set<MethodEntry> methodEntries, MethodImplementationsTreeNode node) {
+                MethodEntry methodEntry = node.getMethodEntry();
+                if (containsObfBehavior(methodEntry)) {
+                        // collect the entry
+                        methodEntries.add(methodEntry);
+                }
+                
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        getRelatedMethodImplementations(methodEntries, (MethodImplementationsTreeNode)node.getChildAt(i));
+                }
+        }
+        
+        public Collection<EntryReference<FieldEntry,BehaviorEntry>> getFieldReferences(FieldEntry fieldEntry) {
+                return m_fieldReferences.get(fieldEntry);
+        }
+        
+        public Collection<FieldEntry> getReferencedFields(BehaviorEntry behaviorEntry) {
+                // linear search is fast enough for now
+                Set<FieldEntry> fieldEntries = Sets.newHashSet();
+                for (EntryReference<FieldEntry,BehaviorEntry> reference : m_fieldReferences.values()) {
+                        if (reference.context == behaviorEntry) {
+                                fieldEntries.add(reference.entry);
+                        }
+                }
+                return fieldEntries;
+        }
+        
+        public Collection<EntryReference<BehaviorEntry,BehaviorEntry>> getBehaviorReferences(BehaviorEntry behaviorEntry) {
+                return m_behaviorReferences.get(behaviorEntry);
+        }
+        
+        public Collection<BehaviorEntry> getReferencedBehaviors(BehaviorEntry behaviorEntry) {
+                // linear search is fast enough for now
+                Set<BehaviorEntry> behaviorEntries = Sets.newHashSet();
+                for (EntryReference<BehaviorEntry,BehaviorEntry> reference : m_behaviorReferences.values()) {
+                        if (reference.context == behaviorEntry) {
+                                behaviorEntries.add(reference.entry);
+                        }
+                }
+                return behaviorEntries;
+        }
+        
+        public Collection<String> getInnerClasses(String obfOuterClassName) {
+                return m_innerClasses.get(obfOuterClassName);
+        }
+        
+        public String getOuterClass(String obfInnerClassName) {
+                // make sure we use the right name
+                if (new ClassEntry(obfInnerClassName).getPackageName() != null) {
+                        throw new IllegalArgumentException("Don't reference obfuscated inner classes using packages: " + obfInnerClassName);
+                }
+                return m_outerClasses.get(obfInnerClassName);
+        }
+        
+        public boolean isAnonymousClass(String obfInnerClassName) {
+                return m_anonymousClasses.containsKey(obfInnerClassName);
+        }
+        
+        public BehaviorEntry getAnonymousClassCaller(String obfInnerClassName) {
+                return m_anonymousClasses.get(obfInnerClassName);
+        }
+        
+        public Set<String> getInterfaces(String className) {
+                Set<String> interfaceNames = new HashSet<String>();
+                interfaceNames.addAll(m_interfaces.get(className));
+                for (ClassEntry ancestor : m_translationIndex.getAncestry(new ClassEntry(className))) {
+                        interfaceNames.addAll(m_interfaces.get(ancestor.getName()));
+                }
+                return interfaceNames;
+        }
+        
+        public Set<String> getImplementingClasses(String targetInterfaceName) {
+                // linear search is fast enough for now
+                Set<String> classNames = Sets.newHashSet();
+                for (Map.Entry<String,String> entry : m_interfaces.entries()) {
+                        String className = entry.getKey();
+                        String interfaceName = entry.getValue();
+                        if (interfaceName.equals(targetInterfaceName)) {
+                                classNames.add(className);
+                                m_translationIndex.getSubclassNamesRecursively(classNames, new ClassEntry(className));
+                        }
+                }
+                return classNames;
+        }
+        
+        public boolean isInterface(String className) {
+                return m_interfaces.containsValue(className);
+        }
+        
+        public boolean containsObfClass(ClassEntry obfClassEntry) {
+                return m_obfClassEntries.contains(obfClassEntry);
+        }
+        
+        public boolean containsObfField(FieldEntry obfFieldEntry) {
+                return m_access.containsKey(obfFieldEntry);
+        }
+        
+        public boolean containsObfBehavior(BehaviorEntry obfBehaviorEntry) {
+                return m_access.containsKey(obfBehaviorEntry);
+        }
+        
+        public boolean containsObfArgument(ArgumentEntry obfArgumentEntry) {
+                // check the behavior
+                if (!containsObfBehavior(obfArgumentEntry.getBehaviorEntry())) {
+                        return false;
+                }
+                
+                // check the argument
+                if (obfArgumentEntry.getIndex() >= obfArgumentEntry.getBehaviorEntry().getSignature().getArgumentTypes().size()) {
+                        return false;
+                }
+                
+                return true;
+        }
+        
+        public boolean containsObfEntry(Entry obfEntry) {
+                if (obfEntry instanceof ClassEntry) {
+                        return containsObfClass((ClassEntry)obfEntry);
+                } else if (obfEntry instanceof FieldEntry) {
+                        return containsObfField((FieldEntry)obfEntry);
+                } else if (obfEntry instanceof BehaviorEntry) {
+                        return containsObfBehavior((BehaviorEntry)obfEntry);
+                } else if (obfEntry instanceof ArgumentEntry) {
+                        return containsObfArgument((ArgumentEntry)obfEntry);
+                } else {
+                        throw new Error("Entry type not supported: " + obfEntry.getClass().getName());
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java b/src/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
new file mode 100644
index 0000000..1009226
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class MethodImplementationsTreeNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = 3781080657461899915L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private MethodEntry m_entry;
+        
+        public MethodImplementationsTreeNode(Translator deobfuscatingTranslator, MethodEntry entry) {
+                if (entry == null) {
+                        throw new IllegalArgumentException("entry cannot be null!");
+                }
+                
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+        }
+        
+        public MethodEntry getMethodEntry() {
+                return m_entry;
+        }
+        
+        public String getDeobfClassName() {
+                return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        }
+        
+        public String getDeobfMethodName() {
+                return m_deobfuscatingTranslator.translate(m_entry);
+        }
+        
+        @Override
+        public String toString() {
+                String className = getDeobfClassName();
+                if (className == null) {
+                        className = m_entry.getClassName();
+                }
+                
+                String methodName = getDeobfMethodName();
+                if (methodName == null) {
+                        methodName = m_entry.getName();
+                }
+                return className + "." + methodName + "()";
+        }
+        
+        public void load(JarIndex index) {
+                // get all method implementations
+                List<MethodImplementationsTreeNode> nodes = Lists.newArrayList();
+                for (String implementingClassName : index.getImplementingClasses(m_entry.getClassName())) {
+                        MethodEntry methodEntry = new MethodEntry(
+                                new ClassEntry(implementingClassName),
+                                m_entry.getName(),
+                                m_entry.getSignature()
+                        );
+                        if (index.containsObfBehavior(methodEntry)) {
+                                nodes.add(new MethodImplementationsTreeNode(m_deobfuscatingTranslator, methodEntry));
+                        }
+                }
+                
+                // add them to this node
+                for (MethodImplementationsTreeNode node : nodes) {
+                        this.add(node);
+                }
+        }
+        
+        public static MethodImplementationsTreeNode findNode(MethodImplementationsTreeNode node, MethodEntry entry) {
+                // is this the node?
+                if (node.getMethodEntry().equals(entry)) {
+                        return node;
+                }
+                
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        MethodImplementationsTreeNode foundNode = findNode((MethodImplementationsTreeNode)node.getChildAt(i), entry);
+                        if (foundNode != null) {
+                                return foundNode;
+                        }
+                }
+                return null;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java b/src/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
new file mode 100644
index 0000000..8718220
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class MethodInheritanceTreeNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = 1096677030991810007L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private MethodEntry m_entry;
+        private boolean m_isImplemented;
+        
+        public MethodInheritanceTreeNode(Translator deobfuscatingTranslator, MethodEntry entry, boolean isImplemented) {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = entry;
+                m_isImplemented = isImplemented;
+        }
+        
+        public MethodEntry getMethodEntry() {
+                return m_entry;
+        }
+        
+        public String getDeobfClassName() {
+                return m_deobfuscatingTranslator.translateClass(m_entry.getClassName());
+        }
+        
+        public String getDeobfMethodName() {
+                return m_deobfuscatingTranslator.translate(m_entry);
+        }
+        
+        public boolean isImplemented() {
+                return m_isImplemented;
+        }
+        
+        @Override
+        public String toString() {
+                String className = getDeobfClassName();
+                if (className == null) {
+                        className = m_entry.getClassName();
+                }
+                
+                if (!m_isImplemented) {
+                        return className;
+                } else {
+                        String methodName = getDeobfMethodName();
+                        if (methodName == null) {
+                                methodName = m_entry.getName();
+                        }
+                        return className + "." + methodName + "()";
+                }
+        }
+        
+        public void load(JarIndex index, boolean recurse) {
+                // get all the child nodes
+                List<MethodInheritanceTreeNode> nodes = Lists.newArrayList();
+                for (ClassEntry subclassEntry : index.getTranslationIndex().getSubclass(m_entry.getClassEntry())) {
+                        MethodEntry methodEntry = new MethodEntry(
+                                subclassEntry,
+                                m_entry.getName(),
+                                m_entry.getSignature()
+                        );
+                        nodes.add(new MethodInheritanceTreeNode(
+                                m_deobfuscatingTranslator,
+                                methodEntry,
+                                index.containsObfBehavior(methodEntry)
+                        ));
+                }
+                
+                // add them to this node
+                for (MethodInheritanceTreeNode node : nodes) {
+                        this.add(node);
+                }
+                
+                if (recurse) {
+                        for (MethodInheritanceTreeNode node : nodes) {
+                                node.load(index, true);
+                        }
+                }
+        }
+        
+        public static MethodInheritanceTreeNode findNode(MethodInheritanceTreeNode node, MethodEntry entry) {
+                // is this the node?
+                if (node.getMethodEntry().equals(entry)) {
+                        return node;
+                }
+                
+                // recurse
+                for (int i = 0; i < node.getChildCount(); i++) {
+                        MethodInheritanceTreeNode foundNode = findNode((MethodInheritanceTreeNode)node.getChildAt(i), entry);
+                        if (foundNode != null) {
+                                return foundNode;
+                        }
+                }
+                return null;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/ReferenceTreeNode.java b/src/cuchaz/enigma/analysis/ReferenceTreeNode.java
new file mode 100644
index 0000000..2b08616
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/ReferenceTreeNode.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import cuchaz.enigma.mapping.Entry;
+
+public interface ReferenceTreeNode<E extends Entry,C extends Entry> {
+        E getEntry();
+        EntryReference<E,C> getReference();
+}
diff --git a/src/cuchaz/enigma/analysis/SourceIndex.java b/src/cuchaz/enigma/analysis/SourceIndex.java
new file mode 100644
index 0000000..b43ab61
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/SourceIndex.java
@@ -0,0 +1,173 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.strobel.decompiler.languages.Region;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+
+import cuchaz.enigma.mapping.Entry;
+
+public class SourceIndex {
+        
+        private String m_source;
+        private TreeMap<Token,EntryReference<Entry,Entry>> m_tokenToReference;
+        private Multimap<EntryReference<Entry,Entry>,Token> m_referenceToTokens;
+        private Map<Entry,Token> m_declarationToToken;
+        private List<Integer> m_lineOffsets;
+        
+        public SourceIndex(String source) {
+                m_source = source;
+                m_tokenToReference = Maps.newTreeMap();
+                m_referenceToTokens = HashMultimap.create();
+                m_declarationToToken = Maps.newHashMap();
+                m_lineOffsets = Lists.newArrayList();
+                
+                // count the lines
+                m_lineOffsets.add(0);
+                for (int i = 0; i < source.length(); i++) {
+                        if (source.charAt(i) == '\n') {
+                                m_lineOffsets.add(i + 1);
+                        }
+                }
+        }
+        
+        public String getSource() {
+                return m_source;
+        }
+        
+        public Token getToken(AstNode node) {
+                
+                // get the text of the node
+                String name = "";
+                if (node instanceof Identifier) {
+                        name = ((Identifier)node).getName();
+                }
+                
+                // get a token for this node's region
+                Region region = node.getRegion();
+                if (region.getBeginLine() == 0 || region.getEndLine() == 0) {
+                        // DEBUG
+                        System.err.println(String.format("WARNING: %s \"%s\" has invalid region: %s", node.getNodeType(), name, region));
+                        return null;
+                }
+                Token token = new Token(
+                        toPos(region.getBeginLine(), region.getBeginColumn()),
+                        toPos(region.getEndLine(), region.getEndColumn()),
+                        m_source
+                );
+                if (token.start == 0) {
+                        // DEBUG
+                        System.err.println(String.format("WARNING: %s \"%s\" has invalid start: %s", node.getNodeType(), name, region));
+                        return null;
+                }
+                
+                // DEBUG
+                // System.out.println( String.format( "%s \"%s\" region: %s", node.getNodeType(), name, region ) );
+                
+                // for tokens representing inner classes, make sure we only get the simple name
+                int pos = name.lastIndexOf('$');
+                if (pos >= 0) {
+                        token.end -= pos + 1;
+                }
+                
+                return token;
+        }
+        
+        public void addReference(AstNode node, Entry deobfEntry, Entry deobfContext) {
+                Token token = getToken(node);
+                if (token != null) {
+                        EntryReference<Entry,Entry> deobfReference = new EntryReference<Entry,Entry>(deobfEntry, token.text, deobfContext);
+                        m_tokenToReference.put(token, deobfReference);
+                        m_referenceToTokens.put(deobfReference, token);
+                }
+        }
+        
+        public void addDeclaration(AstNode node, Entry deobfEntry) {
+                Token token = getToken(node);
+                if (token != null) {
+                        EntryReference<Entry,Entry> reference = new EntryReference<Entry,Entry>(deobfEntry, token.text);
+                        m_tokenToReference.put(token, reference);
+                        m_referenceToTokens.put(reference, token);
+                        m_declarationToToken.put(deobfEntry, token);
+                }
+        }
+        
+        public Token getReferenceToken(int pos) {
+                Token token = m_tokenToReference.floorKey(new Token(pos, pos, null));
+                if (token != null && token.contains(pos)) {
+                        return token;
+                }
+                return null;
+        }
+        
+        public Collection<Token> getReferenceTokens(EntryReference<Entry,Entry> deobfReference) {
+                return m_referenceToTokens.get(deobfReference);
+        }
+        
+        public EntryReference<Entry,Entry> getDeobfReference(Token token) {
+                if (token == null) {
+                        return null;
+                }
+                return m_tokenToReference.get(token);
+        }
+        
+        public void replaceDeobfReference(Token token, EntryReference<Entry,Entry> newDeobfReference) {
+                EntryReference<Entry,Entry> oldDeobfReference = m_tokenToReference.get(token);
+                m_tokenToReference.put(token, newDeobfReference);
+                Collection<Token> tokens = m_referenceToTokens.get(oldDeobfReference);
+                m_referenceToTokens.removeAll(oldDeobfReference);
+                m_referenceToTokens.putAll(newDeobfReference, tokens);
+        }
+        
+        public Iterable<Token> referenceTokens() {
+                return m_tokenToReference.keySet();
+        }
+        
+        public Iterable<Token> declarationTokens() {
+                return m_declarationToToken.values();
+        }
+        
+        public Token getDeclarationToken(Entry deobfEntry) {
+                return m_declarationToToken.get(deobfEntry);
+        }
+        
+        public int getLineNumber(int pos) {
+                // line number is 1-based
+                int line = 0;
+                for (Integer offset : m_lineOffsets) {
+                        if (offset > pos) {
+                                break;
+                        }
+                        line++;
+                }
+                return line;
+        }
+        
+        public int getColumnNumber(int pos) {
+                // column number is 1-based
+                return pos - m_lineOffsets.get(getLineNumber(pos) - 1) + 1;
+        }
+        
+        private int toPos(int line, int col) {
+                // line and col are 1-based
+                return m_lineOffsets.get(line - 1) + col - 1;
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
new file mode 100644
index 0000000..4155128
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
@@ -0,0 +1,164 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import com.strobel.assembler.metadata.MemberReference;
+import com.strobel.assembler.metadata.MethodDefinition;
+import com.strobel.assembler.metadata.MethodReference;
+import com.strobel.assembler.metadata.ParameterDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+import com.strobel.decompiler.languages.TextLocation;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.IdentifierExpression;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.SuperReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ThisReferenceExpression;
+
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
+        
+        private BehaviorEntry m_behaviorEntry;
+        
+        public SourceIndexBehaviorVisitor(BehaviorEntry behaviorEntry) {
+                m_behaviorEntry = behaviorEntry;
+        }
+        
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitInvocationExpression(InvocationExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                
+                // get the behavior entry
+                ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                BehaviorEntry behaviorEntry = null;
+                if (ref instanceof MethodReference) {
+                        MethodReference methodRef = (MethodReference)ref;
+                        if (methodRef.isConstructor()) {
+                                behaviorEntry = new ConstructorEntry(classEntry, new Signature(ref.getSignature()));
+                        } else if (methodRef.isTypeInitializer()) {
+                                behaviorEntry = new ConstructorEntry(classEntry);
+                        } else {
+                                behaviorEntry = new MethodEntry(classEntry, ref.getName(), new Signature(ref.getSignature()));
+                        }
+                }
+                if (behaviorEntry != null) {
+                        // get the node for the token
+                        AstNode tokenNode = null;
+                        if (node.getTarget() instanceof MemberReferenceExpression) {
+                                tokenNode = ((MemberReferenceExpression)node.getTarget()).getMemberNameToken();
+                        } else if (node.getTarget() instanceof SuperReferenceExpression) {
+                                tokenNode = node.getTarget();
+                        } else if (node.getTarget() instanceof ThisReferenceExpression) {
+                                tokenNode = node.getTarget();
+                        }
+                        if (tokenNode != null) {
+                                index.addReference(tokenNode, behaviorEntry, m_behaviorEntry);
+                        }
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitMemberReferenceExpression(MemberReferenceExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                if (ref != null) {
+                        // make sure this is actually a field
+                        if (ref.getSignature().indexOf('(') >= 0) {
+                                throw new Error("Expected a field here! got " + ref);
+                        }
+                        
+                        ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName());
+                        index.addReference(node.getMemberNameToken(), fieldEntry, m_behaviorEntry);
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSimpleType(SimpleType node, SourceIndex index) {
+                TypeReference ref = node.getUserData(Keys.TYPE_REFERENCE);
+                if (node.getIdentifierToken().getStartLocation() != TextLocation.EMPTY) {
+                        ClassEntry classEntry = new ClassEntry(ref.getInternalName());
+                        index.addReference(node.getIdentifierToken(), classEntry, m_behaviorEntry);
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitParameterDeclaration(ParameterDeclaration node, SourceIndex index) {
+                ParameterDefinition def = node.getUserData(Keys.PARAMETER_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                MethodDefinition methodDef = (MethodDefinition)def.getMethod();
+                BehaviorEntry behaviorEntry;
+                if (methodDef.isConstructor()) {
+                        behaviorEntry = new ConstructorEntry(classEntry, new Signature(methodDef.getSignature()));
+                } else {
+                        behaviorEntry = new MethodEntry(classEntry, methodDef.getName(), new Signature(methodDef.getSignature()));
+                }
+                ArgumentEntry argumentEntry = new ArgumentEntry(behaviorEntry, def.getPosition(), node.getName());
+                index.addDeclaration(node.getNameToken(), argumentEntry);
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIdentifierExpression(IdentifierExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                if (ref != null) {
+                        ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName());
+                        index.addReference(node.getIdentifierToken(), fieldEntry, m_behaviorEntry);
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitObjectCreationExpression(ObjectCreationExpression node, SourceIndex index) {
+                MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
+                if (ref != null) {
+                        ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
+                        ConstructorEntry constructorEntry = new ConstructorEntry(classEntry, new Signature(ref.getSignature()));
+                        if (node.getType() instanceof SimpleType) {
+                                SimpleType simpleTypeNode = (SimpleType)node.getType();
+                                index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, m_behaviorEntry);
+                        }
+                }
+                
+                return recurse(node, index);
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
new file mode 100644
index 0000000..7222035
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import com.strobel.assembler.metadata.FieldDefinition;
+import com.strobel.assembler.metadata.MethodDefinition;
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.assembler.metadata.TypeReference;
+import com.strobel.decompiler.languages.TextLocation;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.EnumValueDeclaration;
+import com.strobel.decompiler.languages.java.ast.FieldDeclaration;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import com.strobel.decompiler.languages.java.ast.VariableInitializer;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class SourceIndexClassVisitor extends SourceIndexVisitor {
+        
+        private ClassEntry m_classEntry;
+        
+        public SourceIndexClassVisitor(ClassEntry classEntry) {
+                m_classEntry = classEntry;
+        }
+        
+        @Override
+        public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) {
+                // is this this class, or a subtype?
+                TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getInternalName());
+                if (!classEntry.equals(m_classEntry)) {
+                        // it's a sub-type, recurse
+                        index.addDeclaration(node.getNameToken(), classEntry);
+                        return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSimpleType(SimpleType node, SourceIndex index) {
+                TypeReference ref = node.getUserData(Keys.TYPE_REFERENCE);
+                if (node.getIdentifierToken().getStartLocation() != TextLocation.EMPTY) {
+                        ClassEntry classEntry = new ClassEntry(ref.getInternalName());
+                        index.addReference(node.getIdentifierToken(), classEntry, m_classEntry);
+                }
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
+                MethodDefinition def = node.getUserData(Keys.METHOD_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(classEntry, def.getName(), def.getSignature());
+                AstNode tokenNode = node.getNameToken();
+                if (behaviorEntry instanceof ConstructorEntry) {
+                        ConstructorEntry constructorEntry = (ConstructorEntry)behaviorEntry;
+                        if (constructorEntry.isStatic()) {
+                                tokenNode = node.getModifiers().firstOrNullObject();
+                        }
+                }
+                index.addDeclaration(tokenNode, behaviorEntry);
+                return node.acceptVisitor(new SourceIndexBehaviorVisitor(behaviorEntry), index);
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
+                MethodDefinition def = node.getUserData(Keys.METHOD_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                ConstructorEntry constructorEntry = new ConstructorEntry(classEntry, new Signature(def.getSignature()));
+                index.addDeclaration(node.getNameToken(), constructorEntry);
+                return node.acceptVisitor(new SourceIndexBehaviorVisitor(constructorEntry), index);
+        }
+        
+        @Override
+        public Void visitFieldDeclaration(FieldDeclaration node, SourceIndex index) {
+                FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                FieldEntry fieldEntry = new FieldEntry(classEntry, def.getName());
+                assert (node.getVariables().size() == 1);
+                VariableInitializer variable = node.getVariables().firstOrNullObject();
+                index.addDeclaration(variable.getNameToken(), fieldEntry);
+                
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitEnumValueDeclaration(EnumValueDeclaration node, SourceIndex index) {
+                // treat enum declarations as field declarations
+                FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
+                FieldEntry fieldEntry = new FieldEntry(classEntry, def.getName());
+                index.addDeclaration(node.getNameToken(), fieldEntry);
+                
+                return recurse(node, index);
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
new file mode 100644
index 0000000..0d5bdc0
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
@@ -0,0 +1,452 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import com.strobel.assembler.metadata.TypeDefinition;
+import com.strobel.decompiler.languages.java.ast.Annotation;
+import com.strobel.decompiler.languages.java.ast.AnonymousObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayInitializerExpression;
+import com.strobel.decompiler.languages.java.ast.ArraySpecifier;
+import com.strobel.decompiler.languages.java.ast.AssertStatement;
+import com.strobel.decompiler.languages.java.ast.AssignmentExpression;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.BinaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.BlockStatement;
+import com.strobel.decompiler.languages.java.ast.BreakStatement;
+import com.strobel.decompiler.languages.java.ast.CaseLabel;
+import com.strobel.decompiler.languages.java.ast.CastExpression;
+import com.strobel.decompiler.languages.java.ast.CatchClause;
+import com.strobel.decompiler.languages.java.ast.ClassOfExpression;
+import com.strobel.decompiler.languages.java.ast.Comment;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+import com.strobel.decompiler.languages.java.ast.ComposedType;
+import com.strobel.decompiler.languages.java.ast.ConditionalExpression;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.ContinueStatement;
+import com.strobel.decompiler.languages.java.ast.DoWhileStatement;
+import com.strobel.decompiler.languages.java.ast.EmptyStatement;
+import com.strobel.decompiler.languages.java.ast.EnumValueDeclaration;
+import com.strobel.decompiler.languages.java.ast.ExpressionStatement;
+import com.strobel.decompiler.languages.java.ast.FieldDeclaration;
+import com.strobel.decompiler.languages.java.ast.ForEachStatement;
+import com.strobel.decompiler.languages.java.ast.ForStatement;
+import com.strobel.decompiler.languages.java.ast.GotoStatement;
+import com.strobel.decompiler.languages.java.ast.IAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.IdentifierExpression;
+import com.strobel.decompiler.languages.java.ast.IfElseStatement;
+import com.strobel.decompiler.languages.java.ast.ImportDeclaration;
+import com.strobel.decompiler.languages.java.ast.IndexerExpression;
+import com.strobel.decompiler.languages.java.ast.InstanceInitializer;
+import com.strobel.decompiler.languages.java.ast.InstanceOfExpression;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.JavaTokenNode;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.LabelStatement;
+import com.strobel.decompiler.languages.java.ast.LabeledStatement;
+import com.strobel.decompiler.languages.java.ast.LambdaExpression;
+import com.strobel.decompiler.languages.java.ast.LocalTypeDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.MethodGroupExpression;
+import com.strobel.decompiler.languages.java.ast.NewLineNode;
+import com.strobel.decompiler.languages.java.ast.NullReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.PackageDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParenthesizedExpression;
+import com.strobel.decompiler.languages.java.ast.PrimitiveExpression;
+import com.strobel.decompiler.languages.java.ast.ReturnStatement;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.SuperReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.SwitchSection;
+import com.strobel.decompiler.languages.java.ast.SwitchStatement;
+import com.strobel.decompiler.languages.java.ast.SynchronizedStatement;
+import com.strobel.decompiler.languages.java.ast.TextNode;
+import com.strobel.decompiler.languages.java.ast.ThisReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ThrowStatement;
+import com.strobel.decompiler.languages.java.ast.TryCatchStatement;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.UnaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.VariableDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.VariableInitializer;
+import com.strobel.decompiler.languages.java.ast.WhileStatement;
+import com.strobel.decompiler.languages.java.ast.WildcardType;
+import com.strobel.decompiler.patterns.Pattern;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class SourceIndexVisitor implements IAstVisitor<SourceIndex,Void> {
+        
+        @Override
+        public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) {
+                TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
+                ClassEntry classEntry = new ClassEntry(def.getInternalName());
+                index.addDeclaration(node.getNameToken(), classEntry);
+                
+                return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
+        }
+        
+        protected Void recurse(AstNode node, SourceIndex index) {
+                for (final AstNode child : node.getChildren()) {
+                        child.acceptVisitor(this, index);
+                }
+                return null;
+        }
+        
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitFieldDeclaration(FieldDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitEnumValueDeclaration(EnumValueDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitParameterDeclaration(ParameterDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitInvocationExpression(InvocationExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitMemberReferenceExpression(MemberReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSimpleType(SimpleType node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIdentifierExpression(IdentifierExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitComment(Comment node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitPatternPlaceholder(AstNode node, Pattern pattern, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitTypeReference(TypeReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitJavaTokenNode(JavaTokenNode node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIdentifier(Identifier node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitNullReferenceExpression(NullReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitThisReferenceExpression(ThisReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSuperReferenceExpression(SuperReferenceExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitClassOfExpression(ClassOfExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitBlockStatement(BlockStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitExpressionStatement(ExpressionStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitBreakStatement(BreakStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitContinueStatement(ContinueStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitDoWhileStatement(DoWhileStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitEmptyStatement(EmptyStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIfElseStatement(IfElseStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitLabelStatement(LabelStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitLabeledStatement(LabeledStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitReturnStatement(ReturnStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSwitchStatement(SwitchStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSwitchSection(SwitchSection node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitCaseLabel(CaseLabel node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitThrowStatement(ThrowStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitCatchClause(CatchClause node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitAnnotation(Annotation node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitNewLine(NewLineNode node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitVariableDeclaration(VariableDeclarationStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitVariableInitializer(VariableInitializer node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitText(TextNode node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitImportDeclaration(ImportDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitInitializerBlock(InstanceInitializer node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitTypeParameterDeclaration(TypeParameterDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitCompilationUnit(CompilationUnit node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitPackageDeclaration(PackageDeclaration node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitArraySpecifier(ArraySpecifier node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitComposedType(ComposedType node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitWhileStatement(WhileStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitPrimitiveExpression(PrimitiveExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitCastExpression(CastExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitBinaryOperatorExpression(BinaryOperatorExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitInstanceOfExpression(InstanceOfExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitIndexerExpression(IndexerExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitUnaryOperatorExpression(UnaryOperatorExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitConditionalExpression(ConditionalExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitArrayInitializerExpression(ArrayInitializerExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitObjectCreationExpression(ObjectCreationExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitArrayCreationExpression(ArrayCreationExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitAssignmentExpression(AssignmentExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitForStatement(ForStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitForEachStatement(ForEachStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitTryCatchStatement(TryCatchStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitGotoStatement(GotoStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitParenthesizedExpression(ParenthesizedExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitSynchronizedStatement(SynchronizedStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitAnonymousObjectCreationExpression(AnonymousObjectCreationExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitWildcardType(WildcardType node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitMethodGroupExpression(MethodGroupExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitAssertStatement(AssertStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitLambdaExpression(LambdaExpression node, SourceIndex index) {
+                return recurse(node, index);
+        }
+        
+        @Override
+        public Void visitLocalTypeDeclarationStatement(LocalTypeDeclarationStatement node, SourceIndex index) {
+                return recurse(node, index);
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/Token.java b/src/cuchaz/enigma/analysis/Token.java
new file mode 100644
index 0000000..481d2f4
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/Token.java
@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+public class Token implements Comparable<Token> {
+        
+        public int start;
+        public int end;
+        public String text;
+        
+        public Token(int start, int end) {
+                this(start, end, null);
+        }
+        
+        public Token(int start, int end, String source) {
+                this.start = start;
+                this.end = end;
+                if (source != null) {
+                        this.text = source.substring(start, end);
+                }
+        }
+        
+        public boolean contains(int pos) {
+                return pos >= start && pos <= end;
+        }
+        
+        @Override
+        public int compareTo(Token other) {
+                return start - other.start;
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof Token) {
+                        return equals((Token)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(Token other) {
+                return start == other.start && end == other.end;
+        }
+        
+        @Override
+        public String toString() {
+                return String.format("[%d,%d]", start, end);
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/TranslationIndex.java b/src/cuchaz/enigma/analysis/TranslationIndex.java
new file mode 100644
index 0000000..7597c3a
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/TranslationIndex.java
@@ -0,0 +1,227 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtField;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.Translator;
+
+public class TranslationIndex implements Serializable {
+        
+        private static final long serialVersionUID = 738687982126844179L;
+        
+        private Map<ClassEntry,ClassEntry> m_superclasses;
+        private Multimap<ClassEntry,FieldEntry> m_fieldEntries;
+        private Multimap<ClassEntry,BehaviorEntry> m_behaviorEntries;
+        
+        public TranslationIndex() {
+                m_superclasses = Maps.newHashMap();
+                m_fieldEntries = HashMultimap.create();
+                m_behaviorEntries = HashMultimap.create();
+        }
+        
+        public TranslationIndex(TranslationIndex other, Translator translator) {
+                
+                // translate the superclasses
+                m_superclasses = Maps.newHashMap();
+                for (Map.Entry<ClassEntry,ClassEntry> mapEntry : other.m_superclasses.entrySet()) {
+                        m_superclasses.put(
+                                translator.translateEntry(mapEntry.getKey()),
+                                translator.translateEntry(mapEntry.getValue())
+                        );
+                }
+                
+                // translate the fields
+                m_fieldEntries = HashMultimap.create();
+                for (Map.Entry<ClassEntry,FieldEntry> mapEntry : other.m_fieldEntries.entries()) {
+                        m_fieldEntries.put(
+                                translator.translateEntry(mapEntry.getKey()),
+                                translator.translateEntry(mapEntry.getValue())
+                        );
+                }
+                
+                m_behaviorEntries = HashMultimap.create();
+                for (Map.Entry<ClassEntry,BehaviorEntry> mapEntry : other.m_behaviorEntries.entries()) {
+                        m_behaviorEntries.put(
+                                translator.translateEntry(mapEntry.getKey()),
+                                translator.translateEntry(mapEntry.getValue())
+                        );
+                }
+        }
+        
+        public void indexClass(CtClass c) {
+                
+                ClassEntry classEntry = JavassistUtil.getClassEntry(c);
+                
+                // add the superclass
+                ClassEntry superclassEntry = JavassistUtil.getSuperclassEntry(c);
+                if (!isJre(classEntry) && superclassEntry != null && !isJre(superclassEntry)) {
+                        m_superclasses.put(classEntry, superclassEntry);
+                }
+                
+                // add fields
+                for (CtField field : c.getDeclaredFields()) {
+                        FieldEntry fieldEntry = JavassistUtil.getFieldEntry(field);
+                        m_fieldEntries.put(fieldEntry.getClassEntry(), fieldEntry);
+                }
+                
+                // add behaviors
+                for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                        BehaviorEntry behaviorEntry = JavassistUtil.getBehaviorEntry(behavior);
+                        m_behaviorEntries.put(behaviorEntry.getClassEntry(), behaviorEntry);
+                }
+        }
+        
+        public void renameClasses(Map<String,String> renames) {
+                EntryRenamer.renameClassesInMap(renames, m_superclasses);
+                EntryRenamer.renameClassesInMultimap(renames, m_fieldEntries);
+                EntryRenamer.renameClassesInMultimap(renames, m_behaviorEntries);
+        }
+        
+        public ClassEntry getSuperclass(ClassEntry classEntry) {
+                return m_superclasses.get(classEntry);
+        }
+        
+        public List<ClassEntry> getAncestry(ClassEntry classEntry) {
+                List<ClassEntry> ancestors = Lists.newArrayList();
+                while (classEntry != null) {
+                        classEntry = getSuperclass(classEntry);
+                        if (classEntry != null) {
+                                ancestors.add(classEntry);
+                        }
+                }
+                return ancestors;
+        }
+        
+        public List<ClassEntry> getSubclass(ClassEntry classEntry) {
+                // linear search is fast enough for now
+                List<ClassEntry> subclasses = Lists.newArrayList();
+                for (Map.Entry<ClassEntry,ClassEntry> entry : m_superclasses.entrySet()) {
+                        ClassEntry subclass = entry.getKey();
+                        ClassEntry superclass = entry.getValue();
+                        if (classEntry.equals(superclass)) {
+                                subclasses.add(subclass);
+                        }
+                }
+                return subclasses;
+        }
+        
+        public void getSubclassesRecursively(Set<ClassEntry> out, ClassEntry classEntry) {
+                for (ClassEntry subclassEntry : getSubclass(classEntry)) {
+                        out.add(subclassEntry);
+                        getSubclassesRecursively(out, subclassEntry);
+                }
+        }
+        
+        public void getSubclassNamesRecursively(Set<String> out, ClassEntry classEntry) {
+                for (ClassEntry subclassEntry : getSubclass(classEntry)) {
+                        out.add(subclassEntry.getName());
+                        getSubclassNamesRecursively(out, subclassEntry);
+                }
+        }
+        
+        public boolean entryExists(Entry entry) {
+                if (entry instanceof FieldEntry) {
+                        return fieldExists((FieldEntry)entry);
+                } else if (entry instanceof BehaviorEntry) {
+                        return behaviorExists((BehaviorEntry)entry);
+                } else if (entry instanceof ArgumentEntry) {
+                        return behaviorExists(((ArgumentEntry)entry).getBehaviorEntry());
+                }
+                throw new IllegalArgumentException("Cannot check existence for " + entry.getClass());
+        }
+        
+        public boolean fieldExists(FieldEntry fieldEntry) {
+                return m_fieldEntries.containsEntry(fieldEntry.getClassEntry(), fieldEntry);
+        }
+        
+        public boolean behaviorExists(BehaviorEntry behaviorEntry) {
+                return m_behaviorEntries.containsEntry(behaviorEntry.getClassEntry(), behaviorEntry);
+        }
+        
+        public ClassEntry resolveEntryClass(Entry entry) {
+                
+                if (entry instanceof ClassEntry) {
+                        return (ClassEntry)entry;
+                }
+                
+                // this entry could refer to a method on a class where the method is not actually implemented
+                // travel up the inheritance tree to find the closest implementation
+                while (!entryExists(entry)) {
+                        
+                        // is there a parent class?
+                        ClassEntry superclassEntry = getSuperclass(entry.getClassEntry());
+                        if (superclassEntry == null) {
+                                // this is probably a method from a class in a library
+                                // we can't trace the implementation up any higher unless we index the library
+                                return null;
+                        }
+                        
+                        // move up to the parent class
+                        entry = entry.cloneToNewClass(superclassEntry);
+                }
+                return entry.getClassEntry();
+        }
+        
+        private boolean isJre(ClassEntry classEntry) {
+                String packageName = classEntry.getPackageName();
+                return packageName != null && (packageName.startsWith("java") || packageName.startsWith("javax"));
+        }
+        
+        public void write(OutputStream out)
+        throws IOException {
+                GZIPOutputStream gzipout = new GZIPOutputStream(out);
+                ObjectOutputStream oout = new ObjectOutputStream(gzipout);
+                oout.writeObject(m_superclasses);
+                oout.writeObject(m_fieldEntries);
+                oout.writeObject(m_behaviorEntries);
+                gzipout.finish();
+        }
+        
+        @SuppressWarnings("unchecked")
+        public void read(InputStream in)
+        throws IOException {
+                try {
+                        ObjectInputStream oin = new ObjectInputStream(new GZIPInputStream(in));
+                        m_superclasses = (HashMap<ClassEntry,ClassEntry>)oin.readObject();
+                        m_fieldEntries = (HashMultimap<ClassEntry,FieldEntry>)oin.readObject();
+                        m_behaviorEntries = (HashMultimap<ClassEntry,BehaviorEntry>)oin.readObject();
+                } catch (ClassNotFoundException ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java
new file mode 100644
index 0000000..23f8089
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java
@@ -0,0 +1,512 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+
+import com.strobel.componentmodel.Key;
+import com.strobel.decompiler.languages.java.ast.Annotation;
+import com.strobel.decompiler.languages.java.ast.AnonymousObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayInitializerExpression;
+import com.strobel.decompiler.languages.java.ast.ArraySpecifier;
+import com.strobel.decompiler.languages.java.ast.AssertStatement;
+import com.strobel.decompiler.languages.java.ast.AssignmentExpression;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.BinaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.BlockStatement;
+import com.strobel.decompiler.languages.java.ast.BreakStatement;
+import com.strobel.decompiler.languages.java.ast.CaseLabel;
+import com.strobel.decompiler.languages.java.ast.CastExpression;
+import com.strobel.decompiler.languages.java.ast.CatchClause;
+import com.strobel.decompiler.languages.java.ast.ClassOfExpression;
+import com.strobel.decompiler.languages.java.ast.Comment;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+import com.strobel.decompiler.languages.java.ast.ComposedType;
+import com.strobel.decompiler.languages.java.ast.ConditionalExpression;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.ContinueStatement;
+import com.strobel.decompiler.languages.java.ast.DoWhileStatement;
+import com.strobel.decompiler.languages.java.ast.EmptyStatement;
+import com.strobel.decompiler.languages.java.ast.EnumValueDeclaration;
+import com.strobel.decompiler.languages.java.ast.ExpressionStatement;
+import com.strobel.decompiler.languages.java.ast.FieldDeclaration;
+import com.strobel.decompiler.languages.java.ast.ForEachStatement;
+import com.strobel.decompiler.languages.java.ast.ForStatement;
+import com.strobel.decompiler.languages.java.ast.GotoStatement;
+import com.strobel.decompiler.languages.java.ast.IAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.IdentifierExpression;
+import com.strobel.decompiler.languages.java.ast.IfElseStatement;
+import com.strobel.decompiler.languages.java.ast.ImportDeclaration;
+import com.strobel.decompiler.languages.java.ast.IndexerExpression;
+import com.strobel.decompiler.languages.java.ast.InstanceInitializer;
+import com.strobel.decompiler.languages.java.ast.InstanceOfExpression;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.JavaTokenNode;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.LabelStatement;
+import com.strobel.decompiler.languages.java.ast.LabeledStatement;
+import com.strobel.decompiler.languages.java.ast.LambdaExpression;
+import com.strobel.decompiler.languages.java.ast.LocalTypeDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.MethodGroupExpression;
+import com.strobel.decompiler.languages.java.ast.NewLineNode;
+import com.strobel.decompiler.languages.java.ast.NullReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.PackageDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParenthesizedExpression;
+import com.strobel.decompiler.languages.java.ast.PrimitiveExpression;
+import com.strobel.decompiler.languages.java.ast.ReturnStatement;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.SuperReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.SwitchSection;
+import com.strobel.decompiler.languages.java.ast.SwitchStatement;
+import com.strobel.decompiler.languages.java.ast.SynchronizedStatement;
+import com.strobel.decompiler.languages.java.ast.TextNode;
+import com.strobel.decompiler.languages.java.ast.ThisReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ThrowStatement;
+import com.strobel.decompiler.languages.java.ast.TryCatchStatement;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.UnaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.VariableDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.VariableInitializer;
+import com.strobel.decompiler.languages.java.ast.WhileStatement;
+import com.strobel.decompiler.languages.java.ast.WildcardType;
+import com.strobel.decompiler.patterns.Pattern;
+
+public class TreeDumpVisitor implements IAstVisitor<Void,Void> {
+        
+        private File m_file;
+        private Writer m_out;
+        
+        public TreeDumpVisitor(File file) {
+                m_file = file;
+                m_out = null;
+        }
+        
+        @Override
+        public Void visitCompilationUnit(CompilationUnit node, Void ignored) {
+                try {
+                        m_out = new FileWriter(m_file);
+                        recurse(node, ignored);
+                        m_out.close();
+                        return null;
+                } catch (IOException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private Void recurse(AstNode node, Void ignored) {
+                // show the tree
+                try {
+                        m_out.write(getIndent(node) + node.getClass().getSimpleName() + " " + getText(node) + " " + dumpUserData(node) + " " + node.getRegion() + "\n");
+                } catch (IOException ex) {
+                        throw new Error(ex);
+                }
+                
+                // recurse
+                for (final AstNode child : node.getChildren()) {
+                        child.acceptVisitor(this, ignored);
+                }
+                return null;
+        }
+        
+        private String getText(AstNode node) {
+                if (node instanceof Identifier) {
+                        return "\"" + ((Identifier)node).getName() + "\"";
+                }
+                return "";
+        }
+        
+        private String dumpUserData(AstNode node) {
+                StringBuilder buf = new StringBuilder();
+                for (Key<?> key : Keys.ALL_KEYS) {
+                        Object val = node.getUserData(key);
+                        if (val != null) {
+                                buf.append(String.format(" [%s=%s]", key, val));
+                        }
+                }
+                return buf.toString();
+        }
+        
+        private String getIndent(AstNode node) {
+                StringBuilder buf = new StringBuilder();
+                int depth = getDepth(node);
+                for (int i = 0; i < depth; i++) {
+                        buf.append("\t");
+                }
+                return buf.toString();
+        }
+        
+        private int getDepth(AstNode node) {
+                int depth = -1;
+                while (node != null) {
+                        depth++;
+                        node = node.getParent();
+                }
+                return depth;
+        }
+        
+        // OVERRIDES WE DON'T CARE ABOUT
+        
+        @Override
+        public Void visitInvocationExpression(InvocationExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitMemberReferenceExpression(MemberReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSimpleType(SimpleType node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitMethodDeclaration(MethodDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration(ConstructorDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitParameterDeclaration(ParameterDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitFieldDeclaration(FieldDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitTypeDeclaration(TypeDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitComment(Comment node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitPatternPlaceholder(AstNode node, Pattern pattern, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitTypeReference(TypeReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitJavaTokenNode(JavaTokenNode node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitIdentifier(Identifier node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitNullReferenceExpression(NullReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitThisReferenceExpression(ThisReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSuperReferenceExpression(SuperReferenceExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitClassOfExpression(ClassOfExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitBlockStatement(BlockStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitExpressionStatement(ExpressionStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitBreakStatement(BreakStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitContinueStatement(ContinueStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitDoWhileStatement(DoWhileStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitEmptyStatement(EmptyStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitIfElseStatement(IfElseStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitLabelStatement(LabelStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitLabeledStatement(LabeledStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitReturnStatement(ReturnStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSwitchStatement(SwitchStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSwitchSection(SwitchSection node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitCaseLabel(CaseLabel node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitThrowStatement(ThrowStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitCatchClause(CatchClause node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitAnnotation(Annotation node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitNewLine(NewLineNode node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitVariableDeclaration(VariableDeclarationStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitVariableInitializer(VariableInitializer node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitText(TextNode node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitImportDeclaration(ImportDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitInitializerBlock(InstanceInitializer node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitTypeParameterDeclaration(TypeParameterDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitPackageDeclaration(PackageDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitArraySpecifier(ArraySpecifier node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitComposedType(ComposedType node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitWhileStatement(WhileStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitPrimitiveExpression(PrimitiveExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitCastExpression(CastExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitBinaryOperatorExpression(BinaryOperatorExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitInstanceOfExpression(InstanceOfExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitIndexerExpression(IndexerExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitIdentifierExpression(IdentifierExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitUnaryOperatorExpression(UnaryOperatorExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitConditionalExpression(ConditionalExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitArrayInitializerExpression(ArrayInitializerExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitObjectCreationExpression(ObjectCreationExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitArrayCreationExpression(ArrayCreationExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitAssignmentExpression(AssignmentExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitForStatement(ForStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitForEachStatement(ForEachStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitTryCatchStatement(TryCatchStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitGotoStatement(GotoStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitParenthesizedExpression(ParenthesizedExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitSynchronizedStatement(SynchronizedStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitAnonymousObjectCreationExpression(AnonymousObjectCreationExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitWildcardType(WildcardType node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitMethodGroupExpression(MethodGroupExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitEnumValueDeclaration(EnumValueDeclaration node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitAssertStatement(AssertStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitLambdaExpression(LambdaExpression node, Void ignored) {
+                return recurse(node, ignored);
+        }
+        
+        @Override
+        public Void visitLocalTypeDeclarationStatement(LocalTypeDeclarationStatement node, Void ignored) {
+                return recurse(node, ignored);
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/CheckCastIterator.java b/src/cuchaz/enigma/bytecode/CheckCastIterator.java
new file mode 100644
index 0000000..5284557
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/CheckCastIterator.java
@@ -0,0 +1,127 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Iterator;
+
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.Opcode;
+import cuchaz.enigma.bytecode.CheckCastIterator.CheckCast;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class CheckCastIterator implements Iterator<CheckCast> {
+        
+        public static class CheckCast {
+                
+                public String className;
+                public MethodEntry prevMethodEntry;
+                
+                public CheckCast(String className, MethodEntry prevMethodEntry) {
+                        this.className = className;
+                        this.prevMethodEntry = prevMethodEntry;
+                }
+        }
+        
+        private ConstPool m_constants;
+        private CodeAttribute m_attribute;
+        private CodeIterator m_iter;
+        private CheckCast m_next;
+        
+        public CheckCastIterator(CodeAttribute codeAttribute) throws BadBytecode {
+                m_constants = codeAttribute.getConstPool();
+                m_attribute = codeAttribute;
+                m_iter = m_attribute.iterator();
+                
+                m_next = getNext();
+        }
+        
+        @Override
+        public boolean hasNext() {
+                return m_next != null;
+        }
+        
+        @Override
+        public CheckCast next() {
+                CheckCast out = m_next;
+                try {
+                        m_next = getNext();
+                } catch (BadBytecode ex) {
+                        throw new Error(ex);
+                }
+                return out;
+        }
+        
+        @Override
+        public void remove() {
+                throw new UnsupportedOperationException();
+        }
+        
+        private CheckCast getNext() throws BadBytecode {
+                int prevPos = 0;
+                while (m_iter.hasNext()) {
+                        int pos = m_iter.next();
+                        int opcode = m_iter.byteAt(pos);
+                        switch (opcode) {
+                                case Opcode.CHECKCAST:
+                                        
+                                        // get the type of this op code (next two bytes are a classinfo index)
+                                        MethodEntry prevMethodEntry = getMethodEntry(prevPos);
+                                        if (prevMethodEntry != null) {
+                                                return new CheckCast(m_constants.getClassInfo(m_iter.s16bitAt(pos + 1)), prevMethodEntry);
+                                        }
+                                break;
+                        }
+                        prevPos = pos;
+                }
+                return null;
+        }
+        
+        private MethodEntry getMethodEntry(int pos) {
+                switch (m_iter.byteAt(pos)) {
+                        case Opcode.INVOKEVIRTUAL:
+                        case Opcode.INVOKESTATIC:
+                        case Opcode.INVOKEDYNAMIC:
+                        case Opcode.INVOKESPECIAL: {
+                                int index = m_iter.s16bitAt(pos + 1);
+                                return new MethodEntry(
+                                        new ClassEntry(Descriptor.toJvmName(m_constants.getMethodrefClassName(index))),
+                                        m_constants.getMethodrefName(index),
+                                        new Signature(m_constants.getMethodrefType(index))
+                                );
+                        }
+                        
+                        case Opcode.INVOKEINTERFACE: {
+                                int index = m_iter.s16bitAt(pos + 1);
+                                return new MethodEntry(
+                                        new ClassEntry(Descriptor.toJvmName(m_constants.getInterfaceMethodrefClassName(index))),
+                                        m_constants.getInterfaceMethodrefName(index),
+                                        new Signature(m_constants.getInterfaceMethodrefType(index))
+                                );
+                        }
+                }
+                return null;
+        }
+        
+        public Iterable<CheckCast> casts() {
+                return new Iterable<CheckCast>() {
+                        @Override
+                        public Iterator<CheckCast> iterator() {
+                                return CheckCastIterator.this;
+                        }
+                };
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/ClassRenamer.java b/src/cuchaz/enigma/bytecode/ClassRenamer.java
new file mode 100644
index 0000000..a5fea92
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/ClassRenamer.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Map;
+import java.util.Set;
+
+import javassist.ClassMap;
+import javassist.CtClass;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.InnerClassesAttribute;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class ClassRenamer {
+        
+        public static void renameClasses(CtClass c, Map<ClassEntry,ClassEntry> map) {
+                
+                // build the map used by javassist
+                ClassMap nameMap = new ClassMap();
+                for (Map.Entry<ClassEntry,ClassEntry> entry : map.entrySet()) {
+                        nameMap.put(entry.getKey().getName(), entry.getValue().getName());
+                }
+                
+                c.replaceClassName(nameMap);
+                
+                // replace simple names in the InnerClasses attribute too
+                ConstPool constants = c.getClassFile().getConstPool();
+                InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag);
+                if (attr != null) {
+                        for (int i = 0; i < attr.tableLength(); i++) {
+                                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i)));
+                                if (attr.innerNameIndex(i) != 0) {
+                                        attr.setInnerNameIndex(i, constants.addUtf8Info(classEntry.getInnerClassName()));
+                                }
+                                
+                                /* DEBUG
+                                System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i)));
+                                */
+                        }
+                }
+        }
+        
+        public static Set<ClassEntry> getAllClassEntries(final CtClass c) {
+                
+                // get the classes that javassist knows about
+                final Set<ClassEntry> entries = Sets.newHashSet();
+                ClassMap map = new ClassMap() {
+                        @Override
+                        public Object get(Object obj) {
+                                if (obj instanceof String) {
+                                        String str = (String)obj;
+                                        
+                                        // javassist throws a lot of weird things at this map
+                                        // I either have to implement my on class scanner, or just try to filter out the weirdness
+                                        // I'm opting to filter out the weirdness for now
+                                        
+                                        // skip anything with generic arguments
+                                        if (str.indexOf('<') >= 0 || str.indexOf('>') >= 0 || str.indexOf(';') >= 0) {
+                                                return null;
+                                        }
+                                        
+                                        // convert path/to/class.inner to path/to/class$inner
+                                        str = str.replace('.', '$');
+                                        
+                                        // remember everything else
+                                        entries.add(new ClassEntry(str));
+                                }
+                                return null;
+                        }
+                        
+                        private static final long serialVersionUID = -202160293602070641L;
+                };
+                c.replaceClassName(map);
+                
+                return entries;
+        }
+        
+        public static void moveAllClassesOutOfDefaultPackage(CtClass c, String newPackageName) {
+                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
+                for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) {
+                        if (classEntry.isInDefaultPackage()) {
+                                map.put(classEntry, new ClassEntry(newPackageName + "/" + classEntry.getName()));
+                        }
+                }
+                ClassRenamer.renameClasses(c, map);
+        }
+        
+        public static void moveAllClassesIntoDefaultPackage(CtClass c, String oldPackageName) {
+                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
+                for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) {
+                        if (classEntry.getPackageName().equals(oldPackageName)) {
+                                map.put(classEntry, new ClassEntry(classEntry.getSimpleName()));
+                        }
+                }
+                ClassRenamer.renameClasses(c, map);
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/ClassTranslator.java b/src/cuchaz/enigma/bytecode/ClassTranslator.java
new file mode 100644
index 0000000..afd3a77
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -0,0 +1,144 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Map;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.SourceFileAttribute;
+
+import com.google.common.collect.Maps;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+import cuchaz.enigma.mapping.Translator;
+import cuchaz.enigma.mapping.Type;
+
+public class ClassTranslator {
+        
+        private Translator m_translator;
+        
+        public ClassTranslator(Translator translator) {
+                m_translator = translator;
+        }
+        
+        public void translate(CtClass c) {
+                
+                // NOTE: the order of these translations is very important
+                
+                // translate all the field and method references in the code by editing the constant pool
+                ConstPool constants = c.getClassFile().getConstPool();
+                ConstPoolEditor editor = new ConstPoolEditor(constants);
+                for (int i = 1; i < constants.getSize(); i++) {
+                        switch (constants.getTag(i)) {
+                                
+                                case ConstPool.CONST_Fieldref: {
+                                        
+                                        // translate the name
+                                        FieldEntry entry = new FieldEntry(
+                                                new ClassEntry(Descriptor.toJvmName(constants.getFieldrefClassName(i))),
+                                                constants.getFieldrefName(i)
+                                        );
+                                        FieldEntry translatedEntry = m_translator.translateEntry(entry);
+                                        
+                                        // translate the type
+                                        Type type = new Type(constants.getFieldrefType(i));
+                                        Type translatedType = m_translator.translateType(type);
+                                        
+                                        if (!entry.equals(translatedEntry) || !type.equals(translatedType)) {
+                                                editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedType.toString());
+                                        }
+                                }
+                                break;
+                                
+                                case ConstPool.CONST_Methodref:
+                                case ConstPool.CONST_InterfaceMethodref: {
+                                        
+                                        // translate the name and type
+                                        BehaviorEntry entry = BehaviorEntryFactory.create(
+                                                Descriptor.toJvmName(editor.getMemberrefClassname(i)),
+                                                editor.getMemberrefName(i),
+                                                editor.getMemberrefType(i)
+                                        );
+                                        BehaviorEntry translatedEntry = m_translator.translateEntry(entry);
+                                        
+                                        if (!entry.getName().equals(translatedEntry.getName()) || !entry.getSignature().equals(translatedEntry.getSignature())) {
+                                                editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getSignature().toString());
+                                        }
+                                }
+                                break;
+                        }
+                }
+                
+                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                
+                // translate all the fields
+                for (CtField field : c.getDeclaredFields()) {
+                        
+                        // translate the name
+                        FieldEntry entry = new FieldEntry(classEntry, field.getName());
+                        String translatedName = m_translator.translate(entry);
+                        if (translatedName != null) {
+                                field.setName(translatedName);
+                        }
+                        
+                        // translate the type
+                        Type translatedType = m_translator.translateType(new Type(field.getFieldInfo().getDescriptor()));
+                        field.getFieldInfo().setDescriptor(translatedType.toString());
+                }
+                
+                // translate all the methods and constructors
+                for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                        if (behavior instanceof CtMethod) {
+                                CtMethod method = (CtMethod)behavior;
+                                
+                                // translate the name
+                                MethodEntry entry = JavassistUtil.getMethodEntry(method);
+                                String translatedName = m_translator.translate(entry);
+                                if (translatedName != null) {
+                                        method.setName(translatedName);
+                                }
+                        }
+                        
+                        // translate the type
+                        Signature translatedSignature = m_translator.translateSignature(new Signature(behavior.getMethodInfo().getDescriptor()));
+                        behavior.getMethodInfo().setDescriptor(translatedSignature.toString());
+                }
+                
+                // translate all the class names referenced in the code
+                // the above code only changed method/field/reference names and types, but not the class names themselves
+                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
+                for (ClassEntry obfClassEntry : ClassRenamer.getAllClassEntries(c)) {
+                        ClassEntry deobfClassEntry = m_translator.translateEntry(obfClassEntry);
+                        if (!obfClassEntry.equals(deobfClassEntry)) {
+                                map.put(obfClassEntry, deobfClassEntry);
+                        }
+                }
+                ClassRenamer.renameClasses(c, map);
+                
+                // translate the source file attribute too
+                ClassEntry deobfClassEntry = map.get(classEntry);
+                if (deobfClassEntry != null) {
+                        String sourceFile = Descriptor.toJvmName(deobfClassEntry.getOuterClassName()) + ".java";
+                        c.getClassFile().addAttribute(new SourceFileAttribute(constants, sourceFile));
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/ConstPoolEditor.java b/src/cuchaz/enigma/bytecode/ConstPoolEditor.java
new file mode 100644
index 0000000..2dec3b7
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/ConstPoolEditor.java
@@ -0,0 +1,263 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import cuchaz.enigma.bytecode.accessors.ClassInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MemberRefInfoAccessor;
+
+public class ConstPoolEditor {
+        
+        private static Method m_getItem;
+        private static Method m_addItem;
+        private static Method m_addItem0;
+        private static Field m_items;
+        private static Field m_cache;
+        private static Field m_numItems;
+        private static Field m_objects;
+        private static Field m_elements;
+        private static Method m_methodWritePool;
+        private static Constructor<ConstPool> m_constructorPool;
+        
+        static {
+                try {
+                        m_getItem = ConstPool.class.getDeclaredMethod("getItem", int.class);
+                        m_getItem.setAccessible(true);
+                        
+                        m_addItem = ConstPool.class.getDeclaredMethod("addItem", Class.forName("javassist.bytecode.ConstInfo"));
+                        m_addItem.setAccessible(true);
+                        
+                        m_addItem0 = ConstPool.class.getDeclaredMethod("addItem0", Class.forName("javassist.bytecode.ConstInfo"));
+                        m_addItem0.setAccessible(true);
+                        
+                        m_items = ConstPool.class.getDeclaredField("items");
+                        m_items.setAccessible(true);
+                        
+                        m_cache = ConstPool.class.getDeclaredField("itemsCache");
+                        m_cache.setAccessible(true);
+                        
+                        m_numItems = ConstPool.class.getDeclaredField("numOfItems");
+                        m_numItems.setAccessible(true);
+                        
+                        m_objects = Class.forName("javassist.bytecode.LongVector").getDeclaredField("objects");
+                        m_objects.setAccessible(true);
+                        
+                        m_elements = Class.forName("javassist.bytecode.LongVector").getDeclaredField("elements");
+                        m_elements.setAccessible(true);
+                        
+                        m_methodWritePool = ConstPool.class.getDeclaredMethod("write", DataOutputStream.class);
+                        m_methodWritePool.setAccessible(true);
+                        
+                        m_constructorPool = ConstPool.class.getDeclaredConstructor(DataInputStream.class);
+                        m_constructorPool.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private ConstPool m_pool;
+        
+        public ConstPoolEditor(ConstPool pool) {
+                m_pool = pool;
+        }
+        
+        public void writePool(DataOutputStream out) {
+                try {
+                        m_methodWritePool.invoke(m_pool, out);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static ConstPool readPool(DataInputStream in) {
+                try {
+                        return m_constructorPool.newInstance(in);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public String getMemberrefClassname(int memberrefIndex) {
+                return Descriptor.toJvmName(m_pool.getClassInfo(m_pool.getMemberClass(memberrefIndex)));
+        }
+        
+        public String getMemberrefName(int memberrefIndex) {
+                return m_pool.getUtf8Info(m_pool.getNameAndTypeName(m_pool.getMemberNameAndType(memberrefIndex)));
+        }
+        
+        public String getMemberrefType(int memberrefIndex) {
+                return m_pool.getUtf8Info(m_pool.getNameAndTypeDescriptor(m_pool.getMemberNameAndType(memberrefIndex)));
+        }
+        
+        public ConstInfoAccessor getItem(int index) {
+                try {
+                        Object entry = m_getItem.invoke(m_pool, index);
+                        if (entry == null) {
+                                return null;
+                        }
+                        return new ConstInfoAccessor(entry);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int addItem(Object item) {
+                try {
+                        return (Integer)m_addItem.invoke(m_pool, item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int addItemForceNew(Object item) {
+                try {
+                        return (Integer)m_addItem0.invoke(m_pool, item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        @SuppressWarnings("rawtypes")
+        public void removeLastItem() {
+                try {
+                        // remove the item from the cache
+                        HashMap cache = getCache();
+                        if (cache != null) {
+                                Object item = getItem(m_pool.getSize() - 1);
+                                cache.remove(item);
+                        }
+                        
+                        // remove the actual item
+                        // based off of LongVector.addElement()
+                        Object items = m_items.get(m_pool);
+                        Object[][] objects = (Object[][])m_objects.get(items);
+                        int numElements = (Integer)m_elements.get(items) - 1;
+                        int nth = numElements >> 7;
+                        int offset = numElements & (128 - 1);
+                        objects[nth][offset] = null;
+                        
+                        // decrement the number of items
+                        m_elements.set(items, numElements);
+                        m_numItems.set(m_pool, (Integer)m_numItems.get(m_pool) - 1);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        @SuppressWarnings("rawtypes")
+        public HashMap getCache() {
+                try {
+                        return (HashMap)m_cache.get(m_pool);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        public void changeMemberrefNameAndType(int memberrefIndex, String newName, String newType) {
+                // NOTE: when changing values, we always need to copy-on-write
+                try {
+                        // get the memberref item
+                        Object item = getItem(memberrefIndex).getItem();
+                        
+                        // update the cache
+                        HashMap cache = getCache();
+                        if (cache != null) {
+                                cache.remove(item);
+                        }
+                        
+                        new MemberRefInfoAccessor(item).setNameAndTypeIndex(m_pool.addNameAndTypeInfo(newName, newType));
+                        
+                        // update the cache
+                        if (cache != null) {
+                                cache.put(item, item);
+                        }
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+                
+                // make sure the change worked
+                assert (newName.equals(getMemberrefName(memberrefIndex)));
+                assert (newType.equals(getMemberrefType(memberrefIndex)));
+        }
+        
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        public void changeClassName(int classNameIndex, String newName) {
+                // NOTE: when changing values, we always need to copy-on-write
+                try {
+                        // get the class item
+                        Object item = getItem(classNameIndex).getItem();
+                        
+                        // update the cache
+                        HashMap cache = getCache();
+                        if (cache != null) {
+                                cache.remove(item);
+                        }
+                        
+                        // add the new name and repoint the name-and-type to it
+                        new ClassInfoAccessor(item).setNameIndex(m_pool.addUtf8Info(newName));
+                        
+                        // update the cache
+                        if (cache != null) {
+                                cache.put(item, item);
+                        }
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static ConstPool newConstPool() {
+                // const pool expects the name of a class to initialize itself
+                // but we want an empty pool
+                // so give it a bogus name, and then clear the entries afterwards
+                ConstPool pool = new ConstPool("a");
+                
+                ConstPoolEditor editor = new ConstPoolEditor(pool);
+                int size = pool.getSize();
+                for (int i = 0; i < size - 1; i++) {
+                        editor.removeLastItem();
+                }
+                
+                // make sure the pool is actually empty
+                // although, in this case "empty" means one thing in it
+                // the JVM spec says index 0 should be reserved
+                assert (pool.getSize() == 1);
+                assert (editor.getItem(0) == null);
+                assert (editor.getItem(1) == null);
+                assert (editor.getItem(2) == null);
+                assert (editor.getItem(3) == null);
+                
+                // also, clear the cache
+                editor.getCache().clear();
+                
+                return pool;
+        }
+        
+        public String dump() {
+                StringBuilder buf = new StringBuilder();
+                for (int i = 1; i < m_pool.getSize(); i++) {
+                        buf.append(String.format("%4d", i));
+                        buf.append("   ");
+                        buf.append(getItem(i).toString());
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/InfoType.java b/src/cuchaz/enigma/bytecode/InfoType.java
new file mode 100644
index 0000000..deaf623
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/InfoType.java
@@ -0,0 +1,317 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+import cuchaz.enigma.bytecode.accessors.ClassInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.InvokeDynamicInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MemberRefInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MethodHandleInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.MethodTypeInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.NameAndTypeInfoAccessor;
+import cuchaz.enigma.bytecode.accessors.StringInfoAccessor;
+
+public enum InfoType {
+        
+        Utf8Info( 1, 0 ),
+        IntegerInfo( 3, 0 ),
+        FloatInfo( 4, 0 ),
+        LongInfo( 5, 0 ),
+        DoubleInfo( 6, 0 ),
+        ClassInfo( 7, 1 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getNameIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor(entry.getItem());
+                        accessor.setNameIndex(remapIndex(map, accessor.getNameIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        ClassInfoAccessor accessor = new ClassInfoAccessor(entry.getItem());
+                        ConstInfoAccessor nameEntry = pool.getItem(accessor.getNameIndex());
+                        return nameEntry != null && nameEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        StringInfo( 8, 1 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        StringInfoAccessor accessor = new StringInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getStringIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        StringInfoAccessor accessor = new StringInfoAccessor(entry.getItem());
+                        accessor.setStringIndex(remapIndex(map, accessor.getStringIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        StringInfoAccessor accessor = new StringInfoAccessor(entry.getItem());
+                        ConstInfoAccessor stringEntry = pool.getItem(accessor.getStringIndex());
+                        return stringEntry != null && stringEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        FieldRefInfo( 9, 2 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getClassIndex());
+                        gatherIndexTree(indices, editor, accessor.getNameAndTypeIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor(entry.getItem());
+                        accessor.setClassIndex(remapIndex(map, accessor.getClassIndex()));
+                        accessor.setNameAndTypeIndex(remapIndex(map, accessor.getNameAndTypeIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        MemberRefInfoAccessor accessor = new MemberRefInfoAccessor(entry.getItem());
+                        ConstInfoAccessor classEntry = pool.getItem(accessor.getClassIndex());
+                        ConstInfoAccessor nameAndTypeEntry = pool.getItem(accessor.getNameAndTypeIndex());
+                        return classEntry != null && classEntry.getTag() == ClassInfo.getTag() && nameAndTypeEntry != null && nameAndTypeEntry.getTag() == NameAndTypeInfo.getTag();
+                }
+        },
+        // same as FieldRefInfo
+        MethodRefInfo( 10, 2 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        FieldRefInfo.gatherIndexTree(indices, editor, entry);
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        FieldRefInfo.remapIndices(map, entry);
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        return FieldRefInfo.subIndicesAreValid(entry, pool);
+                }
+        },
+        // same as FieldRefInfo
+        InterfaceMethodRefInfo( 11, 2 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        FieldRefInfo.gatherIndexTree(indices, editor, entry);
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        FieldRefInfo.remapIndices(map, entry);
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        return FieldRefInfo.subIndicesAreValid(entry, pool);
+                }
+        },
+        NameAndTypeInfo( 12, 1 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getNameIndex());
+                        gatherIndexTree(indices, editor, accessor.getTypeIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor(entry.getItem());
+                        accessor.setNameIndex(remapIndex(map, accessor.getNameIndex()));
+                        accessor.setTypeIndex(remapIndex(map, accessor.getTypeIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        NameAndTypeInfoAccessor accessor = new NameAndTypeInfoAccessor(entry.getItem());
+                        ConstInfoAccessor nameEntry = pool.getItem(accessor.getNameIndex());
+                        ConstInfoAccessor typeEntry = pool.getItem(accessor.getTypeIndex());
+                        return nameEntry != null && nameEntry.getTag() == Utf8Info.getTag() && typeEntry != null && typeEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        MethodHandleInfo( 15, 3 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getTypeIndex());
+                        gatherIndexTree(indices, editor, accessor.getMethodRefIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor(entry.getItem());
+                        accessor.setTypeIndex(remapIndex(map, accessor.getTypeIndex()));
+                        accessor.setMethodRefIndex(remapIndex(map, accessor.getMethodRefIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        MethodHandleInfoAccessor accessor = new MethodHandleInfoAccessor(entry.getItem());
+                        ConstInfoAccessor typeEntry = pool.getItem(accessor.getTypeIndex());
+                        ConstInfoAccessor methodRefEntry = pool.getItem(accessor.getMethodRefIndex());
+                        return typeEntry != null && typeEntry.getTag() == Utf8Info.getTag() && methodRefEntry != null && methodRefEntry.getTag() == MethodRefInfo.getTag();
+                }
+        },
+        MethodTypeInfo( 16, 1 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getTypeIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor(entry.getItem());
+                        accessor.setTypeIndex(remapIndex(map, accessor.getTypeIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        MethodTypeInfoAccessor accessor = new MethodTypeInfoAccessor(entry.getItem());
+                        ConstInfoAccessor typeEntry = pool.getItem(accessor.getTypeIndex());
+                        return typeEntry != null && typeEntry.getTag() == Utf8Info.getTag();
+                }
+        },
+        InvokeDynamicInfo( 18, 2 ) {
+                
+                @Override
+                public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor(entry.getItem());
+                        gatherIndexTree(indices, editor, accessor.getBootstrapIndex());
+                        gatherIndexTree(indices, editor, accessor.getNameAndTypeIndex());
+                }
+                
+                @Override
+                public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor(entry.getItem());
+                        accessor.setBootstrapIndex(remapIndex(map, accessor.getBootstrapIndex()));
+                        accessor.setNameAndTypeIndex(remapIndex(map, accessor.getNameAndTypeIndex()));
+                }
+                
+                @Override
+                public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                        InvokeDynamicInfoAccessor accessor = new InvokeDynamicInfoAccessor(entry.getItem());
+                        ConstInfoAccessor bootstrapEntry = pool.getItem(accessor.getBootstrapIndex());
+                        ConstInfoAccessor nameAndTypeEntry = pool.getItem(accessor.getNameAndTypeIndex());
+                        return bootstrapEntry != null && bootstrapEntry.getTag() == Utf8Info.getTag() && nameAndTypeEntry != null && nameAndTypeEntry.getTag() == NameAndTypeInfo.getTag();
+                }
+        };
+        
+        private static Map<Integer,InfoType> m_types;
+        
+        static {
+                m_types = Maps.newTreeMap();
+                for (InfoType type : values()) {
+                        m_types.put(type.getTag(), type);
+                }
+        }
+        
+        private int m_tag;
+        private int m_level;
+        
+        private InfoType(int tag, int level) {
+                m_tag = tag;
+                m_level = level;
+        }
+        
+        public int getTag() {
+                return m_tag;
+        }
+        
+        public int getLevel() {
+                return m_level;
+        }
+        
+        public void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, ConstInfoAccessor entry) {
+                // by default, do nothing
+        }
+        
+        public void remapIndices(Map<Integer,Integer> map, ConstInfoAccessor entry) {
+                // by default, do nothing
+        }
+        
+        public boolean subIndicesAreValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                // by default, everything is good
+                return true;
+        }
+        
+        public boolean selfIndexIsValid(ConstInfoAccessor entry, ConstPoolEditor pool) {
+                ConstInfoAccessor entryCheck = pool.getItem(entry.getIndex());
+                if (entryCheck == null) {
+                        return false;
+                }
+                return entryCheck.getItem().equals(entry.getItem());
+        }
+        
+        public static InfoType getByTag(int tag) {
+                return m_types.get(tag);
+        }
+        
+        public static List<InfoType> getByLevel(int level) {
+                List<InfoType> types = Lists.newArrayList();
+                for (InfoType type : values()) {
+                        if (type.getLevel() == level) {
+                                types.add(type);
+                        }
+                }
+                return types;
+        }
+        
+        public static List<InfoType> getSortedByLevel() {
+                List<InfoType> types = Lists.newArrayList();
+                types.addAll(getByLevel(0));
+                types.addAll(getByLevel(1));
+                types.addAll(getByLevel(2));
+                types.addAll(getByLevel(3));
+                return types;
+        }
+        
+        public static void gatherIndexTree(Collection<Integer> indices, ConstPoolEditor editor, int index) {
+                // add own index
+                indices.add(index);
+                
+                // recurse
+                ConstInfoAccessor entry = editor.getItem(index);
+                entry.getType().gatherIndexTree(indices, editor, entry);
+        }
+        
+        private static int remapIndex(Map<Integer,Integer> map, int index) {
+                Integer newIndex = map.get(index);
+                if (newIndex == null) {
+                        newIndex = index;
+                }
+                return newIndex;
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/InnerClassWriter.java b/src/cuchaz/enigma/bytecode/InnerClassWriter.java
new file mode 100644
index 0000000..817500b
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/InnerClassWriter.java
@@ -0,0 +1,102 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.Collection;
+
+import javassist.CtClass;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.EnclosingMethodAttribute;
+import javassist.bytecode.InnerClassesAttribute;
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class InnerClassWriter {
+        
+        private JarIndex m_jarIndex;
+        
+        public InnerClassWriter(JarIndex jarIndex) {
+                m_jarIndex = jarIndex;
+        }
+        
+        public void write(CtClass c) {
+                
+                // is this an inner or outer class?
+                String obfInnerClassName = new ClassEntry(Descriptor.toJvmName(c.getName())).getSimpleName();
+                String obfOuterClassName = m_jarIndex.getOuterClass(obfInnerClassName);
+                if (obfOuterClassName == null) {
+                        // this is an outer class
+                        obfOuterClassName = Descriptor.toJvmName(c.getName());
+                } else {
+                        // this is an inner class, rename it to outer$inner
+                        ClassEntry obfClassEntry = new ClassEntry(obfOuterClassName + "$" + obfInnerClassName);
+                        c.setName(obfClassEntry.getName());
+                        
+                        BehaviorEntry caller = m_jarIndex.getAnonymousClassCaller(obfInnerClassName);
+                        if (caller != null) {
+                                // write the enclosing method attribute
+                                if (caller.getName().equals("<clinit>")) {
+                                        c.getClassFile().addAttribute(new EnclosingMethodAttribute(c.getClassFile().getConstPool(), caller.getClassName()));
+                                } else {
+                                        c.getClassFile().addAttribute(new EnclosingMethodAttribute(c.getClassFile().getConstPool(), caller.getClassName(), caller.getName(), caller.getSignature().toString()));
+                                }
+                        }
+                }
+                
+                // write the inner classes if needed
+                Collection<String> obfInnerClassNames = m_jarIndex.getInnerClasses(obfOuterClassName);
+                if (obfInnerClassNames != null && !obfInnerClassNames.isEmpty()) {
+                        writeInnerClasses(c, obfOuterClassName, obfInnerClassNames);
+                }
+        }
+        
+        private void writeInnerClasses(CtClass c, String obfOuterClassName, Collection<String> obfInnerClassNames) {
+                InnerClassesAttribute attr = new InnerClassesAttribute(c.getClassFile().getConstPool());
+                c.getClassFile().addAttribute(attr);
+                for (String obfInnerClassName : obfInnerClassNames) {
+                        // get the new inner class name
+                        ClassEntry obfClassEntry = new ClassEntry(obfOuterClassName + "$" + obfInnerClassName);
+                        
+                        // here's what the JVM spec says about the InnerClasses attribute
+                        // append( inner, outer of inner if inner is member of outer 0 ow, name after $ if inner not anonymous 0 ow, flags );
+                        
+                        // update the attribute with this inner class
+                        ConstPool constPool = c.getClassFile().getConstPool();
+                        int innerClassIndex = constPool.addClassInfo(obfClassEntry.getName());
+                        int outerClassIndex = 0;
+                        int innerClassSimpleNameIndex = 0;
+                        if (!m_jarIndex.isAnonymousClass(obfInnerClassName)) {
+                                outerClassIndex = constPool.addClassInfo(obfClassEntry.getOuterClassName());
+                                innerClassSimpleNameIndex = constPool.addUtf8Info(obfClassEntry.getInnerClassName());
+                        }
+                        
+                        attr.append(innerClassIndex, outerClassIndex, innerClassSimpleNameIndex, c.getClassFile().getAccessFlags() & ~AccessFlag.SUPER);
+                        
+                        /* DEBUG 
+                        System.out.println(String.format("\tOBF: %s -> ATTR: %s,%s,%s (replace %s with %s)",
+                                obfClassEntry,
+                                attr.outerClass(attr.tableLength() - 1),
+                                attr.innerClass(attr.tableLength() - 1),
+                                attr.innerName(attr.tableLength() - 1),
+                                Constants.NonePackage + "/" + obfInnerClassName,
+                                obfClassEntry.getName()
+                        ));
+                        */
+                        
+                        // make sure the outer class references only the new inner class names
+                        c.replaceClassName(Constants.NonePackage + "/" + obfInnerClassName, obfClassEntry.getName());
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/MethodParameterWriter.java b/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
new file mode 100644
index 0000000..5d4ca1a
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/MethodParameterWriter.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.BehaviorEntryFactory;
+import cuchaz.enigma.mapping.Translator;
+
+public class MethodParameterWriter {
+        
+        private Translator m_translator;
+        
+        public MethodParameterWriter(Translator translator) {
+                m_translator = translator;
+        }
+        
+        public void writeMethodArguments(CtClass c) {
+                
+                // Procyon will read method arguments from the "MethodParameters" attribute, so write those
+                for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                        BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(behavior);
+
+                        // get the number of arguments
+                        int numParams = behaviorEntry.getSignature().getArgumentTypes().size();
+                        if (numParams <= 0) {
+                                continue;
+                        }
+                        
+                        // get the list of argument names
+                        List<String> names = new ArrayList<String>(numParams);
+                        for (int i = 0; i < numParams; i++) {
+                                names.add(m_translator.translate(new ArgumentEntry(behaviorEntry, i, "")));
+                        }
+                        
+                        // save the mappings to the class
+                        MethodParametersAttribute.updateClass(behavior.getMethodInfo(), names);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
new file mode 100644
index 0000000..bf95956
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/MethodParametersAttribute.java
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import javassist.bytecode.AttributeInfo;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.MethodInfo;
+
+public class MethodParametersAttribute extends AttributeInfo {
+        
+        private MethodParametersAttribute(ConstPool pool, List<Integer> parameterNameIndices) {
+                super(pool, "MethodParameters", writeStruct(parameterNameIndices));
+        }
+        
+        public static void updateClass(MethodInfo info, List<String> names) {
+                // add the names to the class const pool
+                ConstPool constPool = info.getConstPool();
+                List<Integer> parameterNameIndices = new ArrayList<Integer>();
+                for (String name : names) {
+                        if (name != null) {
+                                parameterNameIndices.add(constPool.addUtf8Info(name));
+                        } else {
+                                parameterNameIndices.add(0);
+                        }
+                }
+                
+                // add the attribute to the method
+                info.addAttribute(new MethodParametersAttribute(constPool, parameterNameIndices));
+        }
+        
+        private static byte[] writeStruct(List<Integer> parameterNameIndices) {
+                // JVM 8 Spec says the struct looks like this:
+                // http://cr.openjdk.java.net/~mr/se/8/java-se-8-fr-spec-01/java-se-8-jvms-fr-diffs.pdf
+                // uint8 num_params
+                // for each param:
+                // uint16 name_index -> points to UTF8 entry in constant pool, or 0 for no entry
+                // uint16 access_flags -> don't care, just set to 0
+                
+                ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                DataOutputStream out = new DataOutputStream(buf);
+                
+                // NOTE: java hates unsigned integers, so we have to be careful here
+                // the writeShort(), writeByte() methods will read 16,8 low-order bits from the int argument
+                // as long as the int argument is in range of the unsigned short/byte type, it will be written as an unsigned short/byte
+                // if the int is out of range, the byte stream won't look the way we want and weird things will happen
+                final int SIZEOF_UINT8 = 1;
+                final int SIZEOF_UINT16 = 2;
+                final int MAX_UINT8 = (1 << 8) - 1;
+                final int MAX_UINT16 = (1 << 16) - 1;
+                
+                try {
+                        assert (parameterNameIndices.size() >= 0 && parameterNameIndices.size() <= MAX_UINT8);
+                        out.writeByte(parameterNameIndices.size());
+                        
+                        for (Integer index : parameterNameIndices) {
+                                assert (index >= 0 && index <= MAX_UINT16);
+                                out.writeShort(index);
+                                
+                                // just write 0 for the access flags
+                                out.writeShort(0);
+                        }
+                        
+                        out.close();
+                        byte[] data = buf.toByteArray();
+                        assert (data.length == SIZEOF_UINT8 + parameterNameIndices.size() * (SIZEOF_UINT16 + SIZEOF_UINT16));
+                        return data;
+                } catch (IOException ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
new file mode 100644
index 0000000..d76f056
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/ClassInfoAccessor.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class ClassInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_nameIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.ClassInfo");
+                        m_nameIndex = m_class.getDeclaredField("name");
+                        m_nameIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public ClassInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getNameIndex() {
+                try {
+                        return (Integer)m_nameIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setNameIndex(int val) {
+                try {
+                        m_nameIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
new file mode 100644
index 0000000..d00c102
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/ConstInfoAccessor.java
@@ -0,0 +1,156 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import cuchaz.enigma.bytecode.InfoType;
+
+public class ConstInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_index;
+        private static Method m_getTag;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.ConstInfo");
+                        m_index = m_class.getDeclaredField("index");
+                        m_index.setAccessible(true);
+                        m_getTag = m_class.getMethod("getTag");
+                        m_getTag.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private Object m_item;
+        
+        public ConstInfoAccessor(Object item) {
+                if (item == null) {
+                        throw new IllegalArgumentException("item cannot be null!");
+                }
+                m_item = item;
+        }
+        
+        public ConstInfoAccessor(DataInputStream in) throws IOException {
+                try {
+                        // read the entry
+                        String className = in.readUTF();
+                        int oldIndex = in.readInt();
+                        
+                        // NOTE: ConstInfo instances write a type id (a "tag"), but they don't read it back
+                        // so we have to read it here
+                        in.readByte();
+                        
+                        Constructor<?> constructor = Class.forName(className).getConstructor(DataInputStream.class, int.class);
+                        constructor.setAccessible(true);
+                        m_item = constructor.newInstance(in, oldIndex);
+                } catch (IOException ex) {
+                        throw ex;
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public Object getItem() {
+                return m_item;
+        }
+        
+        public int getIndex() {
+                try {
+                        return (Integer)m_index.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setIndex(int val) {
+                try {
+                        m_index.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getTag() {
+                try {
+                        return (Integer)m_getTag.invoke(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public ConstInfoAccessor copy() {
+                return new ConstInfoAccessor(copyItem());
+        }
+        
+        public Object copyItem() {
+                // I don't know of a simpler way to copy one of these silly things...
+                try {
+                        // serialize the item
+                        ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                        DataOutputStream out = new DataOutputStream(buf);
+                        write(out);
+                        
+                        // deserialize the item
+                        DataInputStream in = new DataInputStream(new ByteArrayInputStream(buf.toByteArray()));
+                        Object item = new ConstInfoAccessor(in).getItem();
+                        in.close();
+                        
+                        return item;
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void write(DataOutputStream out) throws IOException {
+                try {
+                        out.writeUTF(m_item.getClass().getName());
+                        out.writeInt(getIndex());
+                        
+                        Method method = m_item.getClass().getMethod("write", DataOutputStream.class);
+                        method.setAccessible(true);
+                        method.invoke(m_item, out);
+                } catch (IOException ex) {
+                        throw ex;
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        @Override
+        public String toString() {
+                try {
+                        ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                        PrintWriter out = new PrintWriter(buf);
+                        Method print = m_item.getClass().getMethod("print", PrintWriter.class);
+                        print.setAccessible(true);
+                        print.invoke(m_item, out);
+                        out.close();
+                        return buf.toString().replace("\n", "");
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public InfoType getType() {
+                return InfoType.getByTag(getTag());
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
new file mode 100644
index 0000000..0d780ea
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/InvokeDynamicInfoAccessor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class InvokeDynamicInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_bootstrapIndex;
+        private static Field m_nameAndTypeIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.InvokeDynamicInfo");
+                        m_bootstrapIndex = m_class.getDeclaredField("bootstrap");
+                        m_bootstrapIndex.setAccessible(true);
+                        m_nameAndTypeIndex = m_class.getDeclaredField("nameAndType");
+                        m_nameAndTypeIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public InvokeDynamicInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getBootstrapIndex() {
+                try {
+                        return (Integer)m_bootstrapIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setBootstrapIndex(int val) {
+                try {
+                        m_bootstrapIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getNameAndTypeIndex() {
+                try {
+                        return (Integer)m_nameAndTypeIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setNameAndTypeIndex(int val) {
+                try {
+                        m_nameAndTypeIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
new file mode 100644
index 0000000..9fe945f
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MemberRefInfoAccessor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MemberRefInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_classIndex;
+        private static Field m_nameAndTypeIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.MemberrefInfo");
+                        m_classIndex = m_class.getDeclaredField("classIndex");
+                        m_classIndex.setAccessible(true);
+                        m_nameAndTypeIndex = m_class.getDeclaredField("nameAndTypeIndex");
+                        m_nameAndTypeIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public MemberRefInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getClassIndex() {
+                try {
+                        return (Integer)m_classIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setClassIndex(int val) {
+                try {
+                        m_classIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getNameAndTypeIndex() {
+                try {
+                        return (Integer)m_nameAndTypeIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setNameAndTypeIndex(int val) {
+                try {
+                        m_nameAndTypeIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
new file mode 100644
index 0000000..4c95b22
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MethodHandleInfoAccessor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MethodHandleInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_kindIndex;
+        private static Field m_indexIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.MethodHandleInfo");
+                        m_kindIndex = m_class.getDeclaredField("refKind");
+                        m_kindIndex.setAccessible(true);
+                        m_indexIndex = m_class.getDeclaredField("refIndex");
+                        m_indexIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public MethodHandleInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getTypeIndex() {
+                try {
+                        return (Integer)m_kindIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setTypeIndex(int val) {
+                try {
+                        m_kindIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getMethodRefIndex() {
+                try {
+                        return (Integer)m_indexIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setMethodRefIndex(int val) {
+                try {
+                        m_indexIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
new file mode 100644
index 0000000..e151117
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/MethodTypeInfoAccessor.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class MethodTypeInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_descriptorIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.MethodTypeInfo");
+                        m_descriptorIndex = m_class.getDeclaredField("descriptor");
+                        m_descriptorIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public MethodTypeInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getTypeIndex() {
+                try {
+                        return (Integer)m_descriptorIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setTypeIndex(int val) {
+                try {
+                        m_descriptorIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
new file mode 100644
index 0000000..6e82f3e
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/NameAndTypeInfoAccessor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class NameAndTypeInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_nameIndex;
+        private static Field m_typeIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.NameAndTypeInfo");
+                        m_nameIndex = m_class.getDeclaredField("memberName");
+                        m_nameIndex.setAccessible(true);
+                        m_typeIndex = m_class.getDeclaredField("typeDescriptor");
+                        m_typeIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public NameAndTypeInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getNameIndex() {
+                try {
+                        return (Integer)m_nameIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setNameIndex(int val) {
+                try {
+                        m_nameIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public int getTypeIndex() {
+                try {
+                        return (Integer)m_typeIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setTypeIndex(int val) {
+                try {
+                        m_typeIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
new file mode 100644
index 0000000..6665ffe
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/StringInfoAccessor.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+import java.lang.reflect.Field;
+
+public class StringInfoAccessor {
+        
+        private static Class<?> m_class;
+        private static Field m_stringIndex;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.StringInfo");
+                        m_stringIndex = m_class.getDeclaredField("string");
+                        m_stringIndex.setAccessible(true);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+        
+        private Object m_item;
+        
+        public StringInfoAccessor(Object item) {
+                m_item = item;
+        }
+        
+        public int getStringIndex() {
+                try {
+                        return (Integer)m_stringIndex.get(m_item);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public void setStringIndex(int val) {
+                try {
+                        m_stringIndex.set(m_item, val);
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java b/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
new file mode 100644
index 0000000..2abf60b
--- /dev/null
+++ b/src/cuchaz/enigma/bytecode/accessors/Utf8InfoAccessor.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.bytecode.accessors;
+
+public class Utf8InfoAccessor {
+        
+        private static Class<?> m_class;
+        
+        static {
+                try {
+                        m_class = Class.forName("javassist.bytecode.Utf8Info");
+                } catch (Exception ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        public static boolean isType(ConstInfoAccessor accessor) {
+                return m_class.isAssignableFrom(accessor.getItem().getClass());
+        }
+}
diff --git a/src/cuchaz/enigma/convert/ClassIdentity.java b/src/cuchaz/enigma/convert/ClassIdentity.java
new file mode 100644
index 0000000..1be6123
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassIdentity.java
@@ -0,0 +1,411 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Map;
+
+import javassist.CannotCompileException;
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.Opcode;
+import javassist.expr.ConstructorCall;
+import javassist.expr.ExprEditor;
+import javassist.expr.FieldAccess;
+import javassist.expr.MethodCall;
+import javassist.expr.NewExpr;
+
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multiset;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.Util;
+import cuchaz.enigma.analysis.ClassImplementationsTreeNode;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.bytecode.ConstPoolEditor;
+import cuchaz.enigma.bytecode.InfoType;
+import cuchaz.enigma.bytecode.accessors.ConstInfoAccessor;
+import cuchaz.enigma.convert.ClassNamer.SidedClassNamer;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassNameReplacer;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.Signature;
+
+public class ClassIdentity {
+        
+        private ClassEntry m_classEntry;
+        private SidedClassNamer m_namer;
+        private Multiset<String> m_fields;
+        private Multiset<String> m_methods;
+        private Multiset<String> m_constructors;
+        private String m_staticInitializer;
+        private String m_extends;
+        private Multiset<String> m_implements;
+        private Multiset<String> m_implementations;
+        private Multiset<String> m_references;
+        
+        public ClassIdentity(CtClass c, SidedClassNamer namer, JarIndex index, boolean useReferences) {
+                m_namer = namer;
+                
+                // stuff from the bytecode
+                
+                m_classEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
+                m_fields = HashMultiset.create();
+                for (CtField field : c.getDeclaredFields()) {
+                        m_fields.add(scrubSignature(field.getSignature()));
+                }
+                m_methods = HashMultiset.create();
+                for (CtMethod method : c.getDeclaredMethods()) {
+                        m_methods.add(scrubSignature(method.getSignature()) + "0x" + getBehaviorSignature(method));
+                }
+                m_constructors = HashMultiset.create();
+                for (CtConstructor constructor : c.getDeclaredConstructors()) {
+                        m_constructors.add(scrubSignature(constructor.getSignature()) + "0x" + getBehaviorSignature(constructor));
+                }
+                m_staticInitializer = "";
+                if (c.getClassInitializer() != null) {
+                        m_staticInitializer = getBehaviorSignature(c.getClassInitializer());
+                }
+                m_extends = "";
+                if (c.getClassFile().getSuperclass() != null) {
+                        m_extends = scrubClassName(c.getClassFile().getSuperclass());
+                }
+                m_implements = HashMultiset.create();
+                for (String interfaceName : c.getClassFile().getInterfaces()) {
+                        m_implements.add(scrubClassName(interfaceName));
+                }
+                
+                // stuff from the jar index
+                
+                m_implementations = HashMultiset.create();
+                ClassImplementationsTreeNode implementationsNode = index.getClassImplementations(null, m_classEntry);
+                if (implementationsNode != null) {
+                        @SuppressWarnings("unchecked")
+                        Enumeration<ClassImplementationsTreeNode> implementations = implementationsNode.children();
+                        while (implementations.hasMoreElements()) {
+                                ClassImplementationsTreeNode node = implementations.nextElement();
+                                m_implementations.add(scrubClassName(node.getClassEntry().getName()));
+                        }
+                }
+                
+                m_references = HashMultiset.create();
+                if (useReferences) {
+                        for (CtField field : c.getDeclaredFields()) {
+                                FieldEntry fieldEntry = new FieldEntry(m_classEntry, field.getName());
+                                for (EntryReference<FieldEntry,BehaviorEntry> reference : index.getFieldReferences(fieldEntry)) {
+                                        addReference(reference);
+                                }
+                        }
+                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                BehaviorEntry behaviorEntry = JavassistUtil.getBehaviorEntry(behavior);
+                                for (EntryReference<BehaviorEntry,BehaviorEntry> reference : index.getBehaviorReferences(behaviorEntry)) {
+                                        addReference(reference);
+                                }
+                        }
+                }
+        }
+        
+        private void addReference(EntryReference<? extends Entry,BehaviorEntry> reference) {
+                if (reference.context.getSignature() != null) {
+                        m_references.add(String.format("%s_%s", scrubClassName(reference.context.getClassName()), scrubSignature(reference.context.getSignature())));
+                } else {
+                        m_references.add(String.format("%s_<clinit>", scrubClassName(reference.context.getClassName())));
+                }
+        }
+        
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("class: ");
+                buf.append(m_classEntry.getName());
+                buf.append(" ");
+                buf.append(hashCode());
+                buf.append("\n");
+                for (String field : m_fields) {
+                        buf.append("\tfield ");
+                        buf.append(field);
+                        buf.append("\n");
+                }
+                for (String method : m_methods) {
+                        buf.append("\tmethod ");
+                        buf.append(method);
+                        buf.append("\n");
+                }
+                for (String constructor : m_constructors) {
+                        buf.append("\tconstructor ");
+                        buf.append(constructor);
+                        buf.append("\n");
+                }
+                if (m_staticInitializer.length() > 0) {
+                        buf.append("\tinitializer ");
+                        buf.append(m_staticInitializer);
+                        buf.append("\n");
+                }
+                if (m_extends.length() > 0) {
+                        buf.append("\textends ");
+                        buf.append(m_extends);
+                        buf.append("\n");
+                }
+                for (String interfaceName : m_implements) {
+                        buf.append("\timplements ");
+                        buf.append(interfaceName);
+                        buf.append("\n");
+                }
+                for (String implementation : m_implementations) {
+                        buf.append("\timplemented by ");
+                        buf.append(implementation);
+                        buf.append("\n");
+                }
+                for (String reference : m_references) {
+                        buf.append("\treference ");
+                        buf.append(reference);
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+        
+        private String scrubClassName(String className) {
+                return scrubSignature("L" + Descriptor.toJvmName(className) + ";");
+        }
+        
+        private String scrubSignature(String signature) {
+                return scrubSignature(new Signature(signature));
+        }
+        
+        private String scrubSignature(Signature signature) {
+                
+                return new Signature(signature, new ClassNameReplacer() {
+                        
+                        private Map<String,String> m_classNames = Maps.newHashMap();
+                        
+                        @Override
+                        public String replace(String className) {
+                                
+                                // classes not in the none package can be passed through
+                                ClassEntry classEntry = new ClassEntry(className);
+                                if (!classEntry.getPackageName().equals(Constants.NonePackage)) {
+                                        return className;
+                                }
+                                
+                                // is this class ourself?
+                                if (className.equals(m_classEntry.getName())) {
+                                        return "CSelf";
+                                }
+                                
+                                // try the namer
+                                if (m_namer != null) {
+                                        String newName = m_namer.getName(className);
+                                        if (newName != null) {
+                                                return newName;
+                                        }
+                                }
+                                
+                                // otherwise, use local naming
+                                if (!m_classNames.containsKey(className)) {
+                                        m_classNames.put(className, getNewClassName());
+                                }
+                                return m_classNames.get(className);
+                        }
+                        
+                        private String getNewClassName() {
+                                return String.format("C%03d", m_classNames.size());
+                        }
+                }).toString();
+        }
+        
+        private boolean isClassMatchedUniquely(String className) {
+                return m_namer != null && m_namer.getName(Descriptor.toJvmName(className)) != null;
+        }
+        
+        private String getBehaviorSignature(CtBehavior behavior) {
+                try {
+                        // does this method have an implementation?
+                        if (behavior.getMethodInfo().getCodeAttribute() == null) {
+                                return "(none)";
+                        }
+                        
+                        // compute the hash from the opcodes
+                        ConstPool constants = behavior.getMethodInfo().getConstPool();
+                        final MessageDigest digest = MessageDigest.getInstance("MD5");
+                        CodeIterator iter = behavior.getMethodInfo().getCodeAttribute().iterator();
+                        while (iter.hasNext()) {
+                                int pos = iter.next();
+                                
+                                // update the hash with the opcode
+                                int opcode = iter.byteAt(pos);
+                                digest.update((byte)opcode);
+                                
+                                switch (opcode) {
+                                        case Opcode.LDC: {
+                                                int constIndex = iter.byteAt(pos + 1);
+                                                updateHashWithConstant(digest, constants, constIndex);
+                                        }
+                                        break;
+                                        
+                                        case Opcode.LDC_W:
+                                        case Opcode.LDC2_W: {
+                                                int constIndex = (iter.byteAt(pos + 1) << 8) | iter.byteAt(pos + 2);
+                                                updateHashWithConstant(digest, constants, constIndex);
+                                        }
+                                        break;
+                                }
+                        }
+                        
+                        // update hash with method and field accesses
+                        behavior.instrument(new ExprEditor() {
+                                @Override
+                                public void edit(MethodCall call) {
+                                        updateHashWithString(digest, scrubClassName(call.getClassName()));
+                                        updateHashWithString(digest, scrubSignature(call.getSignature()));
+                                        if (isClassMatchedUniquely(call.getClassName())) {
+                                                updateHashWithString(digest, call.getMethodName());
+                                        }
+                                }
+                                
+                                @Override
+                                public void edit(FieldAccess access) {
+                                        updateHashWithString(digest, scrubClassName(access.getClassName()));
+                                        updateHashWithString(digest, scrubSignature(access.getSignature()));
+                                        if (isClassMatchedUniquely(access.getClassName())) {
+                                                updateHashWithString(digest, access.getFieldName());
+                                        }
+                                }
+                                
+                                @Override
+                                public void edit(ConstructorCall call) {
+                                        updateHashWithString(digest, scrubClassName(call.getClassName()));
+                                        updateHashWithString(digest, scrubSignature(call.getSignature()));
+                                }
+                                
+                                @Override
+                                public void edit(NewExpr expr) {
+                                        updateHashWithString(digest, scrubClassName(expr.getClassName()));
+                                }
+                        });
+                        
+                        // convert the hash to a hex string
+                        return toHex(digest.digest());
+                } catch (BadBytecode | NoSuchAlgorithmException | CannotCompileException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private void updateHashWithConstant(MessageDigest digest, ConstPool constants, int index) {
+                ConstPoolEditor editor = new ConstPoolEditor(constants);
+                ConstInfoAccessor item = editor.getItem(index);
+                if (item.getType() == InfoType.StringInfo) {
+                        updateHashWithString(digest, constants.getStringInfo(index));
+                }
+                // TODO: other constants
+        }
+        
+        private void updateHashWithString(MessageDigest digest, String val) {
+                try {
+                        digest.update(val.getBytes("UTF8"));
+                } catch (UnsupportedEncodingException ex) {
+                        throw new Error(ex);
+                }
+        }
+        
+        private String toHex(byte[] bytes) {
+                // function taken from:
+                // http://stackoverflow.com/questions/9655181/convert-from-byte-array-to-hex-string-in-java
+                final char[] hexArray = "0123456789ABCDEF".toCharArray();
+                char[] hexChars = new char[bytes.length * 2];
+                for (int j = 0; j < bytes.length; j++) {
+                        int v = bytes[j] & 0xFF;
+                        hexChars[j * 2] = hexArray[v >>> 4];
+                        hexChars[j * 2 + 1] = hexArray[v & 0x0F];
+                }
+                return new String(hexChars);
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ClassIdentity) {
+                        return equals((ClassIdentity)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ClassIdentity other) {
+                return m_fields.equals(other.m_fields)
+                        && m_methods.equals(other.m_methods)
+                        && m_constructors.equals(other.m_constructors)
+                        && m_staticInitializer.equals(other.m_staticInitializer)
+                        && m_extends.equals(other.m_extends)
+                        && m_implements.equals(other.m_implements)
+                        && m_implementations.equals(other.m_implementations)
+                        && m_references.equals(other.m_references);
+        }
+        
+        @Override
+        public int hashCode() {
+                List<Object> objs = Lists.newArrayList();
+                objs.addAll(m_fields);
+                objs.addAll(m_methods);
+                objs.addAll(m_constructors);
+                objs.add(m_staticInitializer);
+                objs.add(m_extends);
+                objs.addAll(m_implements);
+                objs.addAll(m_implementations);
+                objs.addAll(m_references);
+                return Util.combineHashesOrdered(objs);
+        }
+        
+        public int getMatchScore(ClassIdentity other) {
+                return getNumMatches(m_fields, other.m_fields) 
+                        + getNumMatches(m_methods, other.m_methods)
+                        + getNumMatches(m_constructors, other.m_constructors);
+        }
+        
+        public int getMaxMatchScore() {
+                return m_fields.size() + m_methods.size() + m_constructors.size();
+        }
+        
+        public boolean matches(CtClass c) {
+                // just compare declaration counts
+                return m_fields.size() == c.getDeclaredFields().length
+                        && m_methods.size() == c.getDeclaredMethods().length
+                        && m_constructors.size() == c.getDeclaredConstructors().length;
+        }
+        
+        private int getNumMatches(Multiset<String> a, Multiset<String> b) {
+                int numMatches = 0;
+                for (String val : a) {
+                        if (b.contains(val)) {
+                                numMatches++;
+                        }
+                }
+                return numMatches;
+        }
+}
diff --git a/src/cuchaz/enigma/convert/ClassMatcher.java b/src/cuchaz/enigma/convert/ClassMatcher.java
new file mode 100644
index 0000000..ccf6b78
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassMatcher.java
@@ -0,0 +1,406 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.jar.JarFile;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.TranslatingTypeLoader;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.convert.ClassNamer.SidedClassNamer;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassMapping;
+import cuchaz.enigma.mapping.JavassistUtil;
+import cuchaz.enigma.mapping.MappingParseException;
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsReader;
+import cuchaz.enigma.mapping.MappingsWriter;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.MethodMapping;
+
+public class ClassMatcher {
+        
+        public static void main(String[] args) throws IOException, MappingParseException {
+                // TEMP
+                JarFile sourceJar = new JarFile(new File("input/1.8-pre3.jar"));
+                JarFile destJar = new JarFile(new File("input/1.8.jar"));
+                File inMappingsFile = new File("../Enigma Mappings/1.8-pre3.mappings");
+                File outMappingsFile = new File("../Enigma Mappings/1.8.mappings");
+                
+                // define a matching to use when the automated system cannot find a match
+                Map<String,String> fallbackMatching = Maps.newHashMap();
+                fallbackMatching.put("none/ayb", "none/ayf");
+                fallbackMatching.put("none/ayd", "none/ayd");
+                fallbackMatching.put("none/bgk", "unknown/bgk");
+                
+                // do the conversion
+                Mappings mappings = new MappingsReader().read(new FileReader(inMappingsFile));
+                convertMappings(sourceJar, destJar, mappings, fallbackMatching);
+                
+                // write out the converted mappings
+                FileWriter writer = new FileWriter(outMappingsFile);
+                new MappingsWriter().write(writer, mappings);
+                writer.close();
+                System.out.println("Wrote converted mappings to:\n\t" + outMappingsFile.getAbsolutePath());
+        }
+        
+        private static void convertMappings(JarFile sourceJar, JarFile destJar, Mappings mappings, Map<String,String> fallbackMatching) {
+                // index jars
+                System.out.println("Indexing source jar...");
+                JarIndex sourceIndex = new JarIndex();
+                sourceIndex.indexJar(sourceJar, false);
+                System.out.println("Indexing dest jar...");
+                JarIndex destIndex = new JarIndex();
+                destIndex.indexJar(destJar, false);
+                TranslatingTypeLoader sourceLoader = new TranslatingTypeLoader(sourceJar, sourceIndex);
+                TranslatingTypeLoader destLoader = new TranslatingTypeLoader(destJar, destIndex);
+                
+                // compute the matching
+                ClassMatching matching = computeMatching(sourceIndex, sourceLoader, destIndex, destLoader);
+                Map<String,Map.Entry<ClassIdentity,List<ClassIdentity>>> matchingIndex = matching.getIndex();
+                
+                // get all the obf class names used in the mappings
+                Set<String> usedClassNames = mappings.getAllObfClassNames();
+                Set<String> allClassNames = Sets.newHashSet();
+                for (ClassEntry classEntry : sourceIndex.getObfClassEntries()) {
+                        allClassNames.add(classEntry.getName());
+                }
+                usedClassNames.retainAll(allClassNames);
+                System.out.println("Used " + usedClassNames.size() + " classes in the mappings");
+                
+                // probabilistically match the non-uniquely-matched source classes
+                for (Map.Entry<ClassIdentity,List<ClassIdentity>> entry : matchingIndex.values()) {
+                        ClassIdentity sourceClass = entry.getKey();
+                        List<ClassIdentity> destClasses = entry.getValue();
+                        
+                        // skip classes that are uniquely matched
+                        if (destClasses.size() == 1) {
+                                continue;
+                        }
+                        
+                        // skip classes that aren't used in the mappings
+                        if (!usedClassNames.contains(sourceClass.getClassEntry().getName())) {
+                                continue;
+                        }
+                        
+                        System.out.println("No exact match for source class " + sourceClass.getClassEntry());
+                        
+                        // find the closest classes
+                        Multimap<Integer,ClassIdentity> scoredMatches = ArrayListMultimap.create();
+                        for (ClassIdentity c : destClasses) {
+                                scoredMatches.put(sourceClass.getMatchScore(c), c);
+                        }
+                        List<Integer> scores = new ArrayList<Integer>(scoredMatches.keySet());
+                        Collections.sort(scores, Collections.reverseOrder());
+                        printScoredMatches(sourceClass.getMaxMatchScore(), scores, scoredMatches);
+                        
+                        // does the best match have a non-zero score and the same name?
+                        int bestScore = scores.get(0);
+                        Collection<ClassIdentity> bestMatches = scoredMatches.get(bestScore);
+                        if (bestScore > 0 && bestMatches.size() == 1) {
+                                ClassIdentity bestMatch = bestMatches.iterator().next();
+                                if (bestMatch.getClassEntry().equals(sourceClass.getClassEntry())) {
+                                        // use it
+                                        System.out.println("\tAutomatically choosing likely match: " + bestMatch.getClassEntry().getName());
+                                        destClasses.clear();
+                                        destClasses.add(bestMatch);
+                                }
+                        }
+                }
+                
+                // group the matching into unique and non-unique matches
+                BiMap<String,String> matchedClassNames = HashBiMap.create();
+                Set<String> unmatchedSourceClassNames = Sets.newHashSet();
+                for (String className : usedClassNames) {
+                        // is there a match for this class?
+                        Map.Entry<ClassIdentity,List<ClassIdentity>> entry = matchingIndex.get(className);
+                        ClassIdentity sourceClass = entry.getKey();
+                        List<ClassIdentity> matches = entry.getValue();
+                        
+                        if (matches.size() == 1) {
+                                // unique match! We're good to go!
+                                matchedClassNames.put(sourceClass.getClassEntry().getName(), matches.get(0).getClassEntry().getName());
+                        } else {
+                                // no match, check the fallback matching
+                                String fallbackMatch = fallbackMatching.get(className);
+                                if (fallbackMatch != null) {
+                                        matchedClassNames.put(sourceClass.getClassEntry().getName(), fallbackMatch);
+                                } else {
+                                        unmatchedSourceClassNames.add(className);
+                                }
+                        }
+                }
+                
+                // report unmatched classes
+                if (!unmatchedSourceClassNames.isEmpty()) {
+                        System.err.println("ERROR: there were unmatched classes!");
+                        for (String className : unmatchedSourceClassNames) {
+                                System.err.println("\t" + className);
+                        }
+                        return;
+                }
+                
+                // get the class name changes from the matched class names
+                Map<String,String> classChanges = Maps.newHashMap();
+                for (Map.Entry<String,String> entry : matchedClassNames.entrySet()) {
+                        if (!entry.getKey().equals(entry.getValue())) {
+                                classChanges.put(entry.getKey(), entry.getValue());
+                                System.out.println(String.format("Class change: %s -> %s", entry.getKey(), entry.getValue()));
+                                /* DEBUG
+                                System.out.println(String.format("\n%s\n%s",
+                                        new ClassIdentity(sourceLoader.loadClass(entry.getKey()), null, sourceIndex, false, false),
+                                        new ClassIdentity( destLoader.loadClass(entry.getValue()), null, destIndex, false, false)
+                                ));
+                                */
+                        }
+                }
+                
+                // sort the changes so classes are renamed in the correct order
+                // ie. if we have the mappings a->b, b->c, we have to apply b->c before a->b
+                LinkedHashMap<String,String> orderedClassChanges = Maps.newLinkedHashMap();
+                int numChangesLeft = classChanges.size();
+                while (!classChanges.isEmpty()) {
+                        Iterator<Map.Entry<String,String>> iter = classChanges.entrySet().iterator();
+                        while (iter.hasNext()) {
+                                Map.Entry<String,String> entry = iter.next();
+                                if (classChanges.get(entry.getValue()) == null) {
+                                        orderedClassChanges.put(entry.getKey(), entry.getValue());
+                                        iter.remove();
+                                }
+                        }
+                        
+                        // did we remove any changes?
+                        if (numChangesLeft - classChanges.size() > 0) {
+                                // keep going
+                                numChangesLeft = classChanges.size();
+                        } else {
+                                // can't sort anymore. There must be a loop
+                                break;
+                        }
+                }
+                if (classChanges.size() > 0) {
+                        throw new Error(String.format("Unable to sort %d/%d class changes!", classChanges.size(), matchedClassNames.size()));
+                }
+                
+                // convert the mappings in the correct class order
+                for (Map.Entry<String,String> entry : orderedClassChanges.entrySet()) {
+                        mappings.renameObfClass(entry.getKey(), entry.getValue());
+                }
+                
+                // check the method matches
+                System.out.println("Checking methods...");
+                for (ClassMapping classMapping : mappings.classes()) {
+                        ClassEntry classEntry = new ClassEntry(classMapping.getObfName());
+                        for (MethodMapping methodMapping : classMapping.methods()) {
+                                
+                                // skip constructors
+                                if (methodMapping.getObfName().equals("<init>")) {
+                                        continue;
+                                }
+                                
+                                MethodEntry methodEntry = new MethodEntry(
+                                        classEntry,
+                                        methodMapping.getObfName(),
+                                        methodMapping.getObfSignature()
+                                );
+                                if (!destIndex.containsObfBehavior(methodEntry)) {
+                                        System.err.println("WARNING: method doesn't match: " + methodEntry);
+                                        
+                                        // show the available methods
+                                        System.err.println("\tAvailable dest methods:");
+                                        CtClass c = destLoader.loadClass(classMapping.getObfName());
+                                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                                System.err.println("\t\t" + JavassistUtil.getBehaviorEntry(behavior));
+                                        }
+                                        
+                                        System.err.println("\tAvailable source methods:");
+                                        c = sourceLoader.loadClass(matchedClassNames.inverse().get(classMapping.getObfName()));
+                                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
+                                                System.err.println("\t\t" + JavassistUtil.getBehaviorEntry(behavior));
+                                        }
+                                }
+                        }
+                }
+                
+                System.out.println("Done!");
+        }
+        
+        public static ClassMatching computeMatching(JarIndex sourceIndex, TranslatingTypeLoader sourceLoader, JarIndex destIndex, TranslatingTypeLoader destLoader) {
+                
+                System.out.println("Matching classes...");
+                
+                ClassMatching matching = null;
+                for (boolean useReferences : Arrays.asList(false, true)) {
+                        int numMatches = 0;
+                        do {
+                                SidedClassNamer sourceNamer = null;
+                                SidedClassNamer destNamer = null;
+                                if (matching != null) {
+                                        // build a class namer
+                                        ClassNamer namer = new ClassNamer(matching.getUniqueMatches());
+                                        sourceNamer = namer.getSourceNamer();
+                                        destNamer = namer.getDestNamer();
+                                        
+                                        // note the number of matches
+                                        numMatches = matching.getUniqueMatches().size();
+                                }
+                                
+                                // get the entries left to match
+                                Set<ClassEntry> sourceClassEntries = Sets.newHashSet();
+                                Set<ClassEntry> destClassEntries = Sets.newHashSet();
+                                if (matching == null) {
+                                        sourceClassEntries.addAll(sourceIndex.getObfClassEntries());
+                                        destClassEntries.addAll(destIndex.getObfClassEntries());
+                                        matching = new ClassMatching();
+                                } else {
+                                        for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : matching.getAmbiguousMatches().entrySet()) {
+                                                for (ClassIdentity c : entry.getKey()) {
+                                                        sourceClassEntries.add(c.getClassEntry());
+                                                        matching.removeSource(c);
+                                                }
+                                                for (ClassIdentity c : entry.getValue()) {
+                                                        destClassEntries.add(c.getClassEntry());
+                                                        matching.removeDest(c);
+                                                }
+                                        }
+                                        for (ClassIdentity c : matching.getUnmatchedSourceClasses()) {
+                                                sourceClassEntries.add(c.getClassEntry());
+                                                matching.removeSource(c);
+                                        }
+                                        for (ClassIdentity c : matching.getUnmatchedDestClasses()) {
+                                                destClassEntries.add(c.getClassEntry());
+                                                matching.removeDest(c);
+                                        }
+                                }
+                                
+                                // compute a matching for the classes
+                                for (ClassEntry classEntry : sourceClassEntries) {
+                                        CtClass c = sourceLoader.loadClass(classEntry.getName());
+                                        ClassIdentity sourceClass = new ClassIdentity(c, sourceNamer, sourceIndex, useReferences);
+                                        matching.addSource(sourceClass);
+                                }
+                                for (ClassEntry classEntry : destClassEntries) {
+                                        CtClass c = destLoader.loadClass(classEntry.getName());
+                                        ClassIdentity destClass = new ClassIdentity(c, destNamer, destIndex, useReferences);
+                                        matching.matchDestClass(destClass);
+                                }
+                                
+                                // TEMP
+                                System.out.println(matching);
+                        } while (matching.getUniqueMatches().size() - numMatches > 0);
+                }
+                
+                // check the class matches
+                System.out.println("Checking class matches...");
+                ClassNamer namer = new ClassNamer(matching.getUniqueMatches());
+                SidedClassNamer sourceNamer = namer.getSourceNamer();
+                SidedClassNamer destNamer = namer.getDestNamer();
+                for (Map.Entry<ClassIdentity,ClassIdentity> entry : matching.getUniqueMatches().entrySet()) {
+                        
+                        // check source
+                        ClassIdentity sourceClass = entry.getKey();
+                        CtClass sourceC = sourceLoader.loadClass(sourceClass.getClassEntry().getName());
+                        assert (sourceC != null) : "Unable to load source class " + sourceClass.getClassEntry();
+                        assert (sourceClass.matches(sourceC)) : "Source " + sourceClass + " doesn't match " + new ClassIdentity(sourceC, sourceNamer, sourceIndex, false);
+                        
+                        // check dest
+                        ClassIdentity destClass = entry.getValue();
+                        CtClass destC = destLoader.loadClass(destClass.getClassEntry().getName());
+                        assert (destC != null) : "Unable to load dest class " + destClass.getClassEntry();
+                        assert (destClass.matches(destC)) : "Dest " + destClass + " doesn't match " + new ClassIdentity(destC, destNamer, destIndex, false);
+                }
+                
+                // warn about the ambiguous matchings
+                List<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>> ambiguousMatches = new ArrayList<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>>(matching.getAmbiguousMatches().entrySet());
+                Collections.sort(ambiguousMatches, new Comparator<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>>() {
+                        @Override
+                        public int compare(Map.Entry<List<ClassIdentity>,List<ClassIdentity>> a, Map.Entry<List<ClassIdentity>,List<ClassIdentity>> b) {
+                                String aName = a.getKey().get(0).getClassEntry().getName();
+                                String bName = b.getKey().get(0).getClassEntry().getName();
+                                return aName.compareTo(bName);
+                        }
+                });
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : ambiguousMatches) {
+                        System.out.println("Ambiguous matching:");
+                        System.out.println("\tSource: " + getClassNames(entry.getKey()));
+                        System.out.println("\tDest:   " + getClassNames(entry.getValue()));
+                }
+                
+                /* DEBUG
+                Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry = ambiguousMatches.get( 7 );
+                for (ClassIdentity c : entry.getKey()) {
+                        System.out.println(c);
+                }
+                for(ClassIdentity c : entry.getKey()) {
+                        System.out.println(decompile(sourceLoader, c.getClassEntry())); 
+                }
+                */
+                
+                return matching;
+        }
+        
+        private static void printScoredMatches(int maxScore, List<Integer> scores, Multimap<Integer,ClassIdentity> scoredMatches) {
+                int numScoredMatchesShown = 0;
+                for (int score : scores) {
+                        for (ClassIdentity scoredMatch : scoredMatches.get(score)) {
+                                System.out.println(String.format("\tScore: %3d %3.0f%%   %s", score, 100.0 * score / maxScore, scoredMatch.getClassEntry().getName()));
+                                if (numScoredMatchesShown++ > 10) {
+                                        return;
+                                }
+                        }
+                }
+        }
+        
+        private static List<String> getClassNames(Collection<ClassIdentity> classes) {
+                List<String> out = Lists.newArrayList();
+                for (ClassIdentity c : classes) {
+                        out.add(c.getClassEntry().getName());
+                }
+                Collections.sort(out);
+                return out;
+        }
+        
+        /* DEBUG
+        private static String decompile(TranslatingTypeLoader loader, ClassEntry classEntry) {
+                PlainTextOutput output = new PlainTextOutput();
+                DecompilerSettings settings = DecompilerSettings.javaDefaults();
+                settings.setForceExplicitImports(true);
+                settings.setShowSyntheticMembers(true);
+                settings.setTypeLoader(loader);
+                Decompiler.decompile(classEntry.getName(), output, settings);
+                return output.toString();
+        }
+        */
+}
diff --git a/src/cuchaz/enigma/convert/ClassMatching.java b/src/cuchaz/enigma/convert/ClassMatching.java
new file mode 100644
index 0000000..53b6f7f
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassMatching.java
@@ -0,0 +1,173 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+
+public class ClassMatching {
+        
+        private Multimap<ClassIdentity,ClassIdentity> m_sourceClasses;
+        private Multimap<ClassIdentity,ClassIdentity> m_matchedDestClasses;
+        private List<ClassIdentity> m_unmatchedDestClasses;
+        
+        public ClassMatching() {
+                m_sourceClasses = ArrayListMultimap.create();
+                m_matchedDestClasses = ArrayListMultimap.create();
+                m_unmatchedDestClasses = Lists.newArrayList();
+        }
+        
+        public void addSource(ClassIdentity c) {
+                m_sourceClasses.put(c, c);
+        }
+        
+        public void matchDestClass(ClassIdentity destClass) {
+                Collection<ClassIdentity> matchedSourceClasses = m_sourceClasses.get(destClass);
+                if (matchedSourceClasses.isEmpty()) {
+                        // no match
+                        m_unmatchedDestClasses.add(destClass);
+                } else {
+                        // found a match
+                        m_matchedDestClasses.put(destClass, destClass);
+                        
+                        // DEBUG
+                        ClassIdentity sourceClass = matchedSourceClasses.iterator().next();
+                        assert (sourceClass.hashCode() == destClass.hashCode());
+                        assert (sourceClass.equals(destClass));
+                }
+        }
+        
+        public void removeSource(ClassIdentity sourceClass) {
+                m_sourceClasses.remove(sourceClass, sourceClass);
+        }
+        
+        public void removeDest(ClassIdentity destClass) {
+                m_matchedDestClasses.remove(destClass, destClass);
+                m_unmatchedDestClasses.remove(destClass);
+        }
+        
+        public List<ClassIdentity> getSourceClasses() {
+                return new ArrayList<ClassIdentity>(m_sourceClasses.values());
+        }
+        
+        public List<ClassIdentity> getDestClasses() {
+                List<ClassIdentity> classes = Lists.newArrayList();
+                classes.addAll(m_matchedDestClasses.values());
+                classes.addAll(m_unmatchedDestClasses);
+                return classes;
+        }
+        
+        public BiMap<ClassIdentity,ClassIdentity> getUniqueMatches() {
+                BiMap<ClassIdentity,ClassIdentity> uniqueMatches = HashBiMap.create();
+                for (ClassIdentity sourceClass : m_sourceClasses.keySet()) {
+                        Collection<ClassIdentity> matchedSourceClasses = m_sourceClasses.get(sourceClass);
+                        Collection<ClassIdentity> matchedDestClasses = m_matchedDestClasses.get(sourceClass);
+                        if (matchedSourceClasses.size() == 1 && matchedDestClasses.size() == 1) {
+                                ClassIdentity matchedSourceClass = matchedSourceClasses.iterator().next();
+                                ClassIdentity matchedDestClass = matchedDestClasses.iterator().next();
+                                uniqueMatches.put(matchedSourceClass, matchedDestClass);
+                        }
+                }
+                return uniqueMatches;
+        }
+        
+        public BiMap<List<ClassIdentity>,List<ClassIdentity>> getAmbiguousMatches() {
+                BiMap<List<ClassIdentity>,List<ClassIdentity>> ambiguousMatches = HashBiMap.create();
+                for (ClassIdentity sourceClass : m_sourceClasses.keySet()) {
+                        Collection<ClassIdentity> matchedSourceClasses = m_sourceClasses.get(sourceClass);
+                        Collection<ClassIdentity> matchedDestClasses = m_matchedDestClasses.get(sourceClass);
+                        if (matchedSourceClasses.size() > 1 && matchedDestClasses.size() > 1) {
+                                ambiguousMatches.put(
+                                        new ArrayList<ClassIdentity>(matchedSourceClasses),
+                                        new ArrayList<ClassIdentity>(matchedDestClasses)
+                                );
+                        }
+                }
+                return ambiguousMatches;
+        }
+        
+        public int getNumAmbiguousSourceMatches() {
+                int num = 0;
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : getAmbiguousMatches().entrySet()) {
+                        num += entry.getKey().size();
+                }
+                return num;
+        }
+        
+        public int getNumAmbiguousDestMatches() {
+                int num = 0;
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : getAmbiguousMatches().entrySet()) {
+                        num += entry.getValue().size();
+                }
+                return num;
+        }
+        
+        public List<ClassIdentity> getUnmatchedSourceClasses() {
+                List<ClassIdentity> classes = Lists.newArrayList();
+                for (ClassIdentity sourceClass : getSourceClasses()) {
+                        if (m_matchedDestClasses.get(sourceClass).isEmpty()) {
+                                classes.add(sourceClass);
+                        }
+                }
+                return classes;
+        }
+        
+        public List<ClassIdentity> getUnmatchedDestClasses() {
+                return new ArrayList<ClassIdentity>(m_unmatchedDestClasses);
+        }
+        
+        public Map<String,Map.Entry<ClassIdentity,List<ClassIdentity>>> getIndex() {
+                Map<String,Map.Entry<ClassIdentity,List<ClassIdentity>>> conversion = Maps.newHashMap();
+                for (Map.Entry<ClassIdentity,ClassIdentity> entry : getUniqueMatches().entrySet()) {
+                        conversion.put(
+                                entry.getKey().getClassEntry().getName(),
+                                new AbstractMap.SimpleEntry<ClassIdentity,List<ClassIdentity>>(entry.getKey(), Arrays.asList(entry.getValue()))
+                        );
+                }
+                for (Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : getAmbiguousMatches().entrySet()) {
+                        for (ClassIdentity sourceClass : entry.getKey()) {
+                                conversion.put(
+                                        sourceClass.getClassEntry().getName(),
+                                        new AbstractMap.SimpleEntry<ClassIdentity,List<ClassIdentity>>(sourceClass, entry.getValue())
+                                );
+                        }
+                }
+                for (ClassIdentity sourceClass : getUnmatchedSourceClasses()) {
+                        conversion.put(
+                                sourceClass.getClassEntry().getName(),
+                                new AbstractMap.SimpleEntry<ClassIdentity,List<ClassIdentity>>(sourceClass, getUnmatchedDestClasses())
+                        );
+                }
+                return conversion;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append(String.format("%12s%8s%8s\n", "", "Source", "Dest"));
+                buf.append(String.format("%12s%8d%8d\n", "Classes", getSourceClasses().size(), getDestClasses().size()));
+                buf.append(String.format("%12s%8d%8d\n", "Unique", getUniqueMatches().size(), getUniqueMatches().size()));
+                buf.append(String.format("%12s%8d%8d\n", "Ambiguous", getNumAmbiguousSourceMatches(), getNumAmbiguousDestMatches()));
+                buf.append(String.format("%12s%8d%8d\n", "Unmatched", getUnmatchedSourceClasses().size(), getUnmatchedDestClasses().size()));
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/convert/ClassNamer.java b/src/cuchaz/enigma/convert/ClassNamer.java
new file mode 100644
index 0000000..1b6e81c
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassNamer.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.convert;
+
+import java.util.Map;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.Maps;
+
+public class ClassNamer {
+        
+        public interface SidedClassNamer {
+                String getName(String name);
+        }
+        
+        private Map<String,String> m_sourceNames;
+        private Map<String,String> m_destNames;
+        
+        public ClassNamer(BiMap<ClassIdentity,ClassIdentity> mappings) {
+                // convert the identity mappings to name maps
+                m_sourceNames = Maps.newHashMap();
+                m_destNames = Maps.newHashMap();
+                int i = 0;
+                for (Map.Entry<ClassIdentity,ClassIdentity> entry : mappings.entrySet()) {
+                        String name = String.format("M%04d", i++);
+                        m_sourceNames.put(entry.getKey().getClassEntry().getName(), name);
+                        m_destNames.put(entry.getValue().getClassEntry().getName(), name);
+                }
+        }
+        
+        public String getSourceName(String name) {
+                return m_sourceNames.get(name);
+        }
+        
+        public String getDestName(String name) {
+                return m_destNames.get(name);
+        }
+        
+        public SidedClassNamer getSourceNamer() {
+                return new SidedClassNamer() {
+                        @Override
+                        public String getName(String name) {
+                                return getSourceName(name);
+                        }
+                };
+        }
+        
+        public SidedClassNamer getDestNamer() {
+                return new SidedClassNamer() {
+                        @Override
+                        public String getName(String name) {
+                                return getDestName(name);
+                        }
+                };
+        }
+}
diff --git a/src/cuchaz/enigma/gui/AboutDialog.java b/src/cuchaz/enigma/gui/AboutDialog.java
new file mode 100644
index 0000000..2476b56
--- /dev/null
+++ b/src/cuchaz/enigma/gui/AboutDialog.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.Cursor;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.IOException;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.WindowConstants;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.Util;
+
+public class AboutDialog {
+        
+        public static void show(JFrame parent) {
+                // init frame
+                final JFrame frame = new JFrame(Constants.Name + " - About");
+                final Container pane = frame.getContentPane();
+                pane.setLayout(new FlowLayout());
+                
+                // load the content
+                try {
+                        String html = Util.readResourceToString("/about.html");
+                        html = String.format(html, Constants.Name, Constants.Version);
+                        JLabel label = new JLabel(html);
+                        label.setHorizontalAlignment(JLabel.CENTER);
+                        pane.add(label);
+                } catch (IOException ex) {
+                        throw new Error(ex);
+                }
+                
+                // show the link
+                String html = "<html><a href=\"%s\">%s</a></html>";
+                html = String.format(html, Constants.Url, Constants.Url);
+                JButton link = new JButton(html);
+                link.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent event) {
+                                Util.openUrl(Constants.Url);
+                        }
+                });
+                link.setBorderPainted(false);
+                link.setOpaque(false);
+                link.setBackground(Color.WHITE);
+                link.setCursor(new Cursor(Cursor.HAND_CURSOR));
+                link.setFocusable(false);
+                JPanel linkPanel = new JPanel();
+                linkPanel.add(link);
+                pane.add(linkPanel);
+                
+                // show ok button
+                JButton okButton = new JButton("Ok");
+                pane.add(okButton);
+                okButton.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent arg0) {
+                                frame.dispose();
+                        }
+                });
+                
+                // show the frame
+                pane.doLayout();
+                frame.setSize(400, 220);
+                frame.setResizable(false);
+                frame.setLocationRelativeTo(parent);
+                frame.setVisible(true);
+                frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/BoxHighlightPainter.java b/src/cuchaz/enigma/gui/BoxHighlightPainter.java
new file mode 100644
index 0000000..db7c85b
--- /dev/null
+++ b/src/cuchaz/enigma/gui/BoxHighlightPainter.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+import java.awt.Shape;
+
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Highlighter;
+import javax.swing.text.JTextComponent;
+
+public abstract class BoxHighlightPainter implements Highlighter.HighlightPainter {
+        
+        private Color m_fillColor;
+        private Color m_borderColor;
+        
+        protected BoxHighlightPainter(Color fillColor, Color borderColor) {
+                m_fillColor = fillColor;
+                m_borderColor = borderColor;
+        }
+        
+        @Override
+        public void paint(Graphics g, int start, int end, Shape shape, JTextComponent text) {
+                Rectangle bounds = getBounds(text, start, end);
+                
+                // fill the area
+                if (m_fillColor != null) {
+                        g.setColor(m_fillColor);
+                        g.fillRoundRect(bounds.x, bounds.y, bounds.width, bounds.height, 4, 4);
+                }
+                
+                // draw a box around the area
+                g.setColor(m_borderColor);
+                g.drawRoundRect(bounds.x, bounds.y, bounds.width, bounds.height, 4, 4);
+        }
+        
+        protected static Rectangle getBounds(JTextComponent text, int start, int end) {
+                try {
+                        // determine the bounds of the text
+                        Rectangle bounds = text.modelToView(start).union(text.modelToView(end));
+                        
+                        // adjust the box so it looks nice
+                        bounds.x -= 2;
+                        bounds.width += 2;
+                        bounds.y += 1;
+                        bounds.height -= 2;
+                        
+                        return bounds;
+                } catch (BadLocationException ex) {
+                        // don't care... just return something
+                        return new Rectangle(0, 0, 0, 0);
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/gui/BrowserCaret.java b/src/cuchaz/enigma/gui/BrowserCaret.java
new file mode 100644
index 0000000..acee483
--- /dev/null
+++ b/src/cuchaz/enigma/gui/BrowserCaret.java
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Graphics;
+import java.awt.Shape;
+
+import javax.swing.text.DefaultCaret;
+import javax.swing.text.Highlighter;
+import javax.swing.text.JTextComponent;
+
+public class BrowserCaret extends DefaultCaret {
+        
+        private static final long serialVersionUID = 1158977422507969940L;
+        
+        private static final Highlighter.HighlightPainter m_selectionPainter = new Highlighter.HighlightPainter() {
+                @Override
+                public void paint(Graphics g, int p0, int p1, Shape bounds, JTextComponent c) {
+                        // don't paint anything
+                }
+        };
+        
+        @Override
+        public boolean isSelectionVisible() {
+                return false;
+        }
+        
+        @Override
+        public boolean isVisible() {
+                return true;
+        }
+        
+        @Override
+        public Highlighter.HighlightPainter getSelectionPainter() {
+                return m_selectionPainter;
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ClassListCellRenderer.java b/src/cuchaz/enigma/gui/ClassListCellRenderer.java
new file mode 100644
index 0000000..d0f01e6
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassListCellRenderer.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Component;
+
+import javassist.bytecode.Descriptor;
+
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.ListCellRenderer;
+
+public class ClassListCellRenderer implements ListCellRenderer<String> {
+        
+        private DefaultListCellRenderer m_defaultRenderer;
+        
+        public ClassListCellRenderer() {
+                m_defaultRenderer = new DefaultListCellRenderer();
+        }
+        
+        @Override
+        public Component getListCellRendererComponent(JList<? extends String> list, String className, int index, boolean isSelected, boolean hasFocus) {
+                JLabel label = (JLabel)m_defaultRenderer.getListCellRendererComponent(list, className, index, isSelected, hasFocus);
+                label.setText(Descriptor.toJavaName(className));
+                return label;
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ClassSelector.java b/src/cuchaz/enigma/gui/ClassSelector.java
new file mode 100644
index 0000000..654bfbe
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassSelector.java
@@ -0,0 +1,164 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class ClassSelector extends JTree {
+        
+        private static final long serialVersionUID = -7632046902384775977L;
+        
+        public interface ClassSelectionListener {
+                void onSelectClass(ClassEntry classEntry);
+        }
+        
+        public static Comparator<ClassEntry> ObfuscatedClassEntryComparator;
+        public static Comparator<ClassEntry> DeobfuscatedClassEntryComparator;
+        
+        static {
+                ObfuscatedClassEntryComparator = new Comparator<ClassEntry>() {
+                        @Override
+                        public int compare(ClassEntry a, ClassEntry b) {
+                                if (a.getName().length() != b.getName().length()) {
+                                        return a.getName().length() - b.getName().length();
+                                }
+                                return a.getName().compareTo(b.getName());
+                        }
+                };
+                
+                DeobfuscatedClassEntryComparator = new Comparator<ClassEntry>() {
+                        @Override
+                        public int compare(ClassEntry a, ClassEntry b) {
+                                return a.getName().compareTo(b.getName());
+                        }
+                };
+        }
+        
+        private ClassSelectionListener m_listener;
+        private Comparator<ClassEntry> m_comparator;
+        
+        public ClassSelector(Comparator<ClassEntry> comparator) {
+                m_comparator = comparator;
+                
+                // configure the tree control
+                setRootVisible(false);
+                setShowsRootHandles(false);
+                setModel(null);
+                
+                // hook events
+                addMouseListener(new MouseAdapter() {
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (m_listener != null && event.getClickCount() == 2) {
+                                        // get the selected node
+                                        TreePath path = getSelectionPath();
+                                        if (path != null && path.getLastPathComponent() instanceof ClassSelectorClassNode) {
+                                                ClassSelectorClassNode node = (ClassSelectorClassNode)path.getLastPathComponent();
+                                                m_listener.onSelectClass(node.getClassEntry());
+                                        }
+                                }
+                        }
+                });
+                
+                // init defaults
+                m_listener = null;
+        }
+        
+        public void setListener(ClassSelectionListener val) {
+                m_listener = val;
+        }
+        
+        public void setClasses(Collection<ClassEntry> classEntries) {
+                if (classEntries == null) {
+                        setModel(null);
+                        return;
+                }
+                
+                // build the package names
+                Map<String,ClassSelectorPackageNode> packages = Maps.newHashMap();
+                for (ClassEntry classEntry : classEntries) {
+                        packages.put(classEntry.getPackageName(), null);
+                }
+                
+                // sort the packages
+                List<String> sortedPackageNames = Lists.newArrayList(packages.keySet());
+                Collections.sort(sortedPackageNames, new Comparator<String>() {
+                        @Override
+                        public int compare(String a, String b) {
+                                // I can never keep this rule straight when writing these damn things...
+                                // a < b => -1, a == b => 0, a > b => +1
+                                
+                                String[] aparts = a.split("/");
+                                String[] bparts = b.split("/");
+                                for (int i = 0; true; i++) {
+                                        if (i >= aparts.length) {
+                                                return -1;
+                                        } else if (i >= bparts.length) {
+                                                return 1;
+                                        }
+                                        
+                                        int result = aparts[i].compareTo(bparts[i]);
+                                        if (result != 0) {
+                                                return result;
+                                        }
+                                }
+                        }
+                });
+                
+                // create the root node and the package nodes
+                DefaultMutableTreeNode root = new DefaultMutableTreeNode();
+                for (String packageName : sortedPackageNames) {
+                        ClassSelectorPackageNode node = new ClassSelectorPackageNode(packageName);
+                        packages.put(packageName, node);
+                        root.add(node);
+                }
+                
+                // put the classes into packages
+                Multimap<String,ClassEntry> packagedClassEntries = ArrayListMultimap.create();
+                for (ClassEntry classEntry : classEntries) {
+                        packagedClassEntries.put(classEntry.getPackageName(), classEntry);
+                }
+                
+                // build the class nodes
+                for (String packageName : packagedClassEntries.keySet()) {
+                        // sort the class entries
+                        List<ClassEntry> classEntriesInPackage = Lists.newArrayList(packagedClassEntries.get(packageName));
+                        Collections.sort(classEntriesInPackage, m_comparator);
+                        
+                        // create the nodes in order
+                        for (ClassEntry classEntry : classEntriesInPackage) {
+                                ClassSelectorPackageNode node = packages.get(packageName);
+                                node.add(new ClassSelectorClassNode(classEntry));
+                        }
+                }
+                
+                // finally, update the tree control
+                setModel(new DefaultTreeModel(root));
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ClassSelectorClassNode.java b/src/cuchaz/enigma/gui/ClassSelectorClassNode.java
new file mode 100644
index 0000000..66e931b
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassSelectorClassNode.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class ClassSelectorClassNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = -8956754339813257380L;
+        
+        private ClassEntry m_classEntry;
+        
+        public ClassSelectorClassNode(ClassEntry classEntry) {
+                m_classEntry = classEntry;
+        }
+        
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String toString() {
+                return m_classEntry.getSimpleName();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ClassSelectorPackageNode.java b/src/cuchaz/enigma/gui/ClassSelectorPackageNode.java
new file mode 100644
index 0000000..451d380
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassSelectorPackageNode.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+public class ClassSelectorPackageNode extends DefaultMutableTreeNode {
+        
+        private static final long serialVersionUID = -3730868701219548043L;
+        
+        private String m_packageName;
+        
+        public ClassSelectorPackageNode(String packageName) {
+                m_packageName = packageName;
+        }
+        
+        public String getPackageName() {
+                return m_packageName;
+        }
+        
+        @Override
+        public String toString() {
+                return m_packageName;
+        }
+}
diff --git a/src/cuchaz/enigma/gui/CrashDialog.java b/src/cuchaz/enigma/gui/CrashDialog.java
new file mode 100644
index 0000000..360091a
--- /dev/null
+++ b/src/cuchaz/enigma/gui/CrashDialog.java
@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.WindowConstants;
+
+import cuchaz.enigma.Constants;
+
+public class CrashDialog {
+        
+        private static CrashDialog m_instance = null;
+        
+        private JFrame m_frame;
+        private JTextArea m_text;
+        
+        private CrashDialog(JFrame parent) {
+                // init frame
+                m_frame = new JFrame(Constants.Name + " - Crash Report");
+                final Container pane = m_frame.getContentPane();
+                pane.setLayout(new BorderLayout());
+                
+                JLabel label = new JLabel(Constants.Name + " has crashed! =(");
+                label.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+                pane.add(label, BorderLayout.NORTH);
+                
+                // report panel
+                m_text = new JTextArea();
+                m_text.setTabSize(2);
+                pane.add(new JScrollPane(m_text), BorderLayout.CENTER);
+                
+                // buttons panel
+                JPanel buttonsPanel = new JPanel();
+                FlowLayout buttonsLayout = new FlowLayout();
+                buttonsLayout.setAlignment(FlowLayout.RIGHT);
+                buttonsPanel.setLayout(buttonsLayout);
+                buttonsPanel.add(GuiTricks.unboldLabel(new JLabel("If you choose exit, you will lose any unsaved work.")));
+                JButton ignoreButton = new JButton("Ignore");
+                ignoreButton.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent event) {
+                                // close (hide) the dialog
+                                m_frame.setVisible(false);
+                        }
+                });
+                buttonsPanel.add(ignoreButton);
+                JButton exitButton = new JButton("Exit");
+                exitButton.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent event) {
+                                // exit enigma
+                                System.exit(1);
+                        }
+                });
+                buttonsPanel.add(exitButton);
+                pane.add(buttonsPanel, BorderLayout.SOUTH);
+                
+                // show the frame
+                m_frame.setSize(600, 400);
+                m_frame.setLocationRelativeTo(parent);
+                m_frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        }
+        
+        public static void init(JFrame parent) {
+                m_instance = new CrashDialog(parent);
+        }
+        
+        public static void show(Throwable ex) {
+                // get the error report
+                StringWriter buf = new StringWriter();
+                ex.printStackTrace(new PrintWriter(buf));
+                String report = buf.toString();
+                
+                // show it!
+                m_instance.m_text.setText(report);
+                m_instance.m_frame.doLayout();
+                m_instance.m_frame.setVisible(true);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/DeobfuscatedHighlightPainter.java b/src/cuchaz/enigma/gui/DeobfuscatedHighlightPainter.java
new file mode 100644
index 0000000..26a3163
--- /dev/null
+++ b/src/cuchaz/enigma/gui/DeobfuscatedHighlightPainter.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+
+public class DeobfuscatedHighlightPainter extends BoxHighlightPainter {
+        
+        public DeobfuscatedHighlightPainter() {
+                // green ish
+                super(new Color(220, 255, 220), new Color(80, 160, 80));
+        }
+}
diff --git a/src/cuchaz/enigma/gui/Gui.java b/src/cuchaz/enigma/gui/Gui.java
new file mode 100644
index 0000000..ca39c42
--- /dev/null
+++ b/src/cuchaz/enigma/gui/Gui.java
@@ -0,0 +1,1165 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+import java.awt.Rectangle;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.File;
+import java.io.IOException;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Vector;
+import java.util.jar.JarFile;
+
+import javax.swing.BorderFactory;
+import javax.swing.JEditorPane;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextField;
+import javax.swing.JTree;
+import javax.swing.KeyStroke;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingUtilities;
+import javax.swing.Timer;
+import javax.swing.WindowConstants;
+import javax.swing.event.CaretEvent;
+import javax.swing.event.CaretListener;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Highlighter;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreeNode;
+import javax.swing.tree.TreePath;
+
+import jsyntaxpane.DefaultSyntaxKit;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.analysis.BehaviorReferenceTreeNode;
+import cuchaz.enigma.analysis.ClassImplementationsTreeNode;
+import cuchaz.enigma.analysis.ClassInheritanceTreeNode;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.FieldReferenceTreeNode;
+import cuchaz.enigma.analysis.MethodImplementationsTreeNode;
+import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
+import cuchaz.enigma.analysis.ReferenceTreeNode;
+import cuchaz.enigma.analysis.Token;
+import cuchaz.enigma.gui.ClassSelector.ClassSelectionListener;
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.IllegalNameException;
+import cuchaz.enigma.mapping.MappingParseException;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class Gui {
+        
+        private GuiController m_controller;
+        
+        // controls
+        private JFrame m_frame;
+        private ClassSelector m_obfClasses;
+        private ClassSelector m_deobfClasses;
+        private JEditorPane m_editor;
+        private JPanel m_classesPanel;
+        private JSplitPane m_splitClasses;
+        private JPanel m_infoPanel;
+        private ObfuscatedHighlightPainter m_obfuscatedHighlightPainter;
+        private DeobfuscatedHighlightPainter m_deobfuscatedHighlightPainter;
+        private OtherHighlightPainter m_otherHighlightPainter;
+        private SelectionHighlightPainter m_selectionHighlightPainter;
+        private JTree m_inheritanceTree;
+        private JTree m_implementationsTree;
+        private JTree m_callsTree;
+        private JList<Token> m_tokens;
+        private JTabbedPane m_tabs;
+        
+        // dynamic menu items
+        private JMenuItem m_closeJarMenu;
+        private JMenuItem m_openMappingsMenu;
+        private JMenuItem m_saveMappingsMenu;
+        private JMenuItem m_saveMappingsAsMenu;
+        private JMenuItem m_closeMappingsMenu;
+        private JMenuItem m_renameMenu;
+        private JMenuItem m_showInheritanceMenu;
+        private JMenuItem m_openEntryMenu;
+        private JMenuItem m_openPreviousMenu;
+        private JMenuItem m_showCallsMenu;
+        private JMenuItem m_showImplementationsMenu;
+        private JMenuItem m_toggleMappingMenu;
+        private JMenuItem m_exportSourceMenu;
+        private JMenuItem m_exportJarMenu;
+        
+        // state
+        private EntryReference<Entry,Entry> m_reference;
+        private JFileChooser m_jarFileChooser;
+        private JFileChooser m_mappingsFileChooser;
+        private JFileChooser m_exportSourceFileChooser;
+        private JFileChooser m_exportJarFileChooser;
+        
+        public Gui() {
+                
+                // init frame
+                m_frame = new JFrame(Constants.Name);
+                final Container pane = m_frame.getContentPane();
+                pane.setLayout(new BorderLayout());
+                
+                if (Boolean.parseBoolean(System.getProperty("enigma.catchExceptions", "true"))) {
+                        // install a global exception handler to the event thread
+                        CrashDialog.init(m_frame);
+                        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+                                @Override
+                                public void uncaughtException(Thread thread, Throwable ex) {
+                                        ex.printStackTrace(System.err);
+                                        CrashDialog.show(ex);
+                                }
+                        });
+                }
+                
+                m_controller = new GuiController(this);
+                
+                // init file choosers
+                m_jarFileChooser = new JFileChooser();
+                m_mappingsFileChooser = new JFileChooser();
+                m_exportSourceFileChooser = new JFileChooser();
+                m_exportSourceFileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+                m_exportJarFileChooser = new JFileChooser();
+                
+                // init obfuscated classes list
+                m_obfClasses = new ClassSelector(ClassSelector.ObfuscatedClassEntryComparator);
+                m_obfClasses.setListener(new ClassSelectionListener() {
+                        @Override
+                        public void onSelectClass(ClassEntry classEntry) {
+                                navigateTo(classEntry);
+                        }
+                });
+                JScrollPane obfScroller = new JScrollPane(m_obfClasses);
+                JPanel obfPanel = new JPanel();
+                obfPanel.setLayout(new BorderLayout());
+                obfPanel.add(new JLabel("Obfuscated Classes"), BorderLayout.NORTH);
+                obfPanel.add(obfScroller, BorderLayout.CENTER);
+                
+                // init deobfuscated classes list
+                m_deobfClasses = new ClassSelector(ClassSelector.DeobfuscatedClassEntryComparator);
+                m_deobfClasses.setListener(new ClassSelectionListener() {
+                        @Override
+                        public void onSelectClass(ClassEntry classEntry) {
+                                navigateTo(classEntry);
+                        }
+                });
+                JScrollPane deobfScroller = new JScrollPane(m_deobfClasses);
+                JPanel deobfPanel = new JPanel();
+                deobfPanel.setLayout(new BorderLayout());
+                deobfPanel.add(new JLabel("De-obfuscated Classes"), BorderLayout.NORTH);
+                deobfPanel.add(deobfScroller, BorderLayout.CENTER);
+                
+                // set up classes panel (don't add the splitter yet)
+                m_splitClasses = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true, obfPanel, deobfPanel);
+                m_splitClasses.setResizeWeight(0.3);
+                m_classesPanel = new JPanel();
+                m_classesPanel.setLayout(new BorderLayout());
+                m_classesPanel.setPreferredSize(new Dimension(250, 0));
+                
+                // init info panel
+                m_infoPanel = new JPanel();
+                m_infoPanel.setLayout(new GridLayout(4, 1, 0, 0));
+                m_infoPanel.setPreferredSize(new Dimension(0, 100));
+                m_infoPanel.setBorder(BorderFactory.createTitledBorder("Identifier Info"));
+                clearReference();
+                
+                // init editor
+                DefaultSyntaxKit.initKit();
+                m_obfuscatedHighlightPainter = new ObfuscatedHighlightPainter();
+                m_deobfuscatedHighlightPainter = new DeobfuscatedHighlightPainter();
+                m_otherHighlightPainter = new OtherHighlightPainter();
+                m_selectionHighlightPainter = new SelectionHighlightPainter();
+                m_editor = new JEditorPane();
+                m_editor.setEditable(false);
+                m_editor.setCaret(new BrowserCaret());
+                JScrollPane sourceScroller = new JScrollPane(m_editor);
+                m_editor.setContentType("text/java");
+                m_editor.addCaretListener(new CaretListener() {
+                        @Override
+                        public void caretUpdate(CaretEvent event) {
+                                onCaretMove(event.getDot());
+                        }
+                });
+                m_editor.addKeyListener(new KeyAdapter() {
+                        @Override
+                        public void keyPressed(KeyEvent event) {
+                                switch (event.getKeyCode()) {
+                                        case KeyEvent.VK_R:
+                                                m_renameMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_I:
+                                                m_showInheritanceMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_M:
+                                                m_showImplementationsMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_N:
+                                                m_openEntryMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_P:
+                                                m_openPreviousMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_C:
+                                                m_showCallsMenu.doClick();
+                                        break;
+                                        
+                                        case KeyEvent.VK_T:
+                                                m_toggleMappingMenu.doClick();
+                                        break;
+                                }
+                        }
+                });
+                
+                // turn off token highlighting (it's wrong most of the time anyway...)
+                DefaultSyntaxKit kit = (DefaultSyntaxKit)m_editor.getEditorKit();
+                kit.toggleComponent(m_editor, "jsyntaxpane.components.TokenMarker");
+                
+                // init editor popup menu
+                JPopupMenu popupMenu = new JPopupMenu();
+                m_editor.setComponentPopupMenu(popupMenu);
+                {
+                        JMenuItem menu = new JMenuItem("Rename");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        startRename();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_renameMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Show Inheritance");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        showInheritance();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_showInheritanceMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Show Implementations");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        showImplementations();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_showImplementationsMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Show Calls");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        showCalls();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_showCallsMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Go to Declaration");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        navigateTo(m_reference.entry);
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_openEntryMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Go to previous");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        m_controller.openPreviousReference();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_openPreviousMenu = menu;
+                }
+                {
+                        JMenuItem menu = new JMenuItem("Mark as deobfuscated");
+                        menu.addActionListener(new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        toggleMapping();
+                                }
+                        });
+                        menu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T, 0));
+                        menu.setEnabled(false);
+                        popupMenu.add(menu);
+                        m_toggleMappingMenu = menu;
+                }
+                
+                // init inheritance panel
+                m_inheritanceTree = new JTree();
+                m_inheritanceTree.setModel(null);
+                m_inheritanceTree.addMouseListener(new MouseAdapter() {
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (event.getClickCount() == 2) {
+                                        // get the selected node
+                                        TreePath path = m_inheritanceTree.getSelectionPath();
+                                        if (path == null) {
+                                                return;
+                                        }
+                                        
+                                        Object node = path.getLastPathComponent();
+                                        if (node instanceof ClassInheritanceTreeNode) {
+                                                ClassInheritanceTreeNode classNode = (ClassInheritanceTreeNode)node;
+                                                navigateTo(new ClassEntry(classNode.getObfClassName()));
+                                        } else if (node instanceof MethodInheritanceTreeNode) {
+                                                MethodInheritanceTreeNode methodNode = (MethodInheritanceTreeNode)node;
+                                                if (methodNode.isImplemented()) {
+                                                        navigateTo(methodNode.getMethodEntry());
+                                                }
+                                        }
+                                }
+                        }
+                });
+                JPanel inheritancePanel = new JPanel();
+                inheritancePanel.setLayout(new BorderLayout());
+                inheritancePanel.add(new JScrollPane(m_inheritanceTree));
+                
+                // init implementations panel
+                m_implementationsTree = new JTree();
+                m_implementationsTree.setModel(null);
+                m_implementationsTree.addMouseListener(new MouseAdapter() {
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (event.getClickCount() == 2) {
+                                        // get the selected node
+                                        TreePath path = m_implementationsTree.getSelectionPath();
+                                        if (path == null) {
+                                                return;
+                                        }
+                                        
+                                        Object node = path.getLastPathComponent();
+                                        if (node instanceof ClassImplementationsTreeNode) {
+                                                ClassImplementationsTreeNode classNode = (ClassImplementationsTreeNode)node;
+                                                navigateTo(classNode.getClassEntry());
+                                        } else if (node instanceof MethodImplementationsTreeNode) {
+                                                MethodImplementationsTreeNode methodNode = (MethodImplementationsTreeNode)node;
+                                                navigateTo(methodNode.getMethodEntry());
+                                        }
+                                }
+                        }
+                });
+                JPanel implementationsPanel = new JPanel();
+                implementationsPanel.setLayout(new BorderLayout());
+                implementationsPanel.add(new JScrollPane(m_implementationsTree));
+                
+                // init call panel
+                m_callsTree = new JTree();
+                m_callsTree.setModel(null);
+                m_callsTree.addMouseListener(new MouseAdapter() {
+                        @SuppressWarnings("unchecked")
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (event.getClickCount() == 2) {
+                                        // get the selected node
+                                        TreePath path = m_callsTree.getSelectionPath();
+                                        if (path == null) {
+                                                return;
+                                        }
+                                        
+                                        Object node = path.getLastPathComponent();
+                                        if (node instanceof ReferenceTreeNode) {
+                                                ReferenceTreeNode<Entry,Entry> referenceNode = ((ReferenceTreeNode<Entry,Entry>)node);
+                                                if (referenceNode.getReference() != null) {
+                                                        navigateTo(referenceNode.getReference());
+                                                } else {
+                                                        navigateTo(referenceNode.getEntry());
+                                                }
+                                        }
+                                }
+                        }
+                });
+                m_tokens = new JList<Token>();
+                m_tokens.setCellRenderer(new TokenListCellRenderer(m_controller));
+                m_tokens.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+                m_tokens.setLayoutOrientation(JList.VERTICAL);
+                m_tokens.addMouseListener(new MouseAdapter() {
+                        @Override
+                        public void mouseClicked(MouseEvent event) {
+                                if (event.getClickCount() == 2) {
+                                        Token selected = m_tokens.getSelectedValue();
+                                        if (selected != null) {
+                                                showToken(selected);
+                                        }
+                                }
+                        }
+                });
+                m_tokens.setPreferredSize(new Dimension(0, 200));
+                m_tokens.setMinimumSize(new Dimension(0, 200));
+                JSplitPane callPanel = new JSplitPane(
+                        JSplitPane.VERTICAL_SPLIT,
+                        true,
+                        new JScrollPane(m_callsTree),
+                        new JScrollPane(m_tokens)
+                );
+                callPanel.setResizeWeight(1); // let the top side take all the slack
+                callPanel.resetToPreferredSizes();
+                
+                // layout controls
+                JPanel centerPanel = new JPanel();
+                centerPanel.setLayout(new BorderLayout());
+                centerPanel.add(m_infoPanel, BorderLayout.NORTH);
+                centerPanel.add(sourceScroller, BorderLayout.CENTER);
+                m_tabs = new JTabbedPane();
+                m_tabs.setPreferredSize(new Dimension(250, 0));
+                m_tabs.addTab("Inheritance", inheritancePanel);
+                m_tabs.addTab("Implementations", implementationsPanel);
+                m_tabs.addTab("Call Graph", callPanel);
+                JSplitPane splitRight = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, centerPanel, m_tabs);
+                splitRight.setResizeWeight(1); // let the left side take all the slack
+                splitRight.resetToPreferredSizes();
+                JSplitPane splitCenter = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, m_classesPanel, splitRight);
+                splitCenter.setResizeWeight(0); // let the right side take all the slack
+                pane.add(splitCenter, BorderLayout.CENTER);
+                
+                // init menus
+                JMenuBar menuBar = new JMenuBar();
+                m_frame.setJMenuBar(menuBar);
+                {
+                        JMenu menu = new JMenu("File");
+                        menuBar.add(menu);
+                        {
+                                JMenuItem item = new JMenuItem("Open Jar...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_jarFileChooser.showOpenDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        // load the jar in a separate thread
+                                                        new Thread() {
+                                                                @Override
+                                                                public void run() {
+                                                                        try {
+                                                                                m_controller.openJar(new JarFile(m_jarFileChooser.getSelectedFile()));
+                                                                        } catch (IOException ex) {
+                                                                                throw new Error(ex);
+                                                                        }
+                                                                }
+                                                        }.start();
+                                                }
+                                        }
+                                });
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Close Jar");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                m_controller.closeJar();
+                                        }
+                                });
+                                m_closeJarMenu = item;
+                        }
+                        menu.addSeparator();
+                        {
+                                JMenuItem item = new JMenuItem("Open Mappings...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_mappingsFileChooser.showOpenDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        try {
+                                                                m_controller.openMappings(m_mappingsFileChooser.getSelectedFile());
+                                                        } catch (IOException ex) {
+                                                                throw new Error(ex);
+                                                        } catch (MappingParseException ex) {
+                                                                JOptionPane.showMessageDialog(m_frame, ex.getMessage());
+                                                        }
+                                                }
+                                        }
+                                });
+                                m_openMappingsMenu = item;
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Save Mappings");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                try {
+                                                        m_controller.saveMappings(m_mappingsFileChooser.getSelectedFile());
+                                                } catch (IOException ex) {
+                                                        throw new Error(ex);
+                                                }
+                                        }
+                                });
+                                item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK));
+                                m_saveMappingsMenu = item;
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Save Mappings As...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_mappingsFileChooser.showSaveDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        try {
+                                                                m_controller.saveMappings(m_mappingsFileChooser.getSelectedFile());
+                                                                m_saveMappingsMenu.setEnabled(true);
+                                                        } catch (IOException ex) {
+                                                                throw new Error(ex);
+                                                        }
+                                                }
+                                        }
+                                });
+                                item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK));
+                                m_saveMappingsAsMenu = item;
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Close Mappings");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                m_controller.closeMappings();
+                                        }
+                                });
+                                m_closeMappingsMenu = item;
+                        }
+                        menu.addSeparator();
+                        {
+                                JMenuItem item = new JMenuItem("Export Source...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_exportSourceFileChooser.showSaveDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        m_controller.exportSource(m_exportSourceFileChooser.getSelectedFile());
+                                                }
+                                        }
+                                });
+                                m_exportSourceMenu = item;
+                        }
+                        {
+                                JMenuItem item = new JMenuItem("Export Jar...");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                if (m_exportJarFileChooser.showSaveDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                        m_controller.exportJar(m_exportJarFileChooser.getSelectedFile());
+                                                }
+                                        }
+                                });
+                                m_exportJarMenu = item;
+                        }
+                        menu.addSeparator();
+                        {
+                                JMenuItem item = new JMenuItem("Exit");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                close();
+                                        }
+                                });
+                        }
+                }
+                {
+                        JMenu menu = new JMenu("Help");
+                        menuBar.add(menu);
+                        {
+                                JMenuItem item = new JMenuItem("About");
+                                menu.add(item);
+                                item.addActionListener(new ActionListener() {
+                                        @Override
+                                        public void actionPerformed(ActionEvent event) {
+                                                AboutDialog.show(m_frame);
+                                        }
+                                });
+                        }
+                }
+                
+                // init state
+                onCloseJar();
+                
+                m_frame.addWindowListener(new WindowAdapter() {
+                        @Override
+                        public void windowClosing(WindowEvent event) {
+                                close();
+                        }
+                });
+                
+                // show the frame
+                pane.doLayout();
+                m_frame.setSize(1024, 576);
+                m_frame.setMinimumSize(new Dimension(640, 480));
+                m_frame.setVisible(true);
+                m_frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        }
+        
+        public JFrame getFrame() {
+                return m_frame;
+        }
+        
+        public GuiController getController() {
+                return m_controller;
+        }
+        
+        public void onStartOpenJar() {
+                m_classesPanel.removeAll();
+                JPanel panel = new JPanel();
+                panel.setLayout(new FlowLayout());
+                panel.add(new JLabel("Loading..."));
+                m_classesPanel.add(panel);
+                redraw();
+        }
+        
+        public void onFinishOpenJar(String jarName) {
+                // update gui
+                m_frame.setTitle(Constants.Name + " - " + jarName);
+                m_classesPanel.removeAll();
+                m_classesPanel.add(m_splitClasses);
+                setSource(null);
+                
+                // update menu
+                m_closeJarMenu.setEnabled(true);
+                m_openMappingsMenu.setEnabled(true);
+                m_saveMappingsMenu.setEnabled(false);
+                m_saveMappingsAsMenu.setEnabled(true);
+                m_closeMappingsMenu.setEnabled(true);
+                m_exportSourceMenu.setEnabled(true);
+                m_exportJarMenu.setEnabled(true);
+                
+                redraw();
+        }
+        
+        public void onCloseJar() {
+                // update gui
+                m_frame.setTitle(Constants.Name);
+                setObfClasses(null);
+                setDeobfClasses(null);
+                setSource(null);
+                m_classesPanel.removeAll();
+                
+                // update menu
+                m_closeJarMenu.setEnabled(false);
+                m_openMappingsMenu.setEnabled(false);
+                m_saveMappingsMenu.setEnabled(false);
+                m_saveMappingsAsMenu.setEnabled(false);
+                m_closeMappingsMenu.setEnabled(false);
+                m_exportSourceMenu.setEnabled(false);
+                m_exportJarMenu.setEnabled(false);
+                
+                redraw();
+        }
+        
+        public void setObfClasses(Collection<ClassEntry> obfClasses) {
+                m_obfClasses.setClasses(obfClasses);
+        }
+        
+        public void setDeobfClasses(Collection<ClassEntry> deobfClasses) {
+                m_deobfClasses.setClasses(deobfClasses);
+        }
+        
+        public void setMappingsFile(File file) {
+                m_mappingsFileChooser.setSelectedFile(file);
+                m_saveMappingsMenu.setEnabled(file != null);
+        }
+        
+        public void setSource(String source) {
+                m_editor.getHighlighter().removeAllHighlights();
+                m_editor.setText(source);
+        }
+        
+        public void showToken(final Token token) {
+                if (token == null) {
+                        throw new IllegalArgumentException("Token cannot be null!");
+                }
+                
+                // set the caret position to the token
+                m_editor.setCaretPosition(token.start);
+                m_editor.grabFocus();
+                
+                try {
+                        // make sure the token is visible in the scroll window
+                        Rectangle start = m_editor.modelToView(token.start);
+                        Rectangle end = m_editor.modelToView(token.end);
+                        final Rectangle show = start.union(end);
+                        show.grow(start.width * 10, start.height * 6);
+                        SwingUtilities.invokeLater(new Runnable() {
+                                @Override
+                                public void run() {
+                                        m_editor.scrollRectToVisible(show);
+                                }
+                        });
+                } catch (BadLocationException ex) {
+                        throw new Error(ex);
+                }
+                
+                // highlight the token momentarily
+                final Timer timer = new Timer(200, new ActionListener() {
+                        private int m_counter = 0;
+                        private Object m_highlight = null;
+                        
+                        @Override
+                        public void actionPerformed(ActionEvent event) {
+                                if (m_counter % 2 == 0) {
+                                        try {
+                                                m_highlight = m_editor.getHighlighter().addHighlight(token.start, token.end, m_selectionHighlightPainter);
+                                        } catch (BadLocationException ex) {
+                                                // don't care
+                                        }
+                                } else if (m_highlight != null) {
+                                        m_editor.getHighlighter().removeHighlight(m_highlight);
+                                }
+                                
+                                if (m_counter++ > 6) {
+                                        Timer timer = (Timer)event.getSource();
+                                        timer.stop();
+                                }
+                        }
+                });
+                timer.start();
+                
+                redraw();
+        }
+        
+        public void showTokens(Collection<Token> tokens) {
+                Vector<Token> sortedTokens = new Vector<Token>(tokens);
+                Collections.sort(sortedTokens);
+                if (sortedTokens.size() > 1) {
+                        // sort the tokens and update the tokens panel
+                        m_tokens.setListData(sortedTokens);
+                        m_tokens.setSelectedIndex(0);
+                } else {
+                        m_tokens.setListData(new Vector<Token>());
+                }
+                
+                // show the first token
+                showToken(sortedTokens.get(0));
+        }
+        
+        public void setHighlightedTokens(Iterable<Token> obfuscatedTokens, Iterable<Token> deobfuscatedTokens, Iterable<Token> otherTokens) {
+                
+                // remove any old highlighters
+                m_editor.getHighlighter().removeAllHighlights();
+                
+                // color things based on the index
+                if (obfuscatedTokens != null) {
+                        setHighlightedTokens(obfuscatedTokens, m_obfuscatedHighlightPainter);
+                }
+                if (deobfuscatedTokens != null) {
+                        setHighlightedTokens(deobfuscatedTokens, m_deobfuscatedHighlightPainter);
+                }
+                if (otherTokens != null) {
+                        setHighlightedTokens(otherTokens, m_otherHighlightPainter);
+                }
+                
+                redraw();
+        }
+        
+        private void setHighlightedTokens(Iterable<Token> tokens, Highlighter.HighlightPainter painter) {
+                for (Token token : tokens) {
+                        try {
+                                m_editor.getHighlighter().addHighlight(token.start, token.end, painter);
+                        } catch (BadLocationException ex) {
+                                throw new IllegalArgumentException(ex);
+                        }
+                }
+        }
+        
+        private void clearReference() {
+                m_infoPanel.removeAll();
+                JLabel label = new JLabel("No identifier selected");
+                GuiTricks.unboldLabel(label);
+                label.setHorizontalAlignment(JLabel.CENTER);
+                m_infoPanel.add(label);
+                
+                redraw();
+        }
+        
+        private void showReference(EntryReference<Entry,Entry> reference) {
+                if (reference == null) {
+                        clearReference();
+                        return;
+                }
+                
+                m_reference = reference;
+                
+                m_infoPanel.removeAll();
+                if (reference.entry instanceof ClassEntry) {
+                        showClassEntry((ClassEntry)m_reference.entry);
+                } else if (m_reference.entry instanceof FieldEntry) {
+                        showFieldEntry((FieldEntry)m_reference.entry);
+                } else if (m_reference.entry instanceof MethodEntry) {
+                        showMethodEntry((MethodEntry)m_reference.entry);
+                } else if (m_reference.entry instanceof ConstructorEntry) {
+                        showConstructorEntry((ConstructorEntry)m_reference.entry);
+                } else if (m_reference.entry instanceof ArgumentEntry) {
+                        showArgumentEntry((ArgumentEntry)m_reference.entry);
+                } else {
+                        throw new Error("Unknown entry type: " + m_reference.entry.getClass().getName());
+                }
+                
+                redraw();
+        }
+        
+        private void showClassEntry(ClassEntry entry) {
+                addNameValue(m_infoPanel, "Class", entry.getName());
+        }
+        
+        private void showFieldEntry(FieldEntry entry) {
+                addNameValue(m_infoPanel, "Field", entry.getName());
+                addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
+        }
+        
+        private void showMethodEntry(MethodEntry entry) {
+                addNameValue(m_infoPanel, "Method", entry.getName());
+                addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
+                addNameValue(m_infoPanel, "Signature", entry.getSignature().toString());
+        }
+        
+        private void showConstructorEntry(ConstructorEntry entry) {
+                addNameValue(m_infoPanel, "Constructor", entry.getClassEntry().getName());
+                addNameValue(m_infoPanel, "Signature", entry.getSignature().toString());
+        }
+        
+        private void showArgumentEntry(ArgumentEntry entry) {
+                addNameValue(m_infoPanel, "Argument", entry.getName());
+                addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
+                addNameValue(m_infoPanel, "Method", entry.getBehaviorEntry().getName());
+                addNameValue(m_infoPanel, "Index", Integer.toString(entry.getIndex()));
+        }
+        
+        private void addNameValue(JPanel container, String name, String value) {
+                JPanel panel = new JPanel();
+                panel.setLayout(new FlowLayout(FlowLayout.LEFT, 6, 0));
+                container.add(panel);
+                
+                JLabel label = new JLabel(name + ":", JLabel.RIGHT);
+                label.setPreferredSize(new Dimension(100, label.getPreferredSize().height));
+                panel.add(label);
+                
+                panel.add(GuiTricks.unboldLabel(new JLabel(value, JLabel.LEFT)));
+        }
+        
+        private void onCaretMove(int pos) {
+                
+                Token token = m_controller.getToken(pos);
+                boolean isToken = token != null;
+                
+                m_reference = m_controller.getDeobfReference(token);
+                boolean isClassEntry = isToken && m_reference.entry instanceof ClassEntry;
+                boolean isFieldEntry = isToken && m_reference.entry instanceof FieldEntry;
+                boolean isMethodEntry = isToken && m_reference.entry instanceof MethodEntry;
+                boolean isConstructorEntry = isToken && m_reference.entry instanceof ConstructorEntry;
+                boolean isInJar = isToken && m_controller.entryIsInJar(m_reference.entry);
+                boolean isRenameable = isToken && m_controller.referenceIsRenameable(m_reference);
+                
+                if (isToken) {
+                        showReference(m_reference);
+                } else {
+                        clearReference();
+                }
+                
+                m_renameMenu.setEnabled(isRenameable && isToken);
+                m_showInheritanceMenu.setEnabled(isClassEntry || isMethodEntry || isConstructorEntry);
+                m_showImplementationsMenu.setEnabled(isClassEntry || isMethodEntry);
+                m_showCallsMenu.setEnabled(isClassEntry || isFieldEntry || isMethodEntry || isConstructorEntry);
+                m_openEntryMenu.setEnabled(isInJar && (isClassEntry || isFieldEntry || isMethodEntry || isConstructorEntry));
+                m_openPreviousMenu.setEnabled(m_controller.hasPreviousLocation());
+                m_toggleMappingMenu.setEnabled(isRenameable && isToken);
+                
+                if (isToken && m_controller.entryHasDeobfuscatedName(m_reference.entry)) {
+                        m_toggleMappingMenu.setText("Reset to obfuscated");
+                } else {
+                        m_toggleMappingMenu.setText("Mark as deobfuscated");
+                }
+        }
+        
+        private void navigateTo(Entry entry) {
+                if (!m_controller.entryIsInJar(entry)) {
+                        // entry is not in the jar. Ignore it
+                        return;
+                }
+                if (m_reference != null) {
+                        m_controller.savePreviousReference(m_reference);
+                }
+                m_controller.openDeclaration(entry);
+        }
+        
+        private void navigateTo(EntryReference<Entry,Entry> reference) {
+                if (!m_controller.entryIsInJar(reference.getLocationClassEntry())) {
+                        // reference is not in the jar. Ignore it
+                        return;
+                }
+                if (m_reference != null) {
+                        m_controller.savePreviousReference(m_reference);
+                }
+                m_controller.openReference(reference);
+        }
+        
+        private void startRename() {
+                
+                // init the text box
+                final JTextField text = new JTextField();
+                text.setText(m_reference.getNamableName());
+                text.setPreferredSize(new Dimension(360, text.getPreferredSize().height));
+                text.addKeyListener(new KeyAdapter() {
+                        @Override
+                        public void keyPressed(KeyEvent event) {
+                                switch (event.getKeyCode()) {
+                                        case KeyEvent.VK_ENTER:
+                                                finishRename(text, true);
+                                        break;
+                                        
+                                        case KeyEvent.VK_ESCAPE:
+                                                finishRename(text, false);
+                                        break;
+                                }
+                        }
+                });
+                
+                // find the label with the name and replace it with the text box
+                JPanel panel = (JPanel)m_infoPanel.getComponent(0);
+                panel.remove(panel.getComponentCount() - 1);
+                panel.add(text);
+                text.grabFocus();
+                text.selectAll();
+                
+                redraw();
+        }
+        
+        private void finishRename(JTextField text, boolean saveName) {
+                String newName = text.getText();
+                if (saveName && newName != null && newName.length() > 0) {
+                        try {
+                                m_controller.rename(m_reference, newName);
+                        } catch (IllegalNameException ex) {
+                                text.setBorder(BorderFactory.createLineBorder(Color.red, 1));
+                                text.setToolTipText(ex.getReason());
+                                GuiTricks.showToolTipNow(text);
+                        }
+                        return;
+                }
+                
+                // abort the rename
+                JPanel panel = (JPanel)m_infoPanel.getComponent(0);
+                panel.remove(panel.getComponentCount() - 1);
+                panel.add(GuiTricks.unboldLabel(new JLabel(m_reference.getNamableName(), JLabel.LEFT)));
+                
+                m_editor.grabFocus();
+                
+                redraw();
+        }
+        
+        private void showInheritance() {
+                
+                if (m_reference == null) {
+                        return;
+                }
+                
+                m_inheritanceTree.setModel(null);
+                
+                if (m_reference.entry instanceof ClassEntry) {
+                        // get the class inheritance
+                        ClassInheritanceTreeNode classNode = m_controller.getClassInheritance((ClassEntry)m_reference.entry);
+                        
+                        // show the tree at the root
+                        TreePath path = getPathToRoot(classNode);
+                        m_inheritanceTree.setModel(new DefaultTreeModel((TreeNode)path.getPathComponent(0)));
+                        m_inheritanceTree.expandPath(path);
+                        m_inheritanceTree.setSelectionRow(m_inheritanceTree.getRowForPath(path));
+                } else if (m_reference.entry instanceof MethodEntry) {
+                        // get the method inheritance
+                        MethodInheritanceTreeNode classNode = m_controller.getMethodInheritance((MethodEntry)m_reference.entry);
+                        
+                        // show the tree at the root
+                        TreePath path = getPathToRoot(classNode);
+                        m_inheritanceTree.setModel(new DefaultTreeModel((TreeNode)path.getPathComponent(0)));
+                        m_inheritanceTree.expandPath(path);
+                        m_inheritanceTree.setSelectionRow(m_inheritanceTree.getRowForPath(path));
+                }
+                
+                m_tabs.setSelectedIndex(0);
+                redraw();
+        }
+        
+        private void showImplementations() {
+                
+                if (m_reference == null) {
+                        return;
+                }
+                
+                m_implementationsTree.setModel(null);
+                
+                if (m_reference.entry instanceof ClassEntry) {
+                        // get the class implementations
+                        ClassImplementationsTreeNode node = m_controller.getClassImplementations((ClassEntry)m_reference.entry);
+                        if (node != null) {
+                                // show the tree at the root
+                                TreePath path = getPathToRoot(node);
+                                m_implementationsTree.setModel(new DefaultTreeModel((TreeNode)path.getPathComponent(0)));
+                                m_implementationsTree.expandPath(path);
+                                m_implementationsTree.setSelectionRow(m_implementationsTree.getRowForPath(path));
+                        }
+                } else if (m_reference.entry instanceof MethodEntry) {
+                        // get the method implementations
+                        MethodImplementationsTreeNode node = m_controller.getMethodImplementations((MethodEntry)m_reference.entry);
+                        if (node != null) {
+                                // show the tree at the root
+                                TreePath path = getPathToRoot(node);
+                                m_implementationsTree.setModel(new DefaultTreeModel((TreeNode)path.getPathComponent(0)));
+                                m_implementationsTree.expandPath(path);
+                                m_implementationsTree.setSelectionRow(m_implementationsTree.getRowForPath(path));
+                        }
+                }
+                
+                m_tabs.setSelectedIndex(1);
+                redraw();
+        }
+        
+        private void showCalls() {
+                
+                if (m_reference == null) {
+                        return;
+                }
+                
+                if (m_reference.entry instanceof ClassEntry) {
+                        // look for calls to the default constructor
+                        // TODO: get a list of all the constructors and find calls to all of them
+                        BehaviorReferenceTreeNode node = m_controller.getMethodReferences(new ConstructorEntry((ClassEntry)m_reference.entry, new Signature("()V")));
+                        m_callsTree.setModel(new DefaultTreeModel(node));
+                } else if (m_reference.entry instanceof FieldEntry) {
+                        FieldReferenceTreeNode node = m_controller.getFieldReferences((FieldEntry)m_reference.entry);
+                        m_callsTree.setModel(new DefaultTreeModel(node));
+                } else if (m_reference.entry instanceof MethodEntry) {
+                        BehaviorReferenceTreeNode node = m_controller.getMethodReferences((MethodEntry)m_reference.entry);
+                        m_callsTree.setModel(new DefaultTreeModel(node));
+                } else if (m_reference.entry instanceof ConstructorEntry) {
+                        BehaviorReferenceTreeNode node = m_controller.getMethodReferences((ConstructorEntry)m_reference.entry);
+                        m_callsTree.setModel(new DefaultTreeModel(node));
+                }
+                
+                m_tabs.setSelectedIndex(2);
+                redraw();
+        }
+        
+        private void toggleMapping() {
+                if (m_controller.entryHasDeobfuscatedName(m_reference.entry)) {
+                        m_controller.removeMapping(m_reference);
+                } else {
+                        m_controller.markAsDeobfuscated(m_reference);
+                }
+        }
+        
+        private TreePath getPathToRoot(TreeNode node) {
+                List<TreeNode> nodes = Lists.newArrayList();
+                TreeNode n = node;
+                do {
+                        nodes.add(n);
+                        n = n.getParent();
+                } while (n != null);
+                Collections.reverse(nodes);
+                return new TreePath(nodes.toArray());
+        }
+        
+        private void close() {
+                if (!m_controller.isDirty()) {
+                        // everything is saved, we can exit safely
+                        m_frame.dispose();
+                } else {
+                        // ask to save before closing
+                        String[] options = { "Save and exit", "Discard changes", "Cancel" };
+                        int response = JOptionPane.showOptionDialog(m_frame, "Your mappings have not been saved yet. Do you want to save?", "Save your changes?", JOptionPane.YES_NO_CANCEL_OPTION,
+                                        JOptionPane.QUESTION_MESSAGE, null, options, options[2]);
+                        switch (response) {
+                                case JOptionPane.YES_OPTION: // save and exit
+                                        if (m_mappingsFileChooser.getSelectedFile() != null || m_mappingsFileChooser.showSaveDialog(m_frame) == JFileChooser.APPROVE_OPTION) {
+                                                try {
+                                                        m_controller.saveMappings(m_mappingsFileChooser.getSelectedFile());
+                                                        m_frame.dispose();
+                                                } catch (IOException ex) {
+                                                        throw new Error(ex);
+                                                }
+                                        }
+                                break;
+                                
+                                case JOptionPane.NO_OPTION:
+                                        // don't save, exit
+                                        m_frame.dispose();
+                                break;
+                        
+                                // cancel means do nothing
+                        }
+                }
+        }
+        
+        private void redraw() {
+                m_frame.validate();
+                m_frame.repaint();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java
new file mode 100644
index 0000000..61fea9c
--- /dev/null
+++ b/src/cuchaz/enigma/gui/GuiController.java
@@ -0,0 +1,355 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.List;
+import java.util.jar.JarFile;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Queues;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+
+import cuchaz.enigma.Deobfuscator;
+import cuchaz.enigma.Deobfuscator.ProgressListener;
+import cuchaz.enigma.analysis.BehaviorReferenceTreeNode;
+import cuchaz.enigma.analysis.ClassImplementationsTreeNode;
+import cuchaz.enigma.analysis.ClassInheritanceTreeNode;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.FieldReferenceTreeNode;
+import cuchaz.enigma.analysis.MethodImplementationsTreeNode;
+import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
+import cuchaz.enigma.analysis.SourceIndex;
+import cuchaz.enigma.analysis.Token;
+import cuchaz.enigma.gui.ProgressDialog.ProgressRunnable;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MappingParseException;
+import cuchaz.enigma.mapping.MappingsReader;
+import cuchaz.enigma.mapping.MappingsWriter;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.TranslationDirection;
+
+public class GuiController {
+        
+        private Deobfuscator m_deobfuscator;
+        private Gui m_gui;
+        private SourceIndex m_index;
+        private ClassEntry m_currentObfClass;
+        private boolean m_isDirty;
+        private Deque<EntryReference<Entry,Entry>> m_referenceStack;
+        
+        public GuiController(Gui gui) {
+                m_gui = gui;
+                m_deobfuscator = null;
+                m_index = null;
+                m_currentObfClass = null;
+                m_isDirty = false;
+                m_referenceStack = Queues.newArrayDeque();
+        }
+        
+        public boolean isDirty() {
+                return m_isDirty;
+        }
+        
+        public void openJar(final JarFile jar) throws IOException {
+                m_gui.onStartOpenJar();
+                m_deobfuscator = new Deobfuscator(jar);
+                m_gui.onFinishOpenJar(m_deobfuscator.getJarName());
+                refreshClasses();
+        }
+        
+        public void closeJar() {
+                m_deobfuscator = null;
+                m_gui.onCloseJar();
+        }
+        
+        public void openMappings(File file) throws IOException, MappingParseException {
+                FileReader in = new FileReader(file);
+                m_deobfuscator.setMappings(new MappingsReader().read(in));
+                in.close();
+                m_isDirty = false;
+                m_gui.setMappingsFile(file);
+                refreshClasses();
+                refreshCurrentClass();
+        }
+        
+        public void saveMappings(File file) throws IOException {
+                FileWriter out = new FileWriter(file);
+                new MappingsWriter().write(out, m_deobfuscator.getMappings());
+                out.close();
+                m_isDirty = false;
+        }
+        
+        public void closeMappings() {
+                m_deobfuscator.setMappings(null);
+                m_gui.setMappingsFile(null);
+                refreshClasses();
+                refreshCurrentClass();
+        }
+        
+        public void exportSource(final File dirOut) {
+                ProgressDialog.runInThread(m_gui.getFrame(), new ProgressRunnable() {
+                        @Override
+                        public void run(ProgressListener progress) throws Exception {
+                                m_deobfuscator.writeSources(dirOut, progress);
+                        }
+                });
+        }
+        
+        public void exportJar(final File fileOut) {
+                ProgressDialog.runInThread(m_gui.getFrame(), new ProgressRunnable() {
+                        @Override
+                        public void run(ProgressListener progress) {
+                                m_deobfuscator.writeJar(fileOut, progress);
+                        }
+                });
+        }
+        
+        public Token getToken(int pos) {
+                if (m_index == null) {
+                        return null;
+                }
+                return m_index.getReferenceToken(pos);
+        }
+        
+        public EntryReference<Entry,Entry> getDeobfReference(Token token) {
+                if (m_index == null) {
+                        return null;
+                }
+                return m_index.getDeobfReference(token);
+        }
+        
+        public ReadableToken getReadableToken(Token token) {
+                if (m_index == null) {
+                        return null;
+                }
+                return new ReadableToken(
+                        m_index.getLineNumber(token.start),
+                        m_index.getColumnNumber(token.start),
+                        m_index.getColumnNumber(token.end)
+                );
+        }
+        
+        public boolean entryHasDeobfuscatedName(Entry deobfEntry) {
+                return m_deobfuscator.hasDeobfuscatedName(m_deobfuscator.obfuscateEntry(deobfEntry));
+        }
+        
+        public boolean entryIsInJar(Entry deobfEntry) {
+                return m_deobfuscator.isObfuscatedIdentifier(m_deobfuscator.obfuscateEntry(deobfEntry));
+        }
+        
+        public boolean referenceIsRenameable(EntryReference<Entry,Entry> deobfReference) {
+                return m_deobfuscator.isRenameable(m_deobfuscator.obfuscateReference(deobfReference));
+        }
+        
+        public ClassInheritanceTreeNode getClassInheritance(ClassEntry deobfClassEntry) {
+                ClassEntry obfClassEntry = m_deobfuscator.obfuscateEntry(deobfClassEntry);
+                ClassInheritanceTreeNode rootNode = m_deobfuscator.getJarIndex().getClassInheritance(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfClassEntry
+                );
+                return ClassInheritanceTreeNode.findNode(rootNode, obfClassEntry);
+        }
+        
+        public ClassImplementationsTreeNode getClassImplementations(ClassEntry deobfClassEntry) {
+                ClassEntry obfClassEntry = m_deobfuscator.obfuscateEntry(deobfClassEntry);
+                return m_deobfuscator.getJarIndex().getClassImplementations(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfClassEntry
+                );
+        }
+        
+        public MethodInheritanceTreeNode getMethodInheritance(MethodEntry deobfMethodEntry) {
+                MethodEntry obfMethodEntry = m_deobfuscator.obfuscateEntry(deobfMethodEntry);
+                MethodInheritanceTreeNode rootNode = m_deobfuscator.getJarIndex().getMethodInheritance(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfMethodEntry
+                );
+                return MethodInheritanceTreeNode.findNode(rootNode, obfMethodEntry);
+        }
+        
+        public MethodImplementationsTreeNode getMethodImplementations(MethodEntry deobfMethodEntry) {
+                MethodEntry obfMethodEntry = m_deobfuscator.obfuscateEntry(deobfMethodEntry);
+                MethodImplementationsTreeNode rootNode = m_deobfuscator.getJarIndex().getMethodImplementations(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfMethodEntry
+                );
+                if (rootNode == null) {
+                        return null;
+                }
+                return MethodImplementationsTreeNode.findNode(rootNode, obfMethodEntry);
+        }
+        
+        public FieldReferenceTreeNode getFieldReferences(FieldEntry deobfFieldEntry) {
+                FieldEntry obfFieldEntry = m_deobfuscator.obfuscateEntry(deobfFieldEntry);
+                FieldReferenceTreeNode rootNode = new FieldReferenceTreeNode(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfFieldEntry
+                );
+                rootNode.load(m_deobfuscator.getJarIndex(), true);
+                return rootNode;
+        }
+        
+        public BehaviorReferenceTreeNode getMethodReferences(BehaviorEntry deobfBehaviorEntry) {
+                BehaviorEntry obfBehaviorEntry = m_deobfuscator.obfuscateEntry(deobfBehaviorEntry);
+                BehaviorReferenceTreeNode rootNode = new BehaviorReferenceTreeNode(
+                        m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating),
+                        obfBehaviorEntry
+                );
+                rootNode.load(m_deobfuscator.getJarIndex(), true);
+                return rootNode;
+        }
+        
+        public void rename(EntryReference<Entry,Entry> deobfReference, String newName) {
+                EntryReference<Entry,Entry> obfReference = m_deobfuscator.obfuscateReference(deobfReference);
+                m_deobfuscator.rename(obfReference.getNameableEntry(), newName);
+                m_isDirty = true;
+                refreshClasses();
+                refreshCurrentClass(obfReference);
+        }
+        
+        public void removeMapping(EntryReference<Entry,Entry> deobfReference) {
+                EntryReference<Entry,Entry> obfReference = m_deobfuscator.obfuscateReference(deobfReference);
+                m_deobfuscator.removeMapping(obfReference.getNameableEntry());
+                m_isDirty = true;
+                refreshClasses();
+                refreshCurrentClass(obfReference);
+        }
+        
+        public void markAsDeobfuscated(EntryReference<Entry,Entry> deobfReference) {
+                EntryReference<Entry,Entry> obfReference = m_deobfuscator.obfuscateReference(deobfReference);
+                m_deobfuscator.markAsDeobfuscated(obfReference.getNameableEntry());
+                m_isDirty = true;
+                refreshClasses();
+                refreshCurrentClass(obfReference);
+        }
+        
+        public void openDeclaration(Entry deobfEntry) {
+                if (deobfEntry == null) {
+                        throw new IllegalArgumentException("Entry cannot be null!");
+                }
+                openReference(new EntryReference<Entry,Entry>(deobfEntry, deobfEntry.getName()));
+        }
+        
+        public void openReference(EntryReference<Entry,Entry> deobfReference) {
+                if (deobfReference == null) {
+                        throw new IllegalArgumentException("Reference cannot be null!");
+                }
+                
+                // get the reference target class
+                EntryReference<Entry,Entry> obfReference = m_deobfuscator.obfuscateReference(deobfReference);
+                ClassEntry obfClassEntry = obfReference.getLocationClassEntry().getOuterClassEntry();
+                if (!m_deobfuscator.isObfuscatedIdentifier(obfClassEntry)) {
+                        throw new IllegalArgumentException("Obfuscated class " + obfClassEntry + " was not found in the jar!");
+                }
+                if (m_currentObfClass == null || !m_currentObfClass.equals(obfClassEntry)) {
+                        // deobfuscate the class, then navigate to the reference
+                        m_currentObfClass = obfClassEntry;
+                        deobfuscate(m_currentObfClass, obfReference);
+                } else {
+                        showReference(obfReference);
+                }
+        }
+        
+        private void showReference(EntryReference<Entry,Entry> obfReference) {
+                EntryReference<Entry,Entry> deobfReference = m_deobfuscator.deobfuscateReference(obfReference);
+                Collection<Token> tokens = m_index.getReferenceTokens(deobfReference);
+                if (tokens.isEmpty()) {
+                        // DEBUG
+                        System.err.println(String.format("WARNING: no tokens found for %s in %s", deobfReference, m_currentObfClass));
+                } else {
+                        m_gui.showTokens(tokens);
+                }
+        }
+        
+        public void savePreviousReference(EntryReference<Entry,Entry> deobfReference) {
+                m_referenceStack.push(m_deobfuscator.obfuscateReference(deobfReference));
+        }
+        
+        public void openPreviousReference() {
+                if (hasPreviousLocation()) {
+                        openReference(m_deobfuscator.deobfuscateReference(m_referenceStack.pop()));
+                }
+        }
+        
+        public boolean hasPreviousLocation() {
+                return !m_referenceStack.isEmpty();
+        }
+        
+        private void refreshClasses() {
+                List<ClassEntry> obfClasses = Lists.newArrayList();
+                List<ClassEntry> deobfClasses = Lists.newArrayList();
+                m_deobfuscator.getSeparatedClasses(obfClasses, deobfClasses);
+                m_gui.setObfClasses(obfClasses);
+                m_gui.setDeobfClasses(deobfClasses);
+        }
+        
+        private void refreshCurrentClass() {
+                refreshCurrentClass(null);
+        }
+        
+        private void refreshCurrentClass(EntryReference<Entry,Entry> obfReference) {
+                if (m_currentObfClass != null) {
+                        deobfuscate(m_currentObfClass, obfReference);
+                }
+        }
+        
+        private void deobfuscate(final ClassEntry classEntry, final EntryReference<Entry,Entry> obfReference) {
+                
+                m_gui.setSource("(deobfuscating...)");
+                
+                // run the deobfuscator in a separate thread so we don't block the GUI event queue
+                new Thread() {
+                        @Override
+                        public void run() {
+                                // decompile,deobfuscate the bytecode
+                                CompilationUnit sourceTree = m_deobfuscator.getSourceTree(classEntry.getClassName());
+                                if (sourceTree == null) {
+                                        // decompilation of this class is not supported
+                                        m_gui.setSource("Unable to find class: " + classEntry);
+                                        return;
+                                }
+                                String source = m_deobfuscator.getSource(sourceTree);
+                                m_index = m_deobfuscator.getSourceIndex(sourceTree, source);
+                                m_gui.setSource(m_index.getSource());
+                                if (obfReference != null) {
+                                        showReference(obfReference);
+                                }
+                                
+                                // set the highlighted tokens
+                                List<Token> obfuscatedTokens = Lists.newArrayList();
+                                List<Token> deobfuscatedTokens = Lists.newArrayList();
+                                List<Token> otherTokens = Lists.newArrayList();
+                                for (Token token : m_index.referenceTokens()) {
+                                        EntryReference<Entry,Entry> reference = m_index.getDeobfReference(token);
+                                        if (referenceIsRenameable(reference)) {
+                                                if (entryHasDeobfuscatedName(reference.getNameableEntry())) {
+                                                        deobfuscatedTokens.add(token);
+                                                } else {
+                                                        obfuscatedTokens.add(token);
+                                                }
+                                        } else {
+                                                otherTokens.add(token);
+                                        }
+                                }
+                                m_gui.setHighlightedTokens(obfuscatedTokens, deobfuscatedTokens, otherTokens);
+                        }
+                }.start();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/GuiTricks.java b/src/cuchaz/enigma/gui/GuiTricks.java
new file mode 100644
index 0000000..df9e221
--- /dev/null
+++ b/src/cuchaz/enigma/gui/GuiTricks.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Font;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.ToolTipManager;
+
+public class GuiTricks {
+        
+        public static JLabel unboldLabel(JLabel label) {
+                Font font = label.getFont();
+                label.setFont(font.deriveFont(font.getStyle() & ~Font.BOLD));
+                return label;
+        }
+        
+        public static void showToolTipNow(JComponent component) {
+                // HACKHACK: trick the tooltip manager into showing the tooltip right now
+                ToolTipManager manager = ToolTipManager.sharedInstance();
+                int oldDelay = manager.getInitialDelay();
+                manager.setInitialDelay(0);
+                manager.mouseMoved(new MouseEvent(component, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(), 0, 0, 0, 0, false));
+                manager.setInitialDelay(oldDelay);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ObfuscatedHighlightPainter.java b/src/cuchaz/enigma/gui/ObfuscatedHighlightPainter.java
new file mode 100644
index 0000000..177835f
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ObfuscatedHighlightPainter.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+
+public class ObfuscatedHighlightPainter extends BoxHighlightPainter {
+        
+        public ObfuscatedHighlightPainter() {
+                // red ish
+                super(new Color(255, 220, 220), new Color(160, 80, 80));
+        }
+}
diff --git a/src/cuchaz/enigma/gui/OtherHighlightPainter.java b/src/cuchaz/enigma/gui/OtherHighlightPainter.java
new file mode 100644
index 0000000..4e9c870
--- /dev/null
+++ b/src/cuchaz/enigma/gui/OtherHighlightPainter.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Color;
+
+public class OtherHighlightPainter extends BoxHighlightPainter {
+        
+        public OtherHighlightPainter() {
+                // grey
+                super(null, new Color(180, 180, 180));
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ProgressDialog.java b/src/cuchaz/enigma/gui/ProgressDialog.java
new file mode 100644
index 0000000..b864fdb
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ProgressDialog.java
@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+
+import javax.swing.BorderFactory;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JProgressBar;
+import javax.swing.WindowConstants;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.Deobfuscator.ProgressListener;
+
+public class ProgressDialog implements ProgressListener, AutoCloseable {
+        
+        private JFrame m_frame;
+        private JLabel m_title;
+        private JLabel m_text;
+        private JProgressBar m_progress;
+        
+        public ProgressDialog(JFrame parent) {
+                
+                // init frame
+                m_frame = new JFrame(Constants.Name + " - Operation in progress");
+                final Container pane = m_frame.getContentPane();
+                FlowLayout layout = new FlowLayout();
+                layout.setAlignment(FlowLayout.LEFT);
+                pane.setLayout(layout);
+                
+                m_title = new JLabel();
+                pane.add(m_title);
+                
+                // set up the progress bar
+                JPanel panel = new JPanel();
+                pane.add(panel);
+                panel.setLayout(new BorderLayout());
+                m_text = GuiTricks.unboldLabel(new JLabel());
+                m_progress = new JProgressBar();
+                m_text.setBorder(BorderFactory.createEmptyBorder(0, 0, 10, 0));
+                panel.add(m_text, BorderLayout.NORTH);
+                panel.add(m_progress, BorderLayout.CENTER);
+                panel.setPreferredSize(new Dimension(360, 50));
+                
+                // show the frame
+                pane.doLayout();
+                m_frame.setSize(400, 120);
+                m_frame.setResizable(false);
+                m_frame.setLocationRelativeTo(parent);
+                m_frame.setVisible(true);
+                m_frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        }
+        
+        public void close() {
+                m_frame.dispose();
+        }
+        
+        @Override
+        public void init(int totalWork, String title) {
+                m_title.setText(title);
+                m_progress.setMinimum(0);
+                m_progress.setMaximum(totalWork);
+                m_progress.setValue(0);
+        }
+        
+        @Override
+        public void onProgress(int numDone, String message) {
+                m_text.setText(message);
+                m_progress.setValue(numDone);
+                
+                // update the frame
+                m_frame.validate();
+                m_frame.repaint();
+        }
+        
+        public static interface ProgressRunnable {
+                void run(ProgressListener listener) throws Exception;
+        }
+        
+        public static void runInThread(final JFrame parent, final ProgressRunnable runnable) {
+                new Thread() {
+                        @Override
+                        public void run() {
+                                try (ProgressDialog progress = new ProgressDialog(parent)) {
+                                        runnable.run(progress);
+                                } catch (Exception ex) {
+                                        throw new Error(ex);
+                                }
+                        }
+                }.start();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/ReadableToken.java b/src/cuchaz/enigma/gui/ReadableToken.java
new file mode 100644
index 0000000..66bcbc2
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ReadableToken.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+public class ReadableToken {
+        
+        public int line;
+        public int startColumn;
+        public int endColumn;
+        
+        public ReadableToken(int line, int startColumn, int endColumn) {
+                this.line = line;
+                this.startColumn = startColumn;
+                this.endColumn = endColumn;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("line ");
+                buf.append(line);
+                buf.append(" columns ");
+                buf.append(startColumn);
+                buf.append("-");
+                buf.append(endColumn);
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/gui/RenameListener.java b/src/cuchaz/enigma/gui/RenameListener.java
new file mode 100644
index 0000000..abeda0c
--- /dev/null
+++ b/src/cuchaz/enigma/gui/RenameListener.java
@@ -0,0 +1,17 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import cuchaz.enigma.mapping.Entry;
+
+public interface RenameListener {
+        void rename(Entry obfEntry, String newName);
+}
diff --git a/src/cuchaz/enigma/gui/SelectionHighlightPainter.java b/src/cuchaz/enigma/gui/SelectionHighlightPainter.java
new file mode 100644
index 0000000..5e189d2
--- /dev/null
+++ b/src/cuchaz/enigma/gui/SelectionHighlightPainter.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.Shape;
+
+import javax.swing.text.Highlighter;
+import javax.swing.text.JTextComponent;
+
+public class SelectionHighlightPainter implements Highlighter.HighlightPainter {
+        
+        @Override
+        public void paint(Graphics g, int start, int end, Shape shape, JTextComponent text) {
+                // draw a thick border
+                Graphics2D g2d = (Graphics2D)g;
+                Rectangle bounds = BoxHighlightPainter.getBounds(text, start, end);
+                g2d.setColor(Color.black);
+                g2d.setStroke(new BasicStroke(2.0f));
+                g2d.drawRoundRect(bounds.x, bounds.y, bounds.width, bounds.height, 4, 4);
+        }
+}
diff --git a/src/cuchaz/enigma/gui/TokenListCellRenderer.java b/src/cuchaz/enigma/gui/TokenListCellRenderer.java
new file mode 100644
index 0000000..a49be37
--- /dev/null
+++ b/src/cuchaz/enigma/gui/TokenListCellRenderer.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.gui;
+
+import java.awt.Component;
+
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.ListCellRenderer;
+
+import cuchaz.enigma.analysis.Token;
+
+public class TokenListCellRenderer implements ListCellRenderer<Token> {
+        
+        private GuiController m_controller;
+        private DefaultListCellRenderer m_defaultRenderer;
+        
+        public TokenListCellRenderer(GuiController controller) {
+                m_controller = controller;
+                m_defaultRenderer = new DefaultListCellRenderer();
+        }
+        
+        @Override
+        public Component getListCellRendererComponent(JList<? extends Token> list, Token token, int index, boolean isSelected, boolean hasFocus) {
+                JLabel label = (JLabel)m_defaultRenderer.getListCellRendererComponent(list, token, index, isSelected, hasFocus);
+                label.setText(m_controller.getReadableToken(token).toString());
+                return label;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ArgumentEntry.java b/src/cuchaz/enigma/mapping/ArgumentEntry.java
new file mode 100644
index 0000000..aa22265
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ArgumentEntry.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class ArgumentEntry implements Entry, Serializable {
+        
+        private static final long serialVersionUID = 4472172468162696006L;
+        
+        private BehaviorEntry m_behaviorEntry;
+        private int m_index;
+        private String m_name;
+        
+        public ArgumentEntry(BehaviorEntry behaviorEntry, int index, String name) {
+                if (behaviorEntry == null) {
+                        throw new IllegalArgumentException("Behavior cannot be null!");
+                }
+                if (index < 0) {
+                        throw new IllegalArgumentException("Index must be non-negative!");
+                }
+                if (name == null) {
+                        throw new IllegalArgumentException("Argument name cannot be null!");
+                }
+                
+                m_behaviorEntry = behaviorEntry;
+                m_index = index;
+                m_name = name;
+        }
+        
+        public ArgumentEntry(ArgumentEntry other) {
+                m_behaviorEntry = (BehaviorEntry)m_behaviorEntry.cloneToNewClass(getClassEntry());
+                m_index = other.m_index;
+                m_name = other.m_name;
+        }
+        
+        public ArgumentEntry(ArgumentEntry other, String newClassName) {
+                m_behaviorEntry = (BehaviorEntry)other.m_behaviorEntry.cloneToNewClass(new ClassEntry(newClassName));
+                m_index = other.m_index;
+                m_name = other.m_name;
+        }
+        
+        public BehaviorEntry getBehaviorEntry() {
+                return m_behaviorEntry;
+        }
+        
+        public int getIndex() {
+                return m_index;
+        }
+        
+        @Override
+        public String getName() {
+                return m_name;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return m_behaviorEntry.getClassEntry();
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_behaviorEntry.getClassName();
+        }
+        
+        @Override
+        public ArgumentEntry cloneToNewClass(ClassEntry classEntry) {
+                return new ArgumentEntry(this, classEntry.getName());
+        }
+        
+        public String getMethodName() {
+                return m_behaviorEntry.getName();
+        }
+        
+        public Signature getMethodSignature() {
+                return m_behaviorEntry.getSignature();
+        }
+        
+        @Override
+        public int hashCode() {
+                return Util.combineHashesOrdered(
+                        m_behaviorEntry,
+                        Integer.valueOf(m_index).hashCode(),
+                        m_name.hashCode()
+                );
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ArgumentEntry) {
+                        return equals((ArgumentEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ArgumentEntry other) {
+                return m_behaviorEntry.equals(other.m_behaviorEntry)
+                        && m_index == other.m_index
+                        && m_name.equals(other.m_name);
+        }
+        
+        @Override
+        public String toString() {
+                return m_behaviorEntry.toString() + "(" + m_index + ":" + m_name + ")";
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ArgumentMapping.java b/src/cuchaz/enigma/mapping/ArgumentMapping.java
new file mode 100644
index 0000000..f4d8e77
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ArgumentMapping.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+public class ArgumentMapping implements Serializable, Comparable<ArgumentMapping> {
+        
+        private static final long serialVersionUID = 8610742471440861315L;
+        
+        private int m_index;
+        private String m_name;
+        
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public ArgumentMapping(int index, String name) {
+                m_index = index;
+                m_name = NameValidator.validateArgumentName(name);
+        }
+        
+        public int getIndex() {
+                return m_index;
+        }
+        
+        public String getName() {
+                return m_name;
+        }
+        
+        public void setName(String val) {
+                m_name = NameValidator.validateArgumentName(val);
+        }
+        
+        @Override
+        public int compareTo(ArgumentMapping other) {
+                return Integer.compare(m_index, other.m_index);
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/BehaviorEntry.java b/src/cuchaz/enigma/mapping/BehaviorEntry.java
new file mode 100644
index 0000000..535788f
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/BehaviorEntry.java
@@ -0,0 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public interface BehaviorEntry extends Entry {
+        Signature getSignature();
+}
diff --git a/src/cuchaz/enigma/mapping/BehaviorEntryFactory.java b/src/cuchaz/enigma/mapping/BehaviorEntryFactory.java
new file mode 100644
index 0000000..61e501b
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/BehaviorEntryFactory.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import javassist.CtBehavior;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+import javassist.bytecode.Descriptor;
+
+public class BehaviorEntryFactory {
+        
+        public static BehaviorEntry create(String className, String name, String signature) {
+                return create(new ClassEntry(className), name, signature);
+        }
+        
+        public static BehaviorEntry create(ClassEntry classEntry, String name, String signature) {
+                if (name.equals("<init>")) {
+                        return new ConstructorEntry(classEntry, new Signature(signature));
+                } else if (name.equals("<clinit>")) {
+                        return new ConstructorEntry(classEntry);
+                } else {
+                        return new MethodEntry(classEntry, name, new Signature(signature));
+                }
+        }
+        
+        public static BehaviorEntry create(CtBehavior behavior) {
+                String className = Descriptor.toJvmName(behavior.getDeclaringClass().getName());
+                if (behavior instanceof CtMethod) {
+                        return create(className, behavior.getName(), behavior.getSignature());
+                } else if (behavior instanceof CtConstructor) {
+                        CtConstructor constructor = (CtConstructor)behavior;
+                        if (constructor.isClassInitializer()) {
+                                return create(className, "<clinit>", null);
+                        } else {
+                                return create(className, "<init>", constructor.getSignature());
+                        }
+                } else {
+                        throw new IllegalArgumentException("Unable to create BehaviorEntry from " + behavior);
+                }
+        }
+        
+        public static BehaviorEntry createObf(ClassEntry classEntry, MethodMapping methodMapping) {
+                return create(classEntry, methodMapping.getObfName(), methodMapping.getObfSignature().toString());
+        }
+        
+        public static BehaviorEntry createDeobf(ClassEntry classEntry, MethodMapping methodMapping) {
+                return create(classEntry, methodMapping.getDeobfName(), methodMapping.getObfSignature().toString());
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ClassEntry.java b/src/cuchaz/enigma/mapping/ClassEntry.java
new file mode 100644
index 0000000..cf41001
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ClassEntry.java
@@ -0,0 +1,123 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+public class ClassEntry implements Entry, Serializable {
+        
+        private static final long serialVersionUID = 4235460580973955811L;
+        
+        private String m_name;
+        
+        public ClassEntry(String className) {
+                if (className == null) {
+                        throw new IllegalArgumentException("Class name cannot be null!");
+                }
+                if (className.indexOf('.') >= 0) {
+                        throw new IllegalArgumentException("Class name must be in JVM format. ie, path/to/package/class$inner : " + className);
+                }
+                
+                m_name = className;
+                
+                if (isInnerClass() && getInnerClassName().indexOf('/') >= 0) {
+                        throw new IllegalArgumentException("Inner class must not have a package: " + className);
+                }
+        }
+        
+        public ClassEntry(ClassEntry other) {
+                m_name = other.m_name;
+        }
+        
+        @Override
+        public String getName() {
+                return m_name;
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_name;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return this;
+        }
+        
+        @Override
+        public ClassEntry cloneToNewClass(ClassEntry classEntry) {
+                return classEntry;
+        }
+        
+        @Override
+        public int hashCode() {
+                return m_name.hashCode();
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ClassEntry) {
+                        return equals((ClassEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ClassEntry other) {
+                return m_name.equals(other.m_name);
+        }
+        
+        @Override
+        public String toString() {
+                return m_name;
+        }
+        
+        public boolean isInnerClass() {
+                return m_name.lastIndexOf('$') >= 0;
+        }
+        
+        public String getOuterClassName() {
+                if (isInnerClass()) {
+                        return m_name.substring(0, m_name.lastIndexOf('$'));
+                }
+                return m_name;
+        }
+        
+        public String getInnerClassName() {
+                if (!isInnerClass()) {
+                        throw new Error("This is not an inner class!");
+                }
+                return m_name.substring(m_name.lastIndexOf('$') + 1);
+        }
+        
+        public ClassEntry getOuterClassEntry() {
+                return new ClassEntry(getOuterClassName());
+        }
+        
+        public boolean isInDefaultPackage() {
+                return m_name.indexOf('/') < 0;
+        }
+        
+        public String getPackageName() {
+                int pos = m_name.lastIndexOf('/');
+                if (pos > 0) {
+                        return m_name.substring(0, pos);
+                }
+                return null;
+        }
+        
+        public String getSimpleName() {
+                int pos = m_name.lastIndexOf('/');
+                if (pos > 0) {
+                        return m_name.substring(pos + 1);
+                }
+                return m_name;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java
new file mode 100644
index 0000000..e2c3d56
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -0,0 +1,405 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+public class ClassMapping implements Serializable, Comparable<ClassMapping> {
+        
+        private static final long serialVersionUID = -5148491146902340107L;
+        
+        private String m_obfName;
+        private String m_deobfName;
+        private Map<String,ClassMapping> m_innerClassesByObf;
+        private Map<String,ClassMapping> m_innerClassesByDeobf;
+        private Map<String,FieldMapping> m_fieldsByObf;
+        private Map<String,FieldMapping> m_fieldsByDeobf;
+        private Map<String,MethodMapping> m_methodsByObf;
+        private Map<String,MethodMapping> m_methodsByDeobf;
+        
+        public ClassMapping(String obfName) {
+                this(obfName, null);
+        }
+        
+        public ClassMapping(String obfName, String deobfName) {
+                m_obfName = obfName;
+                m_deobfName = NameValidator.validateClassName(deobfName, false);
+                m_innerClassesByObf = Maps.newHashMap();
+                m_innerClassesByDeobf = Maps.newHashMap();
+                m_fieldsByObf = Maps.newHashMap();
+                m_fieldsByDeobf = Maps.newHashMap();
+                m_methodsByObf = Maps.newHashMap();
+                m_methodsByDeobf = Maps.newHashMap();
+        }
+        
+        public String getObfName() {
+                return m_obfName;
+        }
+        
+        public String getDeobfName() {
+                return m_deobfName;
+        }
+        
+        public void setDeobfName(String val) {
+                m_deobfName = NameValidator.validateClassName(val, false);
+        }
+        
+        //// INNER CLASSES ////////
+        
+        public Iterable<ClassMapping> innerClasses() {
+                assert (m_innerClassesByObf.size() >= m_innerClassesByDeobf.size());
+                return m_innerClassesByObf.values();
+        }
+        
+        public void addInnerClassMapping(ClassMapping classMapping) {
+                assert (isSimpleClassName(classMapping.getObfName()));
+                boolean obfWasAdded = m_innerClassesByObf.put(classMapping.getObfName(), classMapping) == null;
+                assert (obfWasAdded);
+                if (classMapping.getDeobfName() != null) {
+                        assert (isSimpleClassName(classMapping.getDeobfName()));
+                        boolean deobfWasAdded = m_innerClassesByDeobf.put(classMapping.getDeobfName(), classMapping) == null;
+                        assert (deobfWasAdded);
+                }
+        }
+        
+        public void removeInnerClassMapping(ClassMapping classMapping) {
+                boolean obfWasRemoved = m_innerClassesByObf.remove(classMapping.getObfName()) != null;
+                assert (obfWasRemoved);
+                if (classMapping.getDeobfName() != null) {
+                        boolean deobfWasRemoved = m_innerClassesByDeobf.remove(classMapping.getDeobfName()) != null;
+                        assert (deobfWasRemoved);
+                }
+        }
+        
+        public ClassMapping getOrCreateInnerClass(String obfName) {
+                assert (isSimpleClassName(obfName));
+                ClassMapping classMapping = m_innerClassesByObf.get(obfName);
+                if (classMapping == null) {
+                        classMapping = new ClassMapping(obfName);
+                        boolean wasAdded = m_innerClassesByObf.put(obfName, classMapping) == null;
+                        assert (wasAdded);
+                }
+                return classMapping;
+        }
+        
+        public ClassMapping getInnerClassByObf(String obfName) {
+                assert (isSimpleClassName(obfName));
+                return m_innerClassesByObf.get(obfName);
+        }
+        
+        public ClassMapping getInnerClassByDeobf(String deobfName) {
+                assert (isSimpleClassName(deobfName));
+                return m_innerClassesByDeobf.get(deobfName);
+        }
+        
+        public ClassMapping getInnerClassByDeobfThenObf(String name) {
+                ClassMapping classMapping = getInnerClassByDeobf(name);
+                if (classMapping == null) {
+                        classMapping = getInnerClassByObf(name);
+                }
+                return classMapping;
+        }
+        
+        public String getObfInnerClassName(String deobfName) {
+                assert (isSimpleClassName(deobfName));
+                ClassMapping classMapping = m_innerClassesByDeobf.get(deobfName);
+                if (classMapping != null) {
+                        return classMapping.getObfName();
+                }
+                return null;
+        }
+        
+        public String getDeobfInnerClassName(String obfName) {
+                assert (isSimpleClassName(obfName));
+                ClassMapping classMapping = m_innerClassesByObf.get(obfName);
+                if (classMapping != null) {
+                        return classMapping.getDeobfName();
+                }
+                return null;
+        }
+        
+        public void setInnerClassName(String obfName, String deobfName) {
+                assert (isSimpleClassName(obfName));
+                ClassMapping classMapping = getOrCreateInnerClass(obfName);
+                if (classMapping.getDeobfName() != null) {
+                        boolean wasRemoved = m_innerClassesByDeobf.remove(classMapping.getDeobfName()) != null;
+                        assert (wasRemoved);
+                }
+                classMapping.setDeobfName(deobfName);
+                if (deobfName != null) {
+                        assert (isSimpleClassName(deobfName));
+                        boolean wasAdded = m_innerClassesByDeobf.put(deobfName, classMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        //// FIELDS ////////
+        
+        public Iterable<FieldMapping> fields() {
+                assert (m_fieldsByObf.size() == m_fieldsByDeobf.size());
+                return m_fieldsByObf.values();
+        }
+        
+        public boolean containsObfField(String obfName) {
+                return m_fieldsByObf.containsKey(obfName);
+        }
+        
+        public boolean containsDeobfField(String deobfName) {
+                return m_fieldsByDeobf.containsKey(deobfName);
+        }
+        
+        public void addFieldMapping(FieldMapping fieldMapping) {
+                if (m_fieldsByObf.containsKey(fieldMapping.getObfName())) {
+                        throw new Error("Already have mapping for " + m_obfName + "." + fieldMapping.getObfName());
+                }
+                if (m_fieldsByDeobf.containsKey(fieldMapping.getDeobfName())) {
+                        throw new Error("Already have mapping for " + m_deobfName + "." + fieldMapping.getDeobfName());
+                }
+                boolean obfWasAdded = m_fieldsByObf.put(fieldMapping.getObfName(), fieldMapping) == null;
+                assert (obfWasAdded);
+                boolean deobfWasAdded = m_fieldsByDeobf.put(fieldMapping.getDeobfName(), fieldMapping) == null;
+                assert (deobfWasAdded);
+                assert (m_fieldsByObf.size() == m_fieldsByDeobf.size());
+        }
+        
+        public void removeFieldMapping(FieldMapping fieldMapping) {
+                boolean obfWasRemoved = m_fieldsByObf.remove(fieldMapping.getObfName()) != null;
+                assert (obfWasRemoved);
+                if (fieldMapping.getDeobfName() != null) {
+                        boolean deobfWasRemoved = m_fieldsByDeobf.remove(fieldMapping.getDeobfName()) != null;
+                        assert (deobfWasRemoved);
+                }
+        }
+        
+        public FieldMapping getFieldByObf(String obfName) {
+                return m_fieldsByObf.get(obfName);
+        }
+        
+        public FieldMapping getFieldByDeobf(String deobfName) {
+                return m_fieldsByDeobf.get(deobfName);
+        }
+        
+        public String getObfFieldName(String deobfName) {
+                FieldMapping fieldMapping = m_fieldsByDeobf.get(deobfName);
+                if (fieldMapping != null) {
+                        return fieldMapping.getObfName();
+                }
+                return null;
+        }
+        
+        public String getDeobfFieldName(String obfName) {
+                FieldMapping fieldMapping = m_fieldsByObf.get(obfName);
+                if (fieldMapping != null) {
+                        return fieldMapping.getDeobfName();
+                }
+                return null;
+        }
+        
+        public void setFieldName(String obfName, String deobfName) {
+                FieldMapping fieldMapping = m_fieldsByObf.get(obfName);
+                if (fieldMapping == null) {
+                        fieldMapping = new FieldMapping(obfName, deobfName);
+                        boolean obfWasAdded = m_fieldsByObf.put(obfName, fieldMapping) == null;
+                        assert (obfWasAdded);
+                } else {
+                        boolean wasRemoved = m_fieldsByDeobf.remove(fieldMapping.getDeobfName()) != null;
+                        assert (wasRemoved);
+                }
+                fieldMapping.setDeobfName(deobfName);
+                if (deobfName != null) {
+                        boolean wasAdded = m_fieldsByDeobf.put(deobfName, fieldMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        //// METHODS ////////
+        
+        public Iterable<MethodMapping> methods() {
+                assert (m_methodsByObf.size() >= m_methodsByDeobf.size());
+                return m_methodsByObf.values();
+        }
+        
+        public boolean containsObfMethod(String obfName, Signature obfSignature) {
+                return m_methodsByObf.containsKey(getMethodKey(obfName, obfSignature));
+        }
+        
+        public boolean containsDeobfMethod(String deobfName, Signature deobfSignature) {
+                return m_methodsByDeobf.containsKey(getMethodKey(deobfName, deobfSignature));
+        }
+        
+        public void addMethodMapping(MethodMapping methodMapping) {
+                String obfKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature());
+                if (m_methodsByObf.containsKey(obfKey)) {
+                        throw new Error("Already have mapping for " + m_obfName + "." + obfKey);
+                }
+                boolean wasAdded = m_methodsByObf.put(obfKey, methodMapping) == null;
+                assert (wasAdded);
+                if (methodMapping.getDeobfName() != null) {
+                        String deobfKey = getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature());
+                        if (m_methodsByDeobf.containsKey(deobfKey)) {
+                                throw new Error("Already have mapping for " + m_deobfName + "." + deobfKey);
+                        }
+                        boolean deobfWasAdded = m_methodsByDeobf.put(deobfKey, methodMapping) == null;
+                        assert (deobfWasAdded);
+                }
+                assert (m_methodsByObf.size() >= m_methodsByDeobf.size());
+        }
+        
+        public void removeMethodMapping(MethodMapping methodMapping) {
+                boolean obfWasRemoved = m_methodsByObf.remove(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature())) != null;
+                assert (obfWasRemoved);
+                if (methodMapping.getDeobfName() != null) {
+                        boolean deobfWasRemoved = m_methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null;
+                        assert (deobfWasRemoved);
+                }
+        }
+        
+        public MethodMapping getMethodByObf(String obfName, Signature signature) {
+                return m_methodsByObf.get(getMethodKey(obfName, signature));
+        }
+        
+        public MethodMapping getMethodByDeobf(String deobfName, Signature signature) {
+                return m_methodsByDeobf.get(getMethodKey(deobfName, signature));
+        }
+        
+        private String getMethodKey(String name, Signature signature) {
+                if (name == null) {
+                        throw new IllegalArgumentException("name cannot be null!");
+                }
+                if (signature == null) {
+                        throw new IllegalArgumentException("signature cannot be null!");
+                }
+                return name + signature;
+        }
+        
+        public void setMethodName(String obfName, Signature obfSignature, String deobfName) {
+                MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfName, obfSignature));
+                if (methodMapping == null) {
+                        methodMapping = createMethodMapping(obfName, obfSignature);
+                } else if (methodMapping.getDeobfName() != null) {
+                        boolean wasRemoved = m_methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null;
+                        assert (wasRemoved);
+                }
+                methodMapping.setDeobfName(deobfName);
+                if (deobfName != null) {
+                        boolean wasAdded = m_methodsByDeobf.put(getMethodKey(deobfName, obfSignature), methodMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        //// ARGUMENTS ////////
+        
+        public void setArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex, String argumentName) {
+                MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature));
+                if (methodMapping == null) {
+                        methodMapping = createMethodMapping(obfMethodName, obfMethodSignature);
+                }
+                methodMapping.setArgumentName(argumentIndex, argumentName);
+        }
+        
+        public void removeArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex) {
+                m_methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)).removeArgumentName(argumentIndex);
+        }
+        
+        private MethodMapping createMethodMapping(String obfName, Signature obfSignature) {
+                MethodMapping methodMapping = new MethodMapping(obfName, obfSignature);
+                boolean wasAdded = m_methodsByObf.put(getMethodKey(obfName, obfSignature), methodMapping) == null;
+                assert (wasAdded);
+                return methodMapping;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append(m_obfName);
+                buf.append(" <-> ");
+                buf.append(m_deobfName);
+                buf.append("\n");
+                buf.append("Fields:\n");
+                for (FieldMapping fieldMapping : fields()) {
+                        buf.append("\t");
+                        buf.append(fieldMapping.getObfName());
+                        buf.append(" <-> ");
+                        buf.append(fieldMapping.getDeobfName());
+                        buf.append("\n");
+                }
+                buf.append("Methods:\n");
+                for (MethodMapping methodMapping : m_methodsByObf.values()) {
+                        buf.append(methodMapping.toString());
+                        buf.append("\n");
+                }
+                buf.append("Inner Classes:\n");
+                for (ClassMapping classMapping : m_innerClassesByObf.values()) {
+                        buf.append("\t");
+                        buf.append(classMapping.getObfName());
+                        buf.append(" <-> ");
+                        buf.append(classMapping.getDeobfName());
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+        
+        @Override
+        public int compareTo(ClassMapping other) {
+                // sort by a, b, c, ... aa, ab, etc
+                if (m_obfName.length() != other.m_obfName.length()) {
+                        return m_obfName.length() - other.m_obfName.length();
+                }
+                return m_obfName.compareTo(other.m_obfName);
+        }
+        
+        public boolean renameObfClass(String oldObfClassName, String newObfClassName) {
+                
+                // rename inner classes
+                for (ClassMapping innerClassMapping : new ArrayList<ClassMapping>(m_innerClassesByObf.values())) {
+                        if (innerClassMapping.renameObfClass(oldObfClassName, newObfClassName)) {
+                                boolean wasRemoved = m_innerClassesByObf.remove(oldObfClassName) != null;
+                                assert (wasRemoved);
+                                boolean wasAdded = m_innerClassesByObf.put(newObfClassName, innerClassMapping) == null;
+                                assert (wasAdded);
+                        }
+                }
+                
+                // rename method signatures
+                for (MethodMapping methodMapping : new ArrayList<MethodMapping>(m_methodsByObf.values())) {
+                        String oldMethodKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature());
+                        if (methodMapping.renameObfClass(oldObfClassName, newObfClassName)) {
+                                boolean wasRemoved = m_methodsByObf.remove(oldMethodKey) != null;
+                                assert (wasRemoved);
+                                boolean wasAdded = m_methodsByObf.put(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()), methodMapping) == null;
+                                assert (wasAdded);
+                        }
+                }
+                
+                if (m_obfName.equals(oldObfClassName)) {
+                        // rename this class
+                        m_obfName = newObfClassName;
+                        return true;
+                }
+                return false;
+        }
+        
+        public boolean containsArgument(BehaviorEntry obfBehaviorEntry, String name) {
+                MethodMapping methodMapping = m_methodsByObf.get(getMethodKey(obfBehaviorEntry.getName(), obfBehaviorEntry.getSignature()));
+                if (methodMapping != null) {
+                        return methodMapping.containsArgument(name);
+                }
+                return false;
+        }
+        
+        public static boolean isSimpleClassName(String name) {
+                return name.indexOf('/') < 0 && name.indexOf('$') < 0;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/ClassNameReplacer.java b/src/cuchaz/enigma/mapping/ClassNameReplacer.java
new file mode 100644
index 0000000..bf984fd
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ClassNameReplacer.java
@@ -0,0 +1,5 @@
+package cuchaz.enigma.mapping;
+
+public interface ClassNameReplacer {
+        String replace(String className);
+}
diff --git a/src/cuchaz/enigma/mapping/ConstructorEntry.java b/src/cuchaz/enigma/mapping/ConstructorEntry.java
new file mode 100644
index 0000000..5f3760f
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ConstructorEntry.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class ConstructorEntry implements BehaviorEntry, Serializable {
+        
+        private static final long serialVersionUID = -868346075317366758L;
+        
+        private ClassEntry m_classEntry;
+        private Signature m_signature;
+        
+        public ConstructorEntry(ClassEntry classEntry) {
+                this(classEntry, null);
+        }
+        
+        public ConstructorEntry(ClassEntry classEntry, Signature signature) {
+                if (classEntry == null) {
+                        throw new IllegalArgumentException("Class cannot be null!");
+                }
+                
+                m_classEntry = classEntry;
+                m_signature = signature;
+        }
+        
+        public ConstructorEntry(ConstructorEntry other) {
+                m_classEntry = new ClassEntry(other.m_classEntry);
+                m_signature = other.m_signature;
+        }
+        
+        public ConstructorEntry(ConstructorEntry other, String newClassName) {
+                m_classEntry = new ClassEntry(newClassName);
+                m_signature = other.m_signature;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String getName() {
+                if (isStatic()) {
+                        return "<clinit>";
+                }
+                return "<init>";
+        }
+        
+        public boolean isStatic() {
+                return m_signature == null;
+        }
+        
+        @Override
+        public Signature getSignature() {
+                return m_signature;
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_classEntry.getName();
+        }
+        
+        @Override
+        public ConstructorEntry cloneToNewClass(ClassEntry classEntry) {
+                return new ConstructorEntry(this, classEntry.getName());
+        }
+        
+        @Override
+        public int hashCode() {
+                if (isStatic()) {
+                        return Util.combineHashesOrdered(m_classEntry);
+                } else {
+                        return Util.combineHashesOrdered(m_classEntry, m_signature);
+                }
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ConstructorEntry) {
+                        return equals((ConstructorEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ConstructorEntry other) {
+                if (isStatic() != other.isStatic()) {
+                        return false;
+                }
+                
+                if (isStatic()) {
+                        return m_classEntry.equals(other.m_classEntry);
+                } else {
+                        return m_classEntry.equals(other.m_classEntry) && m_signature.equals(other.m_signature);
+                }
+        }
+        
+        @Override
+        public String toString() {
+                if (isStatic()) {
+                        return m_classEntry.getName() + "." + getName();
+                } else {
+                        return m_classEntry.getName() + "." + getName() + m_signature;
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Entry.java b/src/cuchaz/enigma/mapping/Entry.java
new file mode 100644
index 0000000..39e1507
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Entry.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public interface Entry {
+        String getName();
+        String getClassName();
+        ClassEntry getClassEntry();
+        Entry cloneToNewClass(ClassEntry classEntry);
+}
diff --git a/src/cuchaz/enigma/mapping/EntryPair.java b/src/cuchaz/enigma/mapping/EntryPair.java
new file mode 100644
index 0000000..60411c4
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/EntryPair.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public class EntryPair<T extends Entry> {
+        
+        public T obf;
+        public T deobf;
+        
+        public EntryPair(T obf, T deobf) {
+                this.obf = obf;
+                this.deobf = deobf;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/FieldEntry.java b/src/cuchaz/enigma/mapping/FieldEntry.java
new file mode 100644
index 0000000..6cc9eb7
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/FieldEntry.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class FieldEntry implements Entry, Serializable {
+        
+        private static final long serialVersionUID = 3004663582802885451L;
+        
+        private ClassEntry m_classEntry;
+        private String m_name;
+        
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public FieldEntry(ClassEntry classEntry, String name) {
+                if (classEntry == null) {
+                        throw new IllegalArgumentException("Class cannot be null!");
+                }
+                if (name == null) {
+                        throw new IllegalArgumentException("Field name cannot be null!");
+                }
+                
+                m_classEntry = classEntry;
+                m_name = name;
+        }
+        
+        public FieldEntry(FieldEntry other) {
+                m_classEntry = new ClassEntry(other.m_classEntry);
+                m_name = other.m_name;
+        }
+        
+        public FieldEntry(FieldEntry other, String newClassName) {
+                m_classEntry = new ClassEntry(newClassName);
+                m_name = other.m_name;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String getName() {
+                return m_name;
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_classEntry.getName();
+        }
+        
+        @Override
+        public FieldEntry cloneToNewClass(ClassEntry classEntry) {
+                return new FieldEntry(this, classEntry.getName());
+        }
+        
+        @Override
+        public int hashCode() {
+                return Util.combineHashesOrdered(m_classEntry, m_name);
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof FieldEntry) {
+                        return equals((FieldEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(FieldEntry other) {
+                return m_classEntry.equals(other.m_classEntry) && m_name.equals(other.m_name);
+        }
+        
+        @Override
+        public String toString() {
+                return m_classEntry.getName() + "." + m_name;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/FieldMapping.java b/src/cuchaz/enigma/mapping/FieldMapping.java
new file mode 100644
index 0000000..5f5c270
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/FieldMapping.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+public class FieldMapping implements Serializable, Comparable<FieldMapping> {
+        
+        private static final long serialVersionUID = 8610742471440861315L;
+        
+        private String m_obfName;
+        private String m_deobfName;
+        
+        public FieldMapping(String obfName, String deobfName) {
+                m_obfName = obfName;
+                m_deobfName = NameValidator.validateFieldName(deobfName);
+        }
+        
+        public String getObfName() {
+                return m_obfName;
+        }
+        
+        public String getDeobfName() {
+                return m_deobfName;
+        }
+        
+        public void setDeobfName(String val) {
+                m_deobfName = NameValidator.validateFieldName(val);
+        }
+        
+        @Override
+        public int compareTo(FieldMapping other) {
+                return m_obfName.compareTo(other.m_obfName);
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/IllegalNameException.java b/src/cuchaz/enigma/mapping/IllegalNameException.java
new file mode 100644
index 0000000..aacaf3b
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/IllegalNameException.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public class IllegalNameException extends RuntimeException {
+        
+        private static final long serialVersionUID = -2279910052561114323L;
+        
+        private String m_name;
+        private String m_reason;
+        
+        public IllegalNameException(String name) {
+                this(name, null);
+        }
+        
+        public IllegalNameException(String name, String reason) {
+                m_name = name;
+                m_reason = reason;
+        }
+        
+        public String getReason() {
+                return m_reason;
+        }
+        
+        @Override
+        public String getMessage() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("Illegal name: ");
+                buf.append(m_name);
+                if (m_reason != null) {
+                        buf.append(" because ");
+                        buf.append(m_reason);
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/JavassistUtil.java b/src/cuchaz/enigma/mapping/JavassistUtil.java
new file mode 100644
index 0000000..0c446c4
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/JavassistUtil.java
@@ -0,0 +1,83 @@
+package cuchaz.enigma.mapping;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.Descriptor;
+import javassist.expr.ConstructorCall;
+import javassist.expr.FieldAccess;
+import javassist.expr.MethodCall;
+import javassist.expr.NewExpr;
+
+public class JavassistUtil {
+        
+        public static ClassEntry getClassEntry(CtClass c) {
+                return new ClassEntry(Descriptor.toJvmName(c.getName()));
+        }
+        
+        public static ClassEntry getSuperclassEntry(CtClass c) {
+                return new ClassEntry(Descriptor.toJvmName(c.getClassFile().getSuperclass()));
+        }
+        
+        public static MethodEntry getMethodEntry(CtMethod method) {
+                return new MethodEntry(
+                        getClassEntry(method.getDeclaringClass()),
+                        method.getName(),
+                        new Signature(method.getMethodInfo().getDescriptor())
+                );
+        }
+        
+        public static MethodEntry getMethodEntry(MethodCall call) {
+                return new MethodEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        call.getMethodName(),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(CtConstructor constructor) {
+                return new ConstructorEntry(
+                        getClassEntry(constructor.getDeclaringClass()),
+                        new Signature(constructor.getMethodInfo().getDescriptor())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(ConstructorCall call) {
+                return new ConstructorEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(NewExpr call) {
+                return new ConstructorEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static BehaviorEntry getBehaviorEntry(CtBehavior behavior) {
+                if (behavior instanceof CtMethod) {
+                        return getMethodEntry((CtMethod)behavior);
+                } else if (behavior instanceof CtConstructor) {
+                        return getConstructorEntry((CtConstructor)behavior);
+                }
+                throw new Error("behavior is neither Method nor Constructor!");
+        }
+        
+        public static FieldEntry getFieldEntry(CtField field) {
+                return new FieldEntry(
+                        getClassEntry(field.getDeclaringClass()),
+                        field.getName()
+                );
+        }
+        
+        public static FieldEntry getFieldEntry(FieldAccess call) {
+                return new FieldEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        call.getFieldName()
+                );
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingParseException.java b/src/cuchaz/enigma/mapping/MappingParseException.java
new file mode 100644
index 0000000..1974c22
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingParseException.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public class MappingParseException extends Exception {
+        
+        private static final long serialVersionUID = -5487280332892507236L;
+        
+        private int m_line;
+        private String m_message;
+        
+        public MappingParseException(int line, String message) {
+                m_line = line;
+                m_message = message;
+        }
+        
+        @Override
+        public String getMessage() {
+                return "Line " + m_line + ": " + m_message;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java
new file mode 100644
index 0000000..57d8001
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Mappings.java
@@ -0,0 +1,188 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.analysis.TranslationIndex;
+
+public class Mappings implements Serializable {
+        
+        private static final long serialVersionUID = 4649790259460259026L;
+        
+        protected Map<String,ClassMapping> m_classesByObf;
+        protected Map<String,ClassMapping> m_classesByDeobf;
+        
+        public Mappings() {
+                m_classesByObf = Maps.newHashMap();
+                m_classesByDeobf = Maps.newHashMap();
+        }
+        
+        public Mappings(Iterable<ClassMapping> classes) {
+                this();
+                
+                for (ClassMapping classMapping : classes) {
+                        m_classesByObf.put(classMapping.getObfName(), classMapping);
+                        if (classMapping.getDeobfName() != null) {
+                                m_classesByDeobf.put(classMapping.getDeobfName(), classMapping);
+                        }
+                }
+        }
+        
+        public Collection<ClassMapping> classes() {
+                assert (m_classesByObf.size() >= m_classesByDeobf.size());
+                return m_classesByObf.values();
+        }
+        
+        public void addClassMapping(ClassMapping classMapping) {
+                if (m_classesByObf.containsKey(classMapping.getObfName())) {
+                        throw new Error("Already have mapping for " + classMapping.getObfName());
+                }
+                boolean obfWasAdded = m_classesByObf.put(classMapping.getObfName(), classMapping) == null;
+                assert (obfWasAdded);
+                if (classMapping.getDeobfName() != null) {
+                        if (m_classesByDeobf.containsKey(classMapping.getDeobfName())) {
+                                throw new Error("Already have mapping for " + classMapping.getDeobfName());
+                        }
+                        boolean deobfWasAdded = m_classesByDeobf.put(classMapping.getDeobfName(), classMapping) == null;
+                        assert (deobfWasAdded);
+                }
+        }
+        
+        public void removeClassMapping(ClassMapping classMapping) {
+                boolean obfWasRemoved = m_classesByObf.remove(classMapping.getObfName()) != null;
+                assert (obfWasRemoved);
+                if (classMapping.getDeobfName() != null) {
+                        boolean deobfWasRemoved = m_classesByDeobf.remove(classMapping.getDeobfName()) != null;
+                        assert (deobfWasRemoved);
+                }
+        }
+        
+        public ClassMapping getClassByObf(ClassEntry entry) {
+                return getClassByObf(entry.getName());
+        }
+        
+        public ClassMapping getClassByObf(String obfName) {
+                return m_classesByObf.get(obfName);
+        }
+        
+        public ClassMapping getClassByDeobf(ClassEntry entry) {
+                return getClassByDeobf(entry.getName());
+        }
+        
+        public ClassMapping getClassByDeobf(String deobfName) {
+                return m_classesByDeobf.get(deobfName);
+        }
+        
+        public Translator getTranslator(TranslationDirection direction, TranslationIndex index) {
+                switch (direction) {
+                        case Deobfuscating:
+                                
+                                return new Translator(direction, m_classesByObf, index);
+                                
+                        case Obfuscating:
+                                
+                                // fill in the missing deobf class entries with obf entries
+                                Map<String,ClassMapping> classes = Maps.newHashMap();
+                                for (ClassMapping classMapping : classes()) {
+                                        if (classMapping.getDeobfName() != null) {
+                                                classes.put(classMapping.getDeobfName(), classMapping);
+                                        } else {
+                                                classes.put(classMapping.getObfName(), classMapping);
+                                        }
+                                }
+                                
+                                // translate the translation index
+                                // NOTE: this isn't actually recursive
+                                TranslationIndex deobfIndex = new TranslationIndex(index, getTranslator(TranslationDirection.Deobfuscating, index));
+                                
+                                return new Translator(direction, classes, deobfIndex);
+                                
+                        default:
+                                throw new Error("Invalid translation direction!");
+                }
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                for (ClassMapping classMapping : m_classesByObf.values()) {
+                        buf.append(classMapping.toString());
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+        
+        public void renameObfClass(String oldObfName, String newObfName) {
+                for (ClassMapping classMapping : new ArrayList<ClassMapping>(classes())) {
+                        if (classMapping.renameObfClass(oldObfName, newObfName)) {
+                                boolean wasRemoved = m_classesByObf.remove(oldObfName) != null;
+                                assert (wasRemoved);
+                                boolean wasAdded = m_classesByObf.put(newObfName, classMapping) == null;
+                                assert (wasAdded);
+                        }
+                }
+        }
+        
+        public Set<String> getAllObfClassNames() {
+                final Set<String> classNames = Sets.newHashSet();
+                for (ClassMapping classMapping : classes()) {
+                        
+                        // add the class name
+                        classNames.add(classMapping.getObfName());
+                        
+                        // add classes from method signatures
+                        for (MethodMapping methodMapping : classMapping.methods()) {
+                                for (Type type : methodMapping.getObfSignature().types()) {
+                                        if (type.hasClass()) {
+                                                classNames.add(type.getClassEntry().getClassName());
+                                        }
+                                }
+                        }
+                }
+                return classNames;
+        }
+        
+        public boolean containsDeobfClass(String deobfName) {
+                return m_classesByDeobf.containsKey(deobfName);
+        }
+        
+        public boolean containsDeobfField(ClassEntry obfClassEntry, String deobfName) {
+                ClassMapping classMapping = m_classesByObf.get(obfClassEntry.getName());
+                if (classMapping != null) {
+                        return classMapping.containsDeobfField(deobfName);
+                }
+                return false;
+        }
+        
+        public boolean containsDeobfMethod(ClassEntry obfClassEntry, String deobfName, Signature deobfSignature) {
+                ClassMapping classMapping = m_classesByObf.get(obfClassEntry.getName());
+                if (classMapping != null) {
+                        return classMapping.containsDeobfMethod(deobfName, deobfSignature);
+                }
+                return false;
+        }
+        
+        public boolean containsArgument(BehaviorEntry obfBehaviorEntry, String name) {
+                ClassMapping classMapping = m_classesByObf.get(obfBehaviorEntry.getClassName());
+                if (classMapping != null) {
+                        return classMapping.containsArgument(obfBehaviorEntry, name);
+                }
+                return false;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java
new file mode 100644
index 0000000..adf460e
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsReader.java
@@ -0,0 +1,175 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.Deque;
+
+import com.google.common.collect.Queues;
+
+import cuchaz.enigma.Constants;
+
+public class MappingsReader {
+        
+        public Mappings read(Reader in) throws IOException, MappingParseException {
+                return read(new BufferedReader(in));
+        }
+        
+        public Mappings read(BufferedReader in) throws IOException, MappingParseException {
+                Mappings mappings = new Mappings();
+                Deque<Object> mappingStack = Queues.newArrayDeque();
+                
+                int lineNumber = 0;
+                String line = null;
+                while ( (line = in.readLine()) != null) {
+                        lineNumber++;
+                        
+                        // strip comments
+                        int commentPos = line.indexOf('#');
+                        if (commentPos >= 0) {
+                                line = line.substring(0, commentPos);
+                        }
+                        
+                        // skip blank lines
+                        if (line.trim().length() <= 0) {
+                                continue;
+                        }
+                        
+                        // get the indent of this line
+                        int indent = 0;
+                        for (int i = 0; i < line.length(); i++) {
+                                if (line.charAt(i) != '\t') {
+                                        break;
+                                }
+                                indent++;
+                        }
+                        
+                        // handle stack pops
+                        while (indent < mappingStack.size()) {
+                                mappingStack.pop();
+                        }
+                        
+                        String[] parts = line.trim().split("\\s");
+                        try {
+                                // read the first token
+                                String token = parts[0];
+                                
+                                if (token.equalsIgnoreCase("CLASS")) {
+                                        ClassMapping classMapping;
+                                        if (indent == 0) {
+                                                // outer class
+                                                classMapping = readClass(parts, false);
+                                                mappings.addClassMapping(classMapping);
+                                        } else if (indent == 1) {
+                                                // inner class
+                                                if (! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                        throw new MappingParseException(lineNumber, "Unexpected CLASS entry here!");
+                                                }
+                                                
+                                                classMapping = readClass(parts, true);
+                                                ((ClassMapping)mappingStack.getFirst()).addInnerClassMapping(classMapping);
+                                        } else {
+                                                throw new MappingParseException(lineNumber, "Unexpected CLASS entry nesting!");
+                                        }
+                                        mappingStack.push(classMapping);
+                                } else if (token.equalsIgnoreCase("FIELD")) {
+                                        if (mappingStack.isEmpty() || ! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                throw new MappingParseException(lineNumber, "Unexpected FIELD entry here!");
+                                        }
+                                        ((ClassMapping)mappingStack.getFirst()).addFieldMapping(readField(parts));
+                                } else if (token.equalsIgnoreCase("METHOD")) {
+                                        if (mappingStack.isEmpty() || ! (mappingStack.getFirst() instanceof ClassMapping)) {
+                                                throw new MappingParseException(lineNumber, "Unexpected METHOD entry here!");
+                                        }
+                                        MethodMapping methodMapping = readMethod(parts);
+                                        ((ClassMapping)mappingStack.getFirst()).addMethodMapping(methodMapping);
+                                        mappingStack.push(methodMapping);
+                                } else if (token.equalsIgnoreCase("ARG")) {
+                                        if (mappingStack.isEmpty() || ! (mappingStack.getFirst() instanceof MethodMapping)) {
+                                                throw new MappingParseException(lineNumber, "Unexpected ARG entry here!");
+                                        }
+                                        ((MethodMapping)mappingStack.getFirst()).addArgumentMapping(readArgument(parts));
+                                }
+                        } catch (ArrayIndexOutOfBoundsException | NumberFormatException ex) {
+                                throw new MappingParseException(lineNumber, "Malformed line!");
+                        }
+                }
+                
+                return mappings;
+        }
+        
+        private ArgumentMapping readArgument(String[] parts) {
+                return new ArgumentMapping(Integer.parseInt(parts[1]), parts[2]);
+        }
+        
+        private ClassMapping readClass(String[] parts, boolean makeSimple) {
+                if (parts.length == 2) {
+                        String obfName = processName(parts[1], makeSimple);
+                        return new ClassMapping(obfName);
+                } else {
+                        String obfName = processName(parts[1], makeSimple);
+                        String deobfName = processName(parts[2], makeSimple);
+                        return new ClassMapping(obfName, deobfName);
+                }
+        }
+        
+        private String processName(String name, boolean makeSimple) {
+                if (makeSimple) {
+                        return new ClassEntry(name).getSimpleName();
+                } else {
+                        return moveClassOutOfDefaultPackage(name, Constants.NonePackage);
+                }
+        }
+        
+        private String moveClassOutOfDefaultPackage(String className, String newPackageName) {
+                ClassEntry classEntry = new ClassEntry(className);
+                if (classEntry.isInDefaultPackage()) {
+                        return newPackageName + "/" + classEntry.getName();
+                }
+                return className;
+        }
+        
+        private FieldMapping readField(String[] parts) {
+                return new FieldMapping(parts[1], parts[2]);
+        }
+        
+        private MethodMapping readMethod(String[] parts) {
+                if (parts.length == 3) {
+                        String obfName = parts[1];
+                        Signature obfSignature = moveSignatureOutOfDefaultPackage(new Signature(parts[2]), Constants.NonePackage);
+                        return new MethodMapping(obfName, obfSignature);
+                } else {
+                        String obfName = parts[1];
+                        String deobfName = parts[2];
+                        Signature obfSignature = moveSignatureOutOfDefaultPackage(new Signature(parts[3]), Constants.NonePackage);
+                        if (obfName.equals(deobfName)) {
+                                return new MethodMapping(obfName, obfSignature);
+                        } else {
+                                return new MethodMapping(obfName, obfSignature, deobfName);
+                        }
+                }
+        }
+        
+        private Signature moveSignatureOutOfDefaultPackage(Signature signature, final String newPackageName) {
+                return new Signature(signature, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                ClassEntry classEntry = new ClassEntry(className);
+                                if (classEntry.isInDefaultPackage()) {
+                                        return newPackageName + "/" + className;
+                                }
+                                return null;
+                        }
+                });
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingsRenamer.java b/src/cuchaz/enigma/mapping/MappingsRenamer.java
new file mode 100644
index 0000000..0a41c2b
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsRenamer.java
@@ -0,0 +1,237 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.util.Set;
+import java.util.zip.GZIPOutputStream;
+
+import cuchaz.enigma.Constants;
+import cuchaz.enigma.analysis.JarIndex;
+
+public class MappingsRenamer {
+        
+        private JarIndex m_index;
+        private Mappings m_mappings;
+        
+        public MappingsRenamer(JarIndex index, Mappings mappings) {
+                m_index = index;
+                m_mappings = mappings;
+        }
+        
+        public void setClassName(ClassEntry obf, String deobfName) {
+                deobfName = NameValidator.validateClassName(deobfName, !obf.isInnerClass());
+                ClassEntry targetEntry = new ClassEntry(deobfName);
+                if (m_mappings.containsDeobfClass(deobfName) || m_index.containsObfClass(targetEntry)) {
+                        throw new IllegalNameException(deobfName, "There is already a class with that name");
+                }
+                
+                ClassMapping classMapping = getOrCreateClassMapping(obf);
+                
+                if (obf.isInnerClass()) {
+                        classMapping.setInnerClassName(obf.getInnerClassName(), deobfName);
+                } else {
+                        if (classMapping.getDeobfName() != null) {
+                                boolean wasRemoved = m_mappings.m_classesByDeobf.remove(classMapping.getDeobfName()) != null;
+                                assert (wasRemoved);
+                        }
+                        classMapping.setDeobfName(deobfName);
+                        boolean wasAdded = m_mappings.m_classesByDeobf.put(deobfName, classMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        public void removeClassMapping(ClassEntry obf) {
+                ClassMapping classMapping = getClassMapping(obf);
+                if (obf.isInnerClass()) {
+                        classMapping.setInnerClassName(obf.getName(), null);
+                } else {
+                        boolean wasRemoved = m_mappings.m_classesByDeobf.remove(classMapping.getDeobfName()) != null;
+                        assert (wasRemoved);
+                        classMapping.setDeobfName(null);
+                }
+        }
+        
+        public void markClassAsDeobfuscated(ClassEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMapping(obf);
+                if (obf.isInnerClass()) {
+                        String innerClassName = Constants.NonePackage + "/" + obf.getInnerClassName();
+                        classMapping.setInnerClassName(innerClassName, innerClassName);
+                } else {
+                        classMapping.setDeobfName(obf.getName());
+                        boolean wasAdded = m_mappings.m_classesByDeobf.put(obf.getName(), classMapping) == null;
+                        assert (wasAdded);
+                }
+        }
+        
+        public void setFieldName(FieldEntry obf, String deobfName) {
+                deobfName = NameValidator.validateFieldName(deobfName);
+                FieldEntry targetEntry = new FieldEntry(obf.getClassEntry(), deobfName);
+                if (m_mappings.containsDeobfField(obf.getClassEntry(), deobfName) || m_index.containsObfField(targetEntry)) {
+                        throw new IllegalNameException(deobfName, "There is already a field with that name");
+                }
+                
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setFieldName(obf.getName(), deobfName);
+        }
+        
+        public void removeFieldMapping(FieldEntry obf) {
+                ClassMapping classMapping = getClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setFieldName(obf.getName(), null);
+        }
+        
+        public void markFieldAsDeobfuscated(FieldEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setFieldName(obf.getName(), obf.getName());
+        }
+        
+        public void setMethodTreeName(MethodEntry obf, String deobfName) {
+                Set<MethodEntry> implementations = m_index.getRelatedMethodImplementations(obf);
+                
+                deobfName = NameValidator.validateMethodName(deobfName);
+                for (MethodEntry entry : implementations) {
+                        Signature deobfSignature = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateSignature(obf.getSignature());
+                        MethodEntry targetEntry = new MethodEntry(entry.getClassEntry(), deobfName, deobfSignature);
+                        if (m_mappings.containsDeobfMethod(entry.getClassEntry(), deobfName, entry.getSignature()) || m_index.containsObfBehavior(targetEntry)) {
+                                String deobfClassName = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateClass(entry.getClassName());
+                                throw new IllegalNameException(deobfName, "There is already a method with that name and signature in class " + deobfClassName);
+                        }
+                }
+                
+                for (MethodEntry entry : implementations) {
+                        setMethodName(entry, deobfName);
+                }
+        }
+        
+        public void setMethodName(MethodEntry obf, String deobfName) {
+                deobfName = NameValidator.validateMethodName(deobfName);
+                MethodEntry targetEntry = new MethodEntry(obf.getClassEntry(), deobfName, obf.getSignature());
+                if (m_mappings.containsDeobfMethod(obf.getClassEntry(), deobfName, obf.getSignature()) || m_index.containsObfBehavior(targetEntry)) {
+                        String deobfClassName = m_mappings.getTranslator(TranslationDirection.Deobfuscating, m_index.getTranslationIndex()).translateClass(obf.getClassName());
+                        throw new IllegalNameException(deobfName, "There is already a method with that name and signature in class " + deobfClassName);
+                }
+                
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setMethodName(obf.getName(), obf.getSignature(), deobfName);
+        }
+        
+        public void removeMethodTreeMapping(MethodEntry obf) {
+                for (MethodEntry implementation : m_index.getRelatedMethodImplementations(obf)) {
+                        removeMethodMapping(implementation);
+                }
+        }
+        
+        public void removeMethodMapping(MethodEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setMethodName(obf.getName(), obf.getSignature(), null);
+        }
+        
+        public void markMethodTreeAsDeobfuscated(MethodEntry obf) {
+                for (MethodEntry implementation : m_index.getRelatedMethodImplementations(obf)) {
+                        markMethodAsDeobfuscated(implementation);
+                }
+        }
+        
+        public void markMethodAsDeobfuscated(MethodEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setMethodName(obf.getName(), obf.getSignature(), obf.getName());
+        }
+        
+        public void setArgumentName(ArgumentEntry obf, String deobfName) {
+                deobfName = NameValidator.validateArgumentName(deobfName);
+                // NOTE: don't need to check arguments for name collisions with names determined by Procyon
+                if (m_mappings.containsArgument(obf.getBehaviorEntry(), deobfName)) {
+                        throw new IllegalNameException(deobfName, "There is already an argument with that name");
+                }
+                
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setArgumentName(obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), deobfName);
+        }
+        
+        public void removeArgumentMapping(ArgumentEntry obf) {
+                ClassMapping classMapping = getClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.removeArgumentName(obf.getMethodName(), obf.getMethodSignature(), obf.getIndex());
+        }
+        
+        public void markArgumentAsDeobfuscated(ArgumentEntry obf) {
+                ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
+                classMapping.setArgumentName(obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), obf.getName());
+        }
+        
+        public boolean moveFieldToObfClass(ClassMapping classMapping, FieldMapping fieldMapping, ClassEntry obfClass) {
+                classMapping.removeFieldMapping(fieldMapping);
+                ClassMapping targetClassMapping = getOrCreateClassMapping(obfClass);
+                if (!targetClassMapping.containsObfField(fieldMapping.getObfName())) {
+                        if (!targetClassMapping.containsDeobfField(fieldMapping.getDeobfName())) {
+                                targetClassMapping.addFieldMapping(fieldMapping);
+                                return true;
+                        } else {
+                                System.err.println("WARNING: deobf field was already there: " + obfClass + "." + fieldMapping.getDeobfName());
+                        }
+                }
+                return false;
+        }
+        
+        public boolean moveMethodToObfClass(ClassMapping classMapping, MethodMapping methodMapping, ClassEntry obfClass) {
+                classMapping.removeMethodMapping(methodMapping);
+                ClassMapping targetClassMapping = getOrCreateClassMapping(obfClass);
+                if (!targetClassMapping.containsObfMethod(methodMapping.getObfName(), methodMapping.getObfSignature())) {
+                        if (!targetClassMapping.containsDeobfMethod(methodMapping.getDeobfName(), methodMapping.getObfSignature())) {
+                                targetClassMapping.addMethodMapping(methodMapping);
+                                return true;
+                        } else {
+                                System.err.println("WARNING: deobf method was already there: " + obfClass + "." + methodMapping.getDeobfName() + methodMapping.getObfSignature());
+                        }
+                }
+                return false;
+        }
+        
+        public void write(OutputStream out) throws IOException {
+                // TEMP: just use the object output for now. We can find a more efficient storage format later
+                GZIPOutputStream gzipout = new GZIPOutputStream(out);
+                ObjectOutputStream oout = new ObjectOutputStream(gzipout);
+                oout.writeObject(this);
+                gzipout.finish();
+        }
+        
+        private ClassMapping getClassMapping(ClassEntry obfClassEntry) {
+                return m_mappings.m_classesByObf.get(obfClassEntry.getOuterClassName());
+        }
+        
+        private ClassMapping getOrCreateClassMapping(ClassEntry obfClassEntry) {
+                String obfClassName = obfClassEntry.getOuterClassName();
+                ClassMapping classMapping = m_mappings.m_classesByObf.get(obfClassName);
+                if (classMapping == null) {
+                        classMapping = new ClassMapping(obfClassName);
+                        boolean obfWasAdded = m_mappings.m_classesByObf.put(classMapping.getObfName(), classMapping) == null;
+                        assert (obfWasAdded);
+                }
+                return classMapping;
+        }
+        
+        private ClassMapping getClassMappingOrInnerClassMapping(ClassEntry obfClassEntry) {
+                ClassMapping classMapping = getClassMapping(obfClassEntry);
+                if (obfClassEntry.isInDefaultPackage()) {
+                        classMapping = classMapping.getInnerClassByObf(obfClassEntry.getInnerClassName());
+                }
+                return classMapping;
+        }
+        
+        private ClassMapping getOrCreateClassMappingOrInnerClassMapping(ClassEntry obfClassEntry) {
+                ClassMapping classMapping = getOrCreateClassMapping(obfClassEntry);
+                if (obfClassEntry.isInnerClass()) {
+                        classMapping = classMapping.getOrCreateInnerClass(obfClassEntry.getInnerClassName());
+                }
+                return classMapping;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MappingsWriter.java b/src/cuchaz/enigma/mapping/MappingsWriter.java
new file mode 100644
index 0000000..5ac409f
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsWriter.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class MappingsWriter {
+        
+        public void write(Writer out, Mappings mappings) throws IOException {
+                write(new PrintWriter(out), mappings);
+        }
+        
+        public void write(PrintWriter out, Mappings mappings) throws IOException {
+                for (ClassMapping classMapping : sorted(mappings.classes())) {
+                        write(out, classMapping, 0);
+                }
+        }
+        
+        private void write(PrintWriter out, ClassMapping classMapping, int depth) throws IOException {
+                if (classMapping.getDeobfName() == null) {
+                        out.format("%sCLASS %s\n", getIndent(depth), classMapping.getObfName());
+                } else {
+                        out.format("%sCLASS %s %s\n", getIndent(depth), classMapping.getObfName(), classMapping.getDeobfName());
+                }
+                
+                for (ClassMapping innerClassMapping : sorted(classMapping.innerClasses())) {
+                        write(out, innerClassMapping, depth + 1);
+                }
+                
+                for (FieldMapping fieldMapping : sorted(classMapping.fields())) {
+                        write(out, fieldMapping, depth + 1);
+                }
+                
+                for (MethodMapping methodMapping : sorted(classMapping.methods())) {
+                        write(out, methodMapping, depth + 1);
+                }
+        }
+        
+        private void write(PrintWriter out, FieldMapping fieldMapping, int depth) throws IOException {
+                out.format("%sFIELD %s %s\n", getIndent(depth), fieldMapping.getObfName(), fieldMapping.getDeobfName());
+        }
+        
+        private void write(PrintWriter out, MethodMapping methodMapping, int depth) throws IOException {
+                if (methodMapping.getDeobfName() == null) {
+                        out.format("%sMETHOD %s %s\n", getIndent(depth), methodMapping.getObfName(), methodMapping.getObfSignature());
+                } else {
+                        out.format("%sMETHOD %s %s %s\n", getIndent(depth), methodMapping.getObfName(), methodMapping.getDeobfName(), methodMapping.getObfSignature());
+                }
+                
+                for (ArgumentMapping argumentMapping : sorted(methodMapping.arguments())) {
+                        write(out, argumentMapping, depth + 1);
+                }
+        }
+        
+        private void write(PrintWriter out, ArgumentMapping argumentMapping, int depth) throws IOException {
+                out.format("%sARG %d %s\n", getIndent(depth), argumentMapping.getIndex(), argumentMapping.getName());
+        }
+        
+        private <T extends Comparable<T>> List<T> sorted(Iterable<T> classes) {
+                List<T> out = new ArrayList<T>();
+                for (T t : classes) {
+                        out.add(t);
+                }
+                Collections.sort(out);
+                return out;
+        }
+        
+        private String getIndent(int depth) {
+                StringBuilder buf = new StringBuilder();
+                for (int i = 0; i < depth; i++) {
+                        buf.append("\t");
+                }
+                return buf.toString();
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MethodEntry.java b/src/cuchaz/enigma/mapping/MethodEntry.java
new file mode 100644
index 0000000..057e02b
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MethodEntry.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class MethodEntry implements BehaviorEntry, Serializable {
+        
+        private static final long serialVersionUID = 4770915224467247458L;
+        
+        private ClassEntry m_classEntry;
+        private String m_name;
+        private Signature m_signature;
+        
+        public MethodEntry(ClassEntry classEntry, String name, Signature signature) {
+                if (classEntry == null) {
+                        throw new IllegalArgumentException("Class cannot be null!");
+                }
+                if (name == null) {
+                        throw new IllegalArgumentException("Method name cannot be null!");
+                }
+                if (signature == null) {
+                        throw new IllegalArgumentException("Method signature cannot be null!");
+                }
+                if (name.startsWith("<")) {
+                        throw new IllegalArgumentException("Don't use MethodEntry for a constructor!");
+                }
+                
+                m_classEntry = classEntry;
+                m_name = name;
+                m_signature = signature;
+        }
+        
+        public MethodEntry(MethodEntry other) {
+                m_classEntry = new ClassEntry(other.m_classEntry);
+                m_name = other.m_name;
+                m_signature = other.m_signature;
+        }
+        
+        public MethodEntry(MethodEntry other, String newClassName) {
+                m_classEntry = new ClassEntry(newClassName);
+                m_name = other.m_name;
+                m_signature = other.m_signature;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry() {
+                return m_classEntry;
+        }
+        
+        @Override
+        public String getName() {
+                return m_name;
+        }
+        
+        @Override
+        public Signature getSignature() {
+                return m_signature;
+        }
+        
+        @Override
+        public String getClassName() {
+                return m_classEntry.getName();
+        }
+        
+        @Override
+        public MethodEntry cloneToNewClass(ClassEntry classEntry) {
+                return new MethodEntry(this, classEntry.getName());
+        }
+        
+        @Override
+        public int hashCode() {
+                return Util.combineHashesOrdered(m_classEntry, m_name, m_signature);
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof MethodEntry) {
+                        return equals((MethodEntry)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(MethodEntry other) {
+                return m_classEntry.equals(other.m_classEntry)
+                        && m_name.equals(other.m_name)
+                        && m_signature.equals(other.m_signature);
+        }
+        
+        @Override
+        public String toString() {
+                return m_classEntry.getName() + "." + m_name + m_signature;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java
new file mode 100644
index 0000000..1704428
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MethodMapping.java
@@ -0,0 +1,161 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class MethodMapping implements Serializable, Comparable<MethodMapping> {
+        
+        private static final long serialVersionUID = -4409570216084263978L;
+        
+        private String m_obfName;
+        private String m_deobfName;
+        private Signature m_obfSignature;
+        private Map<Integer,ArgumentMapping> m_arguments;
+        
+        public MethodMapping(String obfName, Signature obfSignature) {
+                this(obfName, obfSignature, null);
+        }
+        
+        public MethodMapping(String obfName, Signature obfSignature, String deobfName) {
+                if (obfName == null) {
+                        throw new IllegalArgumentException("obf name cannot be null!");
+                }
+                if (obfSignature == null) {
+                        throw new IllegalArgumentException("obf signature cannot be null!");
+                }
+                m_obfName = obfName;
+                m_deobfName = NameValidator.validateMethodName(deobfName);
+                m_obfSignature = obfSignature;
+                m_arguments = new TreeMap<Integer,ArgumentMapping>();
+        }
+        
+        public String getObfName() {
+                return m_obfName;
+        }
+        
+        public String getDeobfName() {
+                return m_deobfName;
+        }
+        
+        public void setDeobfName(String val) {
+                m_deobfName = NameValidator.validateMethodName(val);
+        }
+        
+        public Signature getObfSignature() {
+                return m_obfSignature;
+        }
+        
+        public Iterable<ArgumentMapping> arguments() {
+                return m_arguments.values();
+        }
+        
+        public boolean isConstructor() {
+                return m_obfName.startsWith("<");
+        }
+        
+        public void addArgumentMapping(ArgumentMapping argumentMapping) {
+                boolean wasAdded = m_arguments.put(argumentMapping.getIndex(), argumentMapping) == null;
+                assert (wasAdded);
+        }
+        
+        public String getObfArgumentName(int index) {
+                ArgumentMapping argumentMapping = m_arguments.get(index);
+                if (argumentMapping != null) {
+                        return argumentMapping.getName();
+                }
+                
+                return null;
+        }
+        
+        public String getDeobfArgumentName(int index) {
+                ArgumentMapping argumentMapping = m_arguments.get(index);
+                if (argumentMapping != null) {
+                        return argumentMapping.getName();
+                }
+                
+                return null;
+        }
+        
+        public void setArgumentName(int index, String name) {
+                ArgumentMapping argumentMapping = m_arguments.get(index);
+                if (argumentMapping == null) {
+                        argumentMapping = new ArgumentMapping(index, name);
+                        boolean wasAdded = m_arguments.put(index, argumentMapping) == null;
+                        assert (wasAdded);
+                } else {
+                        argumentMapping.setName(name);
+                }
+        }
+        
+        public void removeArgumentName(int index) {
+                boolean wasRemoved = m_arguments.remove(index) != null;
+                assert (wasRemoved);
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("\t");
+                buf.append(m_obfName);
+                buf.append(" <-> ");
+                buf.append(m_deobfName);
+                buf.append("\n");
+                buf.append("\t");
+                buf.append(m_obfSignature);
+                buf.append("\n");
+                buf.append("\tArguments:\n");
+                for (ArgumentMapping argumentMapping : m_arguments.values()) {
+                        buf.append("\t\t");
+                        buf.append(argumentMapping.getIndex());
+                        buf.append(" -> ");
+                        buf.append(argumentMapping.getName());
+                        buf.append("\n");
+                }
+                return buf.toString();
+        }
+        
+        @Override
+        public int compareTo(MethodMapping other) {
+                return (m_obfName + m_obfSignature).compareTo(other.m_obfName + other.m_obfSignature);
+        }
+        
+        public boolean renameObfClass(final String oldObfClassName, final String newObfClassName) {
+                
+                // rename obf classes in the signature
+                Signature newSignature = new Signature(m_obfSignature, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                if (className.equals(oldObfClassName)) {
+                                        return newObfClassName;
+                                }
+                                return null;
+                        }
+                });
+                
+                if (!newSignature.equals(m_obfSignature)) {
+                        m_obfSignature = newSignature;
+                        return true;
+                }
+                return false;
+        }
+        
+        public boolean containsArgument(String name) {
+                for (ArgumentMapping argumentMapping : m_arguments.values()) {
+                        if (argumentMapping.getName().equals(name)) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/NameValidator.java b/src/cuchaz/enigma/mapping/NameValidator.java
new file mode 100644
index 0000000..35a17f9
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/NameValidator.java
@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import javassist.bytecode.Descriptor;
+
+public class NameValidator {
+        
+        private static final Pattern IdentifierPattern;
+        private static final Pattern ClassPattern;
+        private static final List<String> ReservedWords = Arrays.asList(
+                "abstract", "continue", "for", "new", "switch", "assert", "default", "goto", "package", "synchronized",
+                "boolean", "do", "if", "private", "this", "break", "double", "implements", "protected", "throw", "byte",
+                "else", "import", "public", "throws", "case", "enum", "instanceof", "return", "transient", "catch",
+                "extends", "int", "short", "try", "char", "final", "interface", "static", "void", "class", "finally",
+                "long", "strictfp", "volatile", "const", "float", "native", "super", "while"
+        );
+        
+        static {
+                
+                // java allows all kinds of weird characters...
+                StringBuilder startChars = new StringBuilder();
+                StringBuilder partChars = new StringBuilder();
+                for (int i = Character.MIN_CODE_POINT; i <= Character.MAX_CODE_POINT; i++) {
+                        if (Character.isJavaIdentifierStart(i)) {
+                                startChars.appendCodePoint(i);
+                        }
+                        if (Character.isJavaIdentifierPart(i)) {
+                                partChars.appendCodePoint(i);
+                        }
+                }
+                
+                String identifierRegex = "[A-Za-z_<][A-Za-z0-9_>]*";
+                IdentifierPattern = Pattern.compile(identifierRegex);
+                ClassPattern = Pattern.compile(String.format("^(%s(\\.|/))*(%s)$", identifierRegex, identifierRegex));
+        }
+        
+        public static String validateClassName(String name, boolean packageRequired) {
+                if (name == null) {
+                        return null;
+                }
+                if (!ClassPattern.matcher(name).matches() || ReservedWords.contains(name)) {
+                        throw new IllegalNameException(name, "This doesn't look like a legal class name");
+                }
+                if (packageRequired && new ClassEntry(name).getPackageName() == null) {
+                        throw new IllegalNameException(name, "Class must be in a package");
+                }
+                return Descriptor.toJvmName(name);
+        }
+        
+        public static String validateFieldName(String name) {
+                if (name == null) {
+                        return null;
+                }
+                if (!IdentifierPattern.matcher(name).matches() || ReservedWords.contains(name)) {
+                        throw new IllegalNameException(name, "This doesn't look like a legal identifier");
+                }
+                return name;
+        }
+        
+        public static String validateMethodName(String name) {
+                return validateFieldName(name);
+        }
+        
+        public static String validateArgumentName(String name) {
+                return validateFieldName(name);
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Signature.java b/src/cuchaz/enigma/mapping/Signature.java
new file mode 100644
index 0000000..ff7f807
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Signature.java
@@ -0,0 +1,109 @@
+package cuchaz.enigma.mapping;
+
+import java.util.List;
+
+import com.beust.jcommander.internal.Lists;
+
+import cuchaz.enigma.Util;
+
+public class Signature {
+        
+        private List<Type> m_argumentTypes;
+        private Type m_returnType;
+        
+        public Signature(String signature) {
+                try {
+                        m_argumentTypes = Lists.newArrayList();
+                        int i=0;
+                        while (i<signature.length()) {
+                                char c = signature.charAt(i);
+                                if (c == '(') {
+                                        assert(m_argumentTypes.isEmpty());
+                                        assert(m_returnType == null);
+                                        i++;
+                                } else if (c == ')') {
+                                        i++;
+                                        break;
+                                } else {
+                                        String type = Type.parseFirst(signature.substring(i));
+                                        m_argumentTypes.add(new Type(type));
+                                        i += type.length();
+                                }
+                        }
+                        m_returnType = new Type(Type.parseFirst(signature.substring(i)));
+                } catch (Exception ex) {
+                        throw new IllegalArgumentException("Unable to parse signature: " + signature, ex);
+                }
+        }
+        
+        public Signature(Signature other, ClassNameReplacer replacer) {
+                m_argumentTypes = Lists.newArrayList(other.m_argumentTypes);
+                for (int i=0; i<m_argumentTypes.size(); i++) {
+                        m_argumentTypes.set(i, new Type(m_argumentTypes.get(i), replacer));
+                }
+                m_returnType = new Type(other.m_returnType, replacer);
+        }
+        
+        public List<Type> getArgumentTypes() {
+                return m_argumentTypes;
+        }
+        
+        public Type getReturnType() {
+                return m_returnType;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("(");
+                for (Type type : m_argumentTypes) {
+                        buf.append(type.toString());
+                }
+                buf.append(")");
+                buf.append(m_returnType.toString());
+                return buf.toString();
+        }
+        
+        public Iterable<Type> types() {
+                List<Type> types = Lists.newArrayList();
+                types.addAll(m_argumentTypes);
+                types.add(m_returnType);
+                return types;
+        }
+        
+        public Iterable<ClassEntry> classes() {
+                List<ClassEntry> out = Lists.newArrayList();
+                for (Type type : types()) {
+                        if (type.isClass()) {
+                                out.add(type.getClassEntry());
+                        }
+                }
+                return out;
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof Signature) {
+                        return equals((Signature)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(Signature other) {
+                return m_argumentTypes.equals(other.m_argumentTypes) && m_returnType.equals(other.m_returnType);
+        }
+        
+        @Override
+        public int hashCode() {
+                return Util.combineHashesOrdered(m_argumentTypes.hashCode(), m_returnType.hashCode());
+        }
+
+        public boolean hasClass(ClassEntry classEntry) {
+                for (Type type : types()) {
+                        if (type.hasClass() && type.getClassEntry().equals(classEntry)) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/SignatureUpdater.java b/src/cuchaz/enigma/mapping/SignatureUpdater.java
new file mode 100644
index 0000000..3477cd5
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/SignatureUpdater.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.List;
+
+import com.google.common.collect.Lists;
+
+public class SignatureUpdater {
+        
+        public interface ClassNameUpdater {
+                String update(String className);
+        }
+        
+        public static String update(String signature, ClassNameUpdater updater) {
+                try {
+                        StringBuilder buf = new StringBuilder();
+                        
+                        // read the signature character-by-character
+                        StringReader reader = new StringReader(signature);
+                        int i = -1;
+                        while ( (i = reader.read()) != -1) {
+                                char c = (char)i;
+                                
+                                // does this character start a class name?
+                                if (c == 'L') {
+                                        // update the class name and add it to the buffer
+                                        buf.append('L');
+                                        String className = readClass(reader);
+                                        if (className == null) {
+                                                throw new IllegalArgumentException("Malformed signature: " + signature);
+                                        }
+                                        buf.append(updater.update(className));
+                                        buf.append(';');
+                                } else {
+                                        // copy the character into the buffer
+                                        buf.append(c);
+                                }
+                        }
+                        
+                        return buf.toString();
+                } catch (IOException ex) {
+                        // I'm pretty sure a StringReader will never throw one of these
+                        throw new Error(ex);
+                }
+        }
+        
+        private static String readClass(StringReader reader) throws IOException {
+                // read all the characters in the buffer until we hit a ';'
+                // remember to treat generics correctly
+                StringBuilder buf = new StringBuilder();
+                int depth = 0;
+                int i = -1;
+                while ( (i = reader.read()) != -1) {
+                        char c = (char)i;
+                        
+                        if (c == '<') {
+                                depth++;
+                        } else if (c == '>') {
+                                depth--;
+                        } else if (depth == 0) {
+                                if (c == ';') {
+                                        return buf.toString();
+                                } else {
+                                        buf.append(c);
+                                }
+                        }
+                }
+                
+                return null;
+        }
+        
+        public static List<String> getClasses(String signature) {
+                final List<String> classNames = Lists.newArrayList();
+                update(signature, new ClassNameUpdater() {
+                        @Override
+                        public String update(String className) {
+                                classNames.add(className);
+                                return className;
+                        }
+                });
+                return classNames;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/TranslationDirection.java b/src/cuchaz/enigma/mapping/TranslationDirection.java
new file mode 100644
index 0000000..d1b14cd
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/TranslationDirection.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+public enum TranslationDirection {
+        
+        Deobfuscating {
+                @Override
+                public <T> T choose(T deobfChoice, T obfChoice) {
+                        return deobfChoice;
+                }
+        },
+        Obfuscating {
+                @Override
+                public <T> T choose(T deobfChoice, T obfChoice) {
+                        return obfChoice;
+                }
+        };
+        
+        public abstract <T> T choose(T deobfChoice, T obfChoice);
+}
diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java
new file mode 100644
index 0000000..5eba18c
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Translator.java
@@ -0,0 +1,239 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+import cuchaz.enigma.analysis.TranslationIndex;
+
+public class Translator {
+        
+        private TranslationDirection m_direction;
+        private Map<String,ClassMapping> m_classes;
+        private TranslationIndex m_index;
+        
+        public Translator() {
+                m_direction = null;
+                m_classes = Maps.newHashMap();
+        }
+        
+        public Translator(TranslationDirection direction, Map<String,ClassMapping> classes, TranslationIndex index) {
+                m_direction = direction;
+                m_classes = classes;
+                m_index = index;
+        }
+        
+        @SuppressWarnings("unchecked")
+        public <T extends Entry> T translateEntry(T entry) {
+                if (entry instanceof ClassEntry) {
+                        return (T)translateEntry((ClassEntry)entry);
+                } else if (entry instanceof FieldEntry) {
+                        return (T)translateEntry((FieldEntry)entry);
+                } else if (entry instanceof MethodEntry) {
+                        return (T)translateEntry((MethodEntry)entry);
+                } else if (entry instanceof ConstructorEntry) {
+                        return (T)translateEntry((ConstructorEntry)entry);
+                } else if (entry instanceof ArgumentEntry) {
+                        return (T)translateEntry((ArgumentEntry)entry);
+                } else {
+                        throw new Error("Unknown entry type: " + entry.getClass().getName());
+                }
+        }
+        
+        public String translateClass(String className) {
+                return translate(new ClassEntry(className));
+        }
+        
+        public String translate(ClassEntry in) {
+                ClassMapping classMapping = m_classes.get(in.getOuterClassName());
+                if (classMapping != null) {
+                        if (in.isInnerClass()) {
+                                // translate the inner class
+                                String translatedInnerClassName = m_direction.choose(
+                                        classMapping.getDeobfInnerClassName(in.getInnerClassName()),
+                                        classMapping.getObfInnerClassName(in.getInnerClassName())
+                                );
+                                if (translatedInnerClassName != null) {
+                                        // try to translate the outer name
+                                        String translatedOuterClassName = m_direction.choose(classMapping.getDeobfName(), classMapping.getObfName());
+                                        if (translatedOuterClassName != null) {
+                                                return translatedOuterClassName + "$" + translatedInnerClassName;
+                                        } else {
+                                                return in.getOuterClassName() + "$" + translatedInnerClassName;
+                                        }
+                                }
+                        } else {
+                                // just return outer
+                                return m_direction.choose(classMapping.getDeobfName(), classMapping.getObfName());
+                        }
+                }
+                return null;
+        }
+        
+        public ClassEntry translateEntry(ClassEntry in) {
+                
+                // can we translate the inner class?
+                String name = translate(in);
+                if (name != null) {
+                        return new ClassEntry(name);
+                }
+                
+                if (in.isInnerClass()) {
+                        
+                        // guess not. just translate the outer class name then
+                        String outerClassName = translate(in.getOuterClassEntry());
+                        if (outerClassName != null) {
+                                return new ClassEntry(outerClassName + "$" + in.getInnerClassName());
+                        }
+                }
+                
+                return in;
+        }
+        
+        public String translate(FieldEntry in) {
+                
+                // resolve the class entry
+                ClassEntry resolvedClassEntry = m_index.resolveEntryClass(in);
+                if (resolvedClassEntry != null) {
+                
+                        // look for the class
+                        ClassMapping classMapping = findClassMapping(resolvedClassEntry);
+                        if (classMapping != null) {
+                                
+                                // look for the field
+                                String translatedName = m_direction.choose(
+                                        classMapping.getDeobfFieldName(in.getName()),
+                                        classMapping.getObfFieldName(in.getName())
+                                );
+                                if (translatedName != null) {
+                                        return translatedName;
+                                }
+                        }
+                }
+                return null;
+        }
+        
+        public FieldEntry translateEntry(FieldEntry in) {
+                String name = translate(in);
+                if (name == null) {
+                        name = in.getName();
+                }
+                return new FieldEntry(translateEntry(in.getClassEntry()), name);
+        }
+        
+        public String translate(MethodEntry in) {
+                
+                // resolve the class entry
+                ClassEntry resolvedClassEntry = m_index.resolveEntryClass(in);
+                if (resolvedClassEntry != null) {
+                
+                        // look for class
+                        ClassMapping classMapping = findClassMapping(resolvedClassEntry);
+                        if (classMapping != null) {
+                                
+                                // look for the method
+                                MethodMapping methodMapping = m_direction.choose(
+                                        classMapping.getMethodByObf(in.getName(), in.getSignature()),
+                                        classMapping.getMethodByDeobf(in.getName(), translateSignature(in.getSignature()))
+                                );
+                                if (methodMapping != null) {
+                                        return m_direction.choose(methodMapping.getDeobfName(), methodMapping.getObfName());
+                                }
+                        }
+                }
+                return null;
+        }
+        
+        public MethodEntry translateEntry(MethodEntry in) {
+                String name = translate(in);
+                if (name == null) {
+                        name = in.getName();
+                }
+                return new MethodEntry(translateEntry(in.getClassEntry()), name, translateSignature(in.getSignature()));
+        }
+        
+        public ConstructorEntry translateEntry(ConstructorEntry in) {
+                if (in.isStatic()) {
+                        return new ConstructorEntry(translateEntry(in.getClassEntry()));
+                } else {
+                        return new ConstructorEntry(translateEntry(in.getClassEntry()), translateSignature(in.getSignature()));
+                }
+        }
+        
+        public BehaviorEntry translateEntry(BehaviorEntry in) {
+                if (in instanceof MethodEntry) {
+                        return translateEntry((MethodEntry)in);
+                } else if (in instanceof ConstructorEntry) {
+                        return translateEntry((ConstructorEntry)in);
+                }
+                throw new Error("Wrong entry type!");
+        }
+        
+        public String translate(ArgumentEntry in) {
+                
+                // look for the class
+                ClassMapping classMapping = findClassMapping(in.getClassEntry());
+                if (classMapping != null) {
+                        
+                        // look for the method
+                        MethodMapping methodMapping = m_direction.choose(
+                                classMapping.getMethodByObf(in.getMethodName(), in.getMethodSignature()),
+                                classMapping.getMethodByDeobf(in.getMethodName(), translateSignature(in.getMethodSignature()))
+                        );
+                        if (methodMapping != null) {
+                                return m_direction.choose(
+                                        methodMapping.getDeobfArgumentName(in.getIndex()),
+                                        methodMapping.getObfArgumentName(in.getIndex())
+                                );
+                        }
+                }
+                return null;
+        }
+        
+        public ArgumentEntry translateEntry(ArgumentEntry in) {
+                String name = translate(in);
+                if (name == null) {
+                        name = in.getName();
+                }
+                return new ArgumentEntry(translateEntry(in.getBehaviorEntry()), in.getIndex(), name);
+        }
+        
+        public Type translateType(Type type) {
+                return new Type(type, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                return translateClass(className);
+                        }
+                });
+        }
+        
+        public Signature translateSignature(Signature signature) {
+                return new Signature(signature, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                return translateClass(className);
+                        }
+                });
+        }
+        
+        private ClassMapping findClassMapping(ClassEntry classEntry) {
+                ClassMapping classMapping = m_classes.get(classEntry.getOuterClassName());
+                if (classMapping != null && classEntry.isInnerClass()) {
+                        classMapping = m_direction.choose(
+                                classMapping.getInnerClassByObf(classEntry.getInnerClassName()),
+                                classMapping.getInnerClassByDeobfThenObf(classEntry.getInnerClassName())
+                        );
+                }
+                return classMapping;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Type.java b/src/cuchaz/enigma/mapping/Type.java
new file mode 100644
index 0000000..9f5d52f
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Type.java
@@ -0,0 +1,218 @@
+package cuchaz.enigma.mapping;
+
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+public class Type {
+        
+        public enum Primitive {
+                Byte('B'),
+                Character('C'),
+                Short('S'),
+                Integer('I'),
+                Long('J'),
+                Float('F'),
+                Double('D'),
+                Boolean('Z');
+                
+                private static final Map<Character,Primitive> m_lookup;
+                
+                static {
+                        m_lookup = Maps.newTreeMap();
+                        for (Primitive val : values()) {
+                                m_lookup.put(val.getCode(), val);
+                        }
+                }
+                
+                public static Primitive get(char code) {
+                        return m_lookup.get(code);
+                }
+                
+                private char m_code;
+                
+                private Primitive(char code) {
+                        m_code = code;
+                }
+        
+                public char getCode() {
+                        return m_code;
+                }
+        }
+        
+        public static String parseFirst(String in) {
+                
+                if (in == null || in.length() <= 0) {
+                        throw new IllegalArgumentException("No type to parse, input is empty!");
+                }
+                
+                // read one type from the input
+                
+                char c = in.charAt(0);
+                
+                // first check for void
+                if (c == 'V') {
+                        return "V";
+                }
+                
+                // then check for primitives
+                Primitive primitive = Primitive.get(c);
+                if (primitive != null) {
+                        return in.substring(0, 1);
+                }
+                
+                // then check for classes
+                if (c == 'L') {
+                        return readClass(in);
+                }
+
+                // then check for arrays
+                int dim = countArrayDimension(in);
+                if (dim > 0) {
+                        String arrayType = Type.parseFirst(in.substring(dim));
+                        return in.substring(0, dim + arrayType.length());
+                }
+                
+                throw new IllegalArgumentException("don't know how to parse: " + in);
+        }
+                
+        private String m_name;
+        
+        public Type(String name) {
+                m_name = name;
+        }
+        
+        public Type(ClassEntry classEntry) {
+                m_name = "L" + classEntry.getClassName() + ";";
+        }
+        
+        public Type(Type type, ClassNameReplacer replacer) {
+                m_name = type.m_name;
+                if (type.isClass()) {
+                        String replacedName = replacer.replace(type.getClassEntry().getClassName());
+                        if (replacedName != null) {
+                                m_name = "L" + replacedName + ";";
+                        }
+                } else if (type.isArray() && type.hasClass()) {
+                        String replacedName = replacer.replace(type.getClassEntry().getClassName());
+                        if (replacedName != null) {
+                                m_name = Type.getArrayPrefix(type.getArrayDimension()) + "L" + replacedName + ";";
+                        }
+                }
+        }
+        
+        @Override
+        public String toString() {
+                return m_name;
+        }
+        
+        public boolean isVoid() {
+                return m_name.length() == 1 && m_name.charAt(0) == 'V';
+        }
+        
+        public boolean isPrimitive() {
+                return m_name.length() == 1 && Primitive.get(m_name.charAt(0)) != null;
+        }
+        
+        public Primitive getPrimitive() {
+                if (!isPrimitive()) {
+                        throw new IllegalStateException("not a primitive");
+                }
+                return Primitive.get(m_name.charAt(0));
+        }
+        
+        public boolean isClass() {
+                return m_name.charAt(0) == 'L' && m_name.charAt(m_name.length() - 1) == ';';
+        }
+        
+        public ClassEntry getClassEntry() {
+                if (isClass()) {
+                        String name = m_name.substring(1, m_name.length() - 1);
+                        
+                        int pos = name.indexOf('<');
+                        if (pos >= 0) {
+                                // remove the parameters from the class name
+                                name = name.substring(0, pos);
+                        }
+                        
+                        return new ClassEntry(name);
+                        
+                } else if (isArray() && getArrayType().isClass()) {
+                        return getArrayType().getClassEntry();
+                } else {
+                        throw new IllegalStateException("type doesn't have a class");
+                }
+        }
+        
+        public boolean isArray() {
+                return m_name.charAt(0) == '[';
+        }
+        
+        public int getArrayDimension() {
+                if (!isArray()) {
+                        throw new IllegalStateException("not an array");
+                }
+                return countArrayDimension(m_name);
+        }
+        
+        public Type getArrayType() {
+                if (!isArray()) {
+                        throw new IllegalStateException("not an array");
+                }
+                return new Type(m_name.substring(getArrayDimension(), m_name.length()));
+        }
+        
+        private static String getArrayPrefix(int dimension) {
+                StringBuilder buf = new StringBuilder();
+                for (int i=0; i<dimension; i++) {
+                        buf.append("[");
+                }
+                return buf.toString();
+        }
+        
+        public boolean hasClass() {
+                return isClass() || (isArray() && getArrayType().hasClass());
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof Type) {
+                        return equals((Type)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(Type other) {
+                return m_name.equals(other.m_name);
+        }
+        
+        public int hashCode() {
+                return m_name.hashCode();
+        }
+        
+        private static int countArrayDimension(String in) {
+                int i=0;
+                for(; i < in.length() && in.charAt(i) == '['; i++);
+                return i;
+        }
+        
+        private static String readClass(String in) {
+                // read all the characters in the buffer until we hit a ';'
+                // remember to treat parameters correctly
+                StringBuilder buf = new StringBuilder();
+                int depth = 0;
+                for (int i=0; i<in.length(); i++) {
+                        char c = in.charAt(i);
+                        buf.append(c);
+                        
+                        if (c == '<') {
+                                depth++;
+                        } else if (c == '>') {
+                                depth--;
+                        } else if (depth == 0 && c == ';') {
+                                return buf.toString();
+                        }
+                }
+                return null;
+        }
+}
diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java
new file mode 100644
index 0000000..fa90779
--- /dev/null
+++ b/test/cuchaz/enigma/EntryFactory.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.\
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+
+public class EntryFactory {
+        
+        public static ClassEntry newClass(String name) {
+                return new ClassEntry(name);
+        }
+        
+        public static FieldEntry newField(String className, String fieldName) {
+                return newField(newClass(className), fieldName);
+        }
+        
+        public static FieldEntry newField(ClassEntry classEntry, String fieldName) {
+                return new FieldEntry(classEntry, fieldName);
+        }
+        
+        public static MethodEntry newMethod(String className, String methodName, String methodSignature) {
+                return newMethod(newClass(className), methodName, methodSignature);
+        }
+        
+        public static MethodEntry newMethod(ClassEntry classEntry, String methodName, String methodSignature) {
+                return new MethodEntry(classEntry, methodName, new Signature(methodSignature));
+        }
+        
+        public static ConstructorEntry newConstructor(String className, String signature) {
+                return newConstructor(newClass(className), signature);
+        }
+        
+        public static ConstructorEntry newConstructor(ClassEntry classEntry, String signature) {
+                return new ConstructorEntry(classEntry, new Signature(signature));
+        }
+        
+        public static EntryReference<FieldEntry,BehaviorEntry> newFieldReferenceByMethod(FieldEntry fieldEntry, String callerClassName, String callerName, String callerSignature) {
+                return new EntryReference<FieldEntry,BehaviorEntry>(fieldEntry, "", newMethod(callerClassName, callerName, callerSignature));
+        }
+        
+        public static EntryReference<FieldEntry,BehaviorEntry> newFieldReferenceByConstructor(FieldEntry fieldEntry, String callerClassName, String callerSignature) {
+                return new EntryReference<FieldEntry,BehaviorEntry>(fieldEntry, "", newConstructor(callerClassName, callerSignature));
+        }
+        
+        public static EntryReference<BehaviorEntry,BehaviorEntry> newBehaviorReferenceByMethod(BehaviorEntry behaviorEntry, String callerClassName, String callerName, String callerSignature) {
+                return new EntryReference<BehaviorEntry,BehaviorEntry>(behaviorEntry, "", newMethod(callerClassName, callerName, callerSignature));
+        }
+        
+        public static EntryReference<BehaviorEntry,BehaviorEntry> newBehaviorReferenceByConstructor(BehaviorEntry behaviorEntry, String callerClassName, String callerSignature) {
+                return new EntryReference<BehaviorEntry,BehaviorEntry>(behaviorEntry, "", newConstructor(callerClassName, callerSignature));
+        }
+}
diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java
new file mode 100644
index 0000000..26d492d
--- /dev/null
+++ b/test/cuchaz/enigma/TestDeobfuscator.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.\
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import static org.junit.Assert.*;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class TestDeobfuscator {
+        
+        private Deobfuscator getDeobfuscator()
+        throws IOException {
+                return new Deobfuscator(new JarFile("build/testLoneClass.obf.jar"));
+        }
+        
+        @Test
+        public void loadJar()
+        throws Exception {
+                getDeobfuscator();
+        }
+        
+        @Test
+        public void getClasses()
+        throws Exception {
+                Deobfuscator deobfuscator = getDeobfuscator();
+                List<ClassEntry> obfClasses = Lists.newArrayList();
+                List<ClassEntry> deobfClasses = Lists.newArrayList();
+                deobfuscator.getSeparatedClasses(obfClasses, deobfClasses);
+                assertEquals(1, obfClasses.size());
+                assertEquals("none/a", obfClasses.get(0).getName());
+                assertEquals(1, deobfClasses.size());
+                assertEquals("cuchaz/enigma/inputs/Keep", deobfClasses.get(0).getName());
+        }
+        
+        @Test
+        public void decompileClass()
+        throws Exception {
+                Deobfuscator deobfuscator = getDeobfuscator();
+                deobfuscator.getSource(deobfuscator.getSourceTree("none/a"));
+        }
+}
diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java
new file mode 100644
index 0000000..2e16a33
--- /dev/null
+++ b/test/cuchaz/enigma/TestInnerClasses.java
@@ -0,0 +1,90 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import cuchaz.enigma.analysis.JarIndex;
+
+public class TestInnerClasses {
+        
+        private JarIndex m_index;
+        private Deobfuscator m_deobfuscator;
+        
+        private static final String AnonymousOuter = "none/a";
+        private static final String AnonymousInner = "b";
+        private static final String SimpleOuter = "none/g";
+        private static final String SimpleInner = "h";
+        private static final String ConstructorArgsOuter = "none/e";
+        private static final String ConstructorArgsInner = "f";
+        private static final String AnonymousWithScopeArgsOuter = "none/c";
+        private static final String AnonymousWithScopeArgsInner = "d";
+        private static final String AnonymousWithOuterAccessOuter = "none/i";
+        private static final String AnonymousWithOuterAccessInner = "j";
+        
+        public TestInnerClasses()
+        throws Exception {
+                m_index = new JarIndex();
+                JarFile jar = new JarFile("build/testInnerClasses.obf.jar");
+                m_index.indexJar(jar, true);
+                m_deobfuscator = new Deobfuscator(jar);
+        }
+        
+        @Test
+        public void simple() {
+                assertThat(m_index.getOuterClass(SimpleInner), is(SimpleOuter));
+                assertThat(m_index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner));
+                assertThat(m_index.isAnonymousClass(SimpleInner), is(false));
+                decompile(SimpleOuter);
+        }
+        
+        @Test
+        public void anonymous() {
+                assertThat(m_index.getOuterClass(AnonymousInner), is(AnonymousOuter));
+                assertThat(m_index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner));
+                assertThat(m_index.isAnonymousClass(AnonymousInner), is(true));
+                decompile(AnonymousOuter);
+        }
+        
+        @Test
+        public void constructorArgs() {
+                assertThat(m_index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter));
+                assertThat(m_index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner));
+                assertThat(m_index.isAnonymousClass(ConstructorArgsInner), is(false));
+                decompile(ConstructorArgsOuter);
+        }
+        
+        @Test
+        public void anonymousWithScopeArgs() {
+                assertThat(m_index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter));
+                assertThat(m_index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner));
+                assertThat(m_index.isAnonymousClass(AnonymousWithScopeArgsInner), is(true));
+                decompile(AnonymousWithScopeArgsOuter);
+        }
+        
+        @Test
+        public void anonymousWithOuterAccess() {
+                assertThat(m_index.getOuterClass(AnonymousWithOuterAccessInner), is(AnonymousWithOuterAccessOuter));
+                assertThat(m_index.getInnerClasses(AnonymousWithOuterAccessOuter), containsInAnyOrder(AnonymousWithOuterAccessInner));
+                assertThat(m_index.isAnonymousClass(AnonymousWithOuterAccessInner), is(true));
+                decompile(AnonymousWithOuterAccessOuter);
+        }
+        
+        private void decompile(String name) {
+                m_deobfuscator.getSourceTree(name);
+        }
+}
diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java
new file mode 100644
index 0000000..22812fe
--- /dev/null
+++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java
@@ -0,0 +1,124 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import static cuchaz.enigma.EntryFactory.*;
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class TestJarIndexConstructorReferences {
+        
+        private JarIndex m_index;
+        
+        private ClassEntry m_baseClass = newClass("none/a");
+        private ClassEntry m_subClass = newClass("none/d");
+        private ClassEntry m_subsubClass = newClass("none/e");
+        private ClassEntry m_defaultClass = newClass("none/c");
+        private ClassEntry m_callerClass = newClass("none/b");
+        
+        public TestJarIndexConstructorReferences()
+        throws Exception {
+                File jarFile = new File("build/testConstructors.obf.jar");
+                m_index = new JarIndex();
+                m_index.indexJar(new JarFile(jarFile), false);
+        }
+        
+        @Test
+        public void obfEntries() {
+                assertThat(m_index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), m_baseClass, m_subClass, m_subsubClass, m_defaultClass, m_callerClass));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void baseDefault() {
+                BehaviorEntry source = newConstructor(m_baseClass, "()V");
+                Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references = m_index.getBehaviorReferences(source);
+                assertThat(references, containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "a", "()V"),
+                        newBehaviorReferenceByConstructor(source, m_subClass.getName(), "()V"),
+                        newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(III)V")
+                ));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void baseInt() {
+                BehaviorEntry source = newConstructor(m_baseClass, "(I)V");
+                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "b", "()V")
+                ));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void subDefault() {
+                BehaviorEntry source = newConstructor(m_subClass, "()V");
+                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "c", "()V"),
+                        newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(I)V")
+                ));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void subInt() {
+                BehaviorEntry source = newConstructor(m_subClass, "(I)V");
+                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "d", "()V"),
+                        newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(II)V"),
+                        newBehaviorReferenceByConstructor(source, m_subsubClass.getName(), "(I)V")
+                ));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void subIntInt() {
+                BehaviorEntry source = newConstructor(m_subClass, "(II)V");
+                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "e", "()V")
+                ));
+        }
+        
+        @Test
+        public void subIntIntInt() {
+                BehaviorEntry source = newConstructor(m_subClass, "(III)V");
+                assertThat(m_index.getBehaviorReferences(source), is(empty()));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void subsubInt() {
+                BehaviorEntry source = newConstructor(m_subsubClass, "(I)V");
+                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "f", "()V")
+                ));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void defaultConstructable() {
+                BehaviorEntry source = newConstructor(m_defaultClass, "()V");
+                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "g", "()V")
+                ));
+        }
+}
diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java
new file mode 100644
index 0000000..1d6e5a5
--- /dev/null
+++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java
@@ -0,0 +1,228 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import static cuchaz.enigma.EntryFactory.*;
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import cuchaz.enigma.analysis.Access;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.analysis.TranslationIndex;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+
+public class TestJarIndexInheritanceTree {
+        
+        private JarIndex m_index;
+        
+        private ClassEntry m_baseClass = newClass("none/a");
+        private ClassEntry m_subClassA = newClass("none/b");
+        private ClassEntry m_subClassAA = newClass("none/d");
+        private ClassEntry m_subClassB = newClass("none/c");
+        private FieldEntry m_nameField = new FieldEntry(m_baseClass, "a");
+        private FieldEntry m_numThingsField = new FieldEntry(m_subClassB, "a");
+        
+        public TestJarIndexInheritanceTree()
+        throws Exception {
+                m_index = new JarIndex();
+                m_index.indexJar(new JarFile("build/testInheritanceTree.obf.jar"), false);
+        }
+        
+        @Test
+        public void obfEntries() {
+                assertThat(m_index.getObfClassEntries(), containsInAnyOrder(
+                        newClass("cuchaz/enigma/inputs/Keep"),
+                        m_baseClass,
+                        m_subClassA,
+                        m_subClassAA,
+                        m_subClassB
+                ));
+        }
+        
+        @Test
+        public void translationIndex() {
+                
+                TranslationIndex index = m_index.getTranslationIndex();
+                
+                // base class
+                assertThat(index.getSuperclass(m_baseClass), is(nullValue()));
+                assertThat(index.getAncestry(m_baseClass), is(empty()));
+                assertThat(index.getSubclass(m_baseClass), containsInAnyOrder(
+                        m_subClassA,
+                        m_subClassB
+                ));
+                
+                // subclass a
+                assertThat(index.getSuperclass(m_subClassA), is(m_baseClass));
+                assertThat(index.getAncestry(m_subClassA), contains(m_baseClass));
+                assertThat(index.getSubclass(m_subClassA), contains(m_subClassAA));
+                
+                // subclass aa
+                assertThat(index.getSuperclass(m_subClassAA), is(m_subClassA));
+                assertThat(index.getAncestry(m_subClassAA), contains(m_subClassA, m_baseClass));
+                assertThat(index.getSubclass(m_subClassAA), is(empty()));
+                
+                // subclass b
+                assertThat(index.getSuperclass(m_subClassB), is(m_baseClass));
+                assertThat(index.getAncestry(m_subClassB), contains(m_baseClass));
+                assertThat(index.getSubclass(m_subClassB), is(empty()));
+        }
+        
+        @Test
+        public void access() {
+                assertThat(m_index.getAccess(m_nameField), is(Access.Private));
+                assertThat(m_index.getAccess(m_numThingsField), is(Access.Private));
+        }
+        
+        @Test
+        public void relatedMethodImplementations() {
+                
+                Set<MethodEntry> entries;
+                
+                // getName()
+                entries = m_index.getRelatedMethodImplementations(newMethod(m_baseClass, "a", "()Ljava/lang/String;"));
+                assertThat(entries, containsInAnyOrder(
+                        newMethod(m_baseClass, "a", "()Ljava/lang/String;"),
+                        newMethod(m_subClassAA, "a", "()Ljava/lang/String;")
+                ));
+                entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassAA, "a", "()Ljava/lang/String;"));
+                assertThat(entries, containsInAnyOrder(
+                        newMethod(m_baseClass, "a", "()Ljava/lang/String;"),
+                        newMethod(m_subClassAA, "a", "()Ljava/lang/String;")
+                ));
+                
+                // doBaseThings()
+                entries = m_index.getRelatedMethodImplementations(newMethod(m_baseClass, "a", "()V"));
+                assertThat(entries, containsInAnyOrder(
+                        newMethod(m_baseClass, "a", "()V"),
+                        newMethod(m_subClassAA, "a", "()V"),
+                        newMethod(m_subClassB, "a", "()V")
+                ));
+                entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassAA, "a", "()V"));
+                assertThat(entries, containsInAnyOrder(
+                        newMethod(m_baseClass, "a", "()V"),
+                        newMethod(m_subClassAA, "a", "()V"),
+                        newMethod(m_subClassB, "a", "()V")
+                ));
+                entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassB, "a", "()V"));
+                assertThat(entries, containsInAnyOrder(
+                        newMethod(m_baseClass, "a", "()V"),
+                        newMethod(m_subClassAA, "a", "()V"),
+                        newMethod(m_subClassB, "a", "()V")
+                ));
+                
+                // doBThings
+                entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassB, "b", "()V"));
+                assertThat(entries, containsInAnyOrder(newMethod(m_subClassB, "b", "()V")));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void fieldReferences() {
+                Collection<EntryReference<FieldEntry,BehaviorEntry>> references;
+                
+                // name
+                references = m_index.getFieldReferences(m_nameField);
+                assertThat(references, containsInAnyOrder(
+                        newFieldReferenceByConstructor(m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V"),
+                        newFieldReferenceByMethod(m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;")
+                ));
+                
+                // numThings
+                references = m_index.getFieldReferences(m_numThingsField);
+                assertThat(references, containsInAnyOrder(
+                        newFieldReferenceByConstructor(m_numThingsField, m_subClassB.getName(), "()V"),
+                        newFieldReferenceByMethod(m_numThingsField, m_subClassB.getName(), "b", "()V")
+                ));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void behaviorReferences() {
+                
+                BehaviorEntry source;
+                Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references;
+                
+                // baseClass constructor
+                source = newConstructor(m_baseClass, "(Ljava/lang/String;)V");
+                references = m_index.getBehaviorReferences(source);
+                assertThat(references, containsInAnyOrder(
+                        newBehaviorReferenceByConstructor(source, m_subClassA.getName(), "(Ljava/lang/String;)V"),
+                        newBehaviorReferenceByConstructor(source, m_subClassB.getName(), "()V")
+                ));
+                
+                // subClassA constructor
+                source = newConstructor(m_subClassA, "(Ljava/lang/String;)V");
+                references = m_index.getBehaviorReferences(source);
+                assertThat(references, containsInAnyOrder(
+                        newBehaviorReferenceByConstructor(source, m_subClassAA.getName(), "()V")
+                ));
+                
+                // baseClass.getName()
+                source = newMethod(m_baseClass, "a", "()Ljava/lang/String;");
+                references = m_index.getBehaviorReferences(source);
+                assertThat(references, containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()Ljava/lang/String;"),
+                        newBehaviorReferenceByMethod(source, m_subClassB.getName(), "a", "()V")
+                ));
+                
+                // subclassAA.getName()
+                source = newMethod(m_subClassAA, "a", "()Ljava/lang/String;");
+                references = m_index.getBehaviorReferences(source);
+                assertThat(references, containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()V")
+                ));
+        }
+        
+        @Test
+        public void containsEntries() {
+                
+                // classes
+                assertThat(m_index.containsObfClass(m_baseClass), is(true));
+                assertThat(m_index.containsObfClass(m_subClassA), is(true));
+                assertThat(m_index.containsObfClass(m_subClassAA), is(true));
+                assertThat(m_index.containsObfClass(m_subClassB), is(true));
+                
+                // fields
+                assertThat(m_index.containsObfField(m_nameField), is(true));
+                assertThat(m_index.containsObfField(m_numThingsField), is(true));
+                
+                // methods
+                // getName()
+                assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "a", "()Ljava/lang/String;")), is(true));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "a", "()Ljava/lang/String;")), is(false));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "a", "()Ljava/lang/String;")), is(true));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "a", "()Ljava/lang/String;")), is(false));
+                
+                // doBaseThings()
+                assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "a", "()V")), is(true));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "a", "()V")), is(false));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "a", "()V")), is(true));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "a", "()V")), is(true));
+                
+                // doBThings()
+                assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "b", "()V")), is(false));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "b", "()V")), is(false));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "b", "()V")), is(false));
+                assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "b", "()V")), is(true));
+                
+        }
+}
diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java
new file mode 100644
index 0000000..c6a9e55
--- /dev/null
+++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java
@@ -0,0 +1,165 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import static cuchaz.enigma.EntryFactory.*;
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import cuchaz.enigma.analysis.Access;
+import cuchaz.enigma.analysis.ClassImplementationsTreeNode;
+import cuchaz.enigma.analysis.ClassInheritanceTreeNode;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.analysis.MethodImplementationsTreeNode;
+import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
+import cuchaz.enigma.mapping.BehaviorEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class TestJarIndexLoneClass {
+        
+        private JarIndex m_index;
+        
+        public TestJarIndexLoneClass()
+        throws Exception {
+                m_index = new JarIndex();
+                m_index.indexJar(new JarFile("build/testLoneClass.obf.jar"), false);
+        }
+        
+        @Test
+        public void obfEntries() {
+                assertThat(m_index.getObfClassEntries(), containsInAnyOrder(
+                        newClass("cuchaz/enigma/inputs/Keep"),
+                        newClass("none/a")
+                ));
+        }
+        
+        @Test
+        public void translationIndex() {
+                assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("none/a")), is(nullValue()));
+                assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(nullValue()));
+                assertThat(m_index.getTranslationIndex().getAncestry(new ClassEntry("none/a")), is(empty()));
+                assertThat(m_index.getTranslationIndex().getAncestry(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+                assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("none/a")), is(empty()));
+                assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+        }
+        
+        @Test
+        public void access() {
+                assertThat(m_index.getAccess(newField("none/a", "a")), is(Access.Private));
+                assertThat(m_index.getAccess(newMethod("none/a", "a", "()Ljava/lang/String;")), is(Access.Public));
+                assertThat(m_index.getAccess(newField("none/a", "b")), is(nullValue()));
+        }
+        
+        @Test
+        public void classInheritance() {
+                ClassInheritanceTreeNode node = m_index.getClassInheritance(new Translator(), newClass("none/a"));
+                assertThat(node, is(not(nullValue())));
+                assertThat(node.getObfClassName(), is("none/a"));
+                assertThat(node.getChildCount(), is(0));
+        }
+        
+        @Test
+        public void methodInheritance() {
+                MethodEntry source = newMethod("none/a", "a", "()Ljava/lang/String;");
+                MethodInheritanceTreeNode node = m_index.getMethodInheritance(new Translator(), source);
+                assertThat(node, is(not(nullValue())));
+                assertThat(node.getMethodEntry(), is(source));
+                assertThat(node.getChildCount(), is(0));
+        }
+        
+        @Test
+        public void classImplementations() {
+                ClassImplementationsTreeNode node = m_index.getClassImplementations(new Translator(), newClass("none/a"));
+                assertThat(node, is(nullValue()));
+        }
+        
+        @Test
+        public void methodImplementations() {
+                MethodEntry source = newMethod("none/a", "a", "()Ljava/lang/String;");
+                MethodImplementationsTreeNode node = m_index.getMethodImplementations(new Translator(), source);
+                assertThat(node, is(nullValue()));
+        }
+        
+        @Test
+        public void relatedMethodImplementations() {
+                Set<MethodEntry> entries = m_index.getRelatedMethodImplementations(newMethod("none/a", "a", "()Ljava/lang/String;"));
+                assertThat(entries, containsInAnyOrder(
+                        newMethod("none/a", "a", "()Ljava/lang/String;")
+                ));
+        }
+        
+        @Test
+        @SuppressWarnings("unchecked")
+        public void fieldReferences() {
+                FieldEntry source = newField("none/a", "a");
+                Collection<EntryReference<FieldEntry,BehaviorEntry>> references = m_index.getFieldReferences(source);
+                assertThat(references, containsInAnyOrder(
+                        newFieldReferenceByConstructor(source, "none/a", "(Ljava/lang/String;)V"),
+                        newFieldReferenceByMethod(source, "none/a", "a", "()Ljava/lang/String;")
+                ));
+        }
+        
+        @Test
+        public void behaviorReferences() {
+                assertThat(m_index.getBehaviorReferences(newMethod("none/a", "a", "()Ljava/lang/String;")), is(empty()));
+        }
+        
+        @Test
+        public void innerClasses() {
+                assertThat(m_index.getInnerClasses("none/a"), is(empty()));
+        }
+        
+        @Test
+        public void outerClass() {
+                assertThat(m_index.getOuterClass("a"), is(nullValue()));
+        }
+        
+        @Test
+        public void isAnonymousClass() {
+                assertThat(m_index.isAnonymousClass("none/a"), is(false));
+        }
+        
+        @Test
+        public void interfaces() {
+                assertThat(m_index.getInterfaces("none/a"), is(empty()));
+        }
+        
+        @Test
+        public void implementingClasses() {
+                assertThat(m_index.getImplementingClasses("none/a"), is(empty()));
+        }
+        
+        @Test
+        public void isInterface() {
+                assertThat(m_index.isInterface("none/a"), is(false));
+        }
+        
+        @Test
+        public void contains() {
+                assertThat(m_index.containsObfClass(newClass("none/a")), is(true));
+                assertThat(m_index.containsObfClass(newClass("none/b")), is(false));
+                assertThat(m_index.containsObfField(newField("none/a", "a")), is(true));
+                assertThat(m_index.containsObfField(newField("none/a", "b")), is(false));
+                assertThat(m_index.containsObfBehavior(newMethod("none/a", "a", "()Ljava/lang/String;")), is(true));
+                assertThat(m_index.containsObfBehavior(newMethod("none/a", "b", "()Ljava/lang/String;")), is(false));
+        }
+}
diff --git a/test/cuchaz/enigma/TestSignature.java b/test/cuchaz/enigma/TestSignature.java
new file mode 100644
index 0000000..183a4fd
--- /dev/null
+++ b/test/cuchaz/enigma/TestSignature.java
@@ -0,0 +1,266 @@
+package cuchaz.enigma;
+
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import org.junit.Test;
+
+import cuchaz.enigma.mapping.ClassNameReplacer;
+import cuchaz.enigma.mapping.Signature;
+import cuchaz.enigma.mapping.Type;
+
+
+public class TestSignature {
+        
+        @Test
+        public void easiest() {
+                final Signature sig = new Signature("()V");
+                assertThat(sig.getArgumentTypes(), is(empty()));
+                assertThat(sig.getReturnType(), is(new Type("V")));
+        }
+        
+        @Test
+        public void primitives() {
+                {
+                        final Signature sig = new Signature("(I)V");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final Signature sig = new Signature("(I)I");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("I")));
+                }
+                {
+                        final Signature sig = new Signature("(IBCJ)Z");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I"),
+                                new Type("B"),
+                                new Type("C"),
+                                new Type("J")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("Z")));
+                }
+        }
+        
+        @Test
+        public void classes() {
+                {
+                        final Signature sig = new Signature("([LFoo;)V");
+                        assertThat(sig.getArgumentTypes().size(), is(1));
+                        assertThat(sig.getArgumentTypes().get(0), is(new Type("[LFoo;")));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final Signature sig = new Signature("(LFoo;)LBar;");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LFoo;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LBar;")));
+                }
+                {
+                        final Signature sig = new Signature("(LFoo;LMoo;LZoo;)LBar;");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LFoo;"),
+                                new Type("LMoo;"),
+                                new Type("LZoo;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LBar;")));
+                }
+                {
+                        final Signature sig = new Signature("(LFoo<LParm;>;LMoo<LParm;>;)LBar<LParm;>;");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LFoo<LParm;>;"),
+                                new Type("LMoo<LParm;>;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LBar<LParm;>;")));
+                }
+        }
+        
+        @Test
+        public void arrays() {
+                {
+                        final Signature sig = new Signature("([I)V");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("[I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final Signature sig = new Signature("([I)[J");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("[I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("[J")));
+                }
+                {
+                        final Signature sig = new Signature("([I[Z[F)[D");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("[I"),
+                                new Type("[Z"),
+                                new Type("[F")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("[D")));
+                }
+        }
+        
+        @Test
+        public void mixed() {
+                {
+                        final Signature sig = new Signature("(I[JLFoo;)Z");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I"),
+                                new Type("[J"),
+                                new Type("LFoo;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("Z")));
+                }
+                {
+                        final Signature sig = new Signature("(III)[LFoo;");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I"),
+                                new Type("I"),
+                                new Type("I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("[LFoo;")));
+                }
+        }
+        
+        @Test
+        public void replaceClasses() {
+                {
+                        final Signature oldSig = new Signature("()V");
+                        final Signature sig = new Signature(oldSig, new ClassNameReplacer() {
+                                @Override
+                                public String replace(String val) {
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), is(empty()));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final Signature oldSig = new Signature("(IJLFoo;)V");
+                        final Signature sig = new Signature(oldSig, new ClassNameReplacer() {
+                                @Override
+                                public String replace(String val) {
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I"),
+                                new Type("J"),
+                                new Type("LFoo;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final Signature oldSig = new Signature("(LFoo;LBar;)LMoo;");
+                        final Signature sig = new Signature(oldSig, new ClassNameReplacer() {
+                                @Override
+                                public String replace(String val) {
+                                        if (val.equals("Foo")) {
+                                                return "Bar";
+                                        }
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LBar;"),
+                                new Type("LBar;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LMoo;")));
+                }
+                {
+                        final Signature oldSig = new Signature("(LFoo;LBar;)LMoo;");
+                        final Signature sig = new Signature(oldSig, new ClassNameReplacer() {
+                                @Override
+                                public String replace(String val) {
+                                        if (val.equals("Moo")) {
+                                                return "Cow";
+                                        }
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LFoo;"),
+                                new Type("LBar;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LCow;")));
+                }
+        }
+        
+        @Test
+        public void replaceArrayClasses() {
+                {
+                        final Signature oldSig = new Signature("([LFoo;)[[[LBar;");
+                        final Signature sig = new Signature(oldSig, new ClassNameReplacer() {
+                                @Override
+                                public String replace(String val) {
+                                        if (val.equals("Foo")) {
+                                                return "Food";
+                                        } else if (val.equals("Bar")) {
+                                                return "Beer";
+                                        }
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("[LFood;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("[[[LBeer;")));
+                }
+        }
+        
+        @Test
+        public void equals() {
+                
+                // base
+                assertThat(new Signature("()V"), is(new Signature("()V")));
+                
+                // arguments
+                assertThat(new Signature("(I)V"), is(new Signature("(I)V")));
+                assertThat(new Signature("(ZIZ)V"), is(new Signature("(ZIZ)V")));
+                assertThat(new Signature("(LFoo;)V"), is(new Signature("(LFoo;)V")));
+                assertThat(new Signature("(LFoo;LBar;)V"), is(new Signature("(LFoo;LBar;)V")));
+                assertThat(new Signature("([I)V"), is(new Signature("([I)V")));
+                assertThat(new Signature("([[D[[[J)V"), is(new Signature("([[D[[[J)V")));
+
+                assertThat(new Signature("()V"), is(not(new Signature("(I)V"))));
+                assertThat(new Signature("(I)V"), is(not(new Signature("()V"))));
+                assertThat(new Signature("(IJ)V"), is(not(new Signature("(JI)V"))));
+                assertThat(new Signature("([[Z)V"), is(not(new Signature("([[LFoo;)V"))));
+                assertThat(new Signature("(LFoo;LBar;)V"), is(not(new Signature("(LFoo;LCow;)V"))));
+                assertThat(new Signature("([LFoo;LBar;)V"), is(not(new Signature("(LFoo;LCow;)V"))));
+                
+                // return type
+                assertThat(new Signature("()I"), is(new Signature("()I")));
+                assertThat(new Signature("()Z"), is(new Signature("()Z")));
+                assertThat(new Signature("()[D"), is(new Signature("()[D")));
+                assertThat(new Signature("()[[[Z"), is(new Signature("()[[[Z")));
+                assertThat(new Signature("()LFoo;"), is(new Signature("()LFoo;")));
+                assertThat(new Signature("()[LFoo;"), is(new Signature("()[LFoo;")));
+                
+                assertThat(new Signature("()I"), is(not(new Signature("()Z"))));
+                assertThat(new Signature("()Z"), is(not(new Signature("()I"))));
+                assertThat(new Signature("()[D"), is(not(new Signature("()[J"))));
+                assertThat(new Signature("()[[[Z"), is(not(new Signature("()[[Z"))));
+                assertThat(new Signature("()LFoo;"), is(not(new Signature("()LBar;"))));
+                assertThat(new Signature("()[LFoo;"), is(not(new Signature("()[LBar;"))));
+        }
+        
+        @Test
+        public void testToString() {
+                assertThat(new Signature("()V").toString(), is("()V"));
+                assertThat(new Signature("(I)V").toString(), is("(I)V"));
+                assertThat(new Signature("(ZIZ)V").toString(), is("(ZIZ)V"));
+                assertThat(new Signature("(LFoo;)V").toString(), is("(LFoo;)V"));
+                assertThat(new Signature("(LFoo;LBar;)V").toString(), is("(LFoo;LBar;)V"));
+                assertThat(new Signature("([I)V").toString(), is("([I)V"));
+                assertThat(new Signature("([[D[[[J)V").toString(), is("([[D[[[J)V"));
+        }
+}
diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java
new file mode 100644
index 0000000..357acb6
--- /dev/null
+++ b/test/cuchaz/enigma/TestSourceIndex.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.util.Set;
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import com.google.common.collect.Sets;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class TestSourceIndex {
+        
+        // TEMP
+        //@Test
+        public void indexEverything()
+        throws Exception {
+                Deobfuscator deobfuscator = new Deobfuscator(new JarFile("input/1.8.jar"));
+                
+                // get all classes that aren't inner classes
+                Set<ClassEntry> classEntries = Sets.newHashSet();
+                for (ClassEntry obfClassEntry : deobfuscator.getJarIndex().getObfClassEntries()) {
+                        if (!obfClassEntry.isInnerClass()) {
+                                classEntries.add(obfClassEntry);
+                        }
+                }
+                
+                for (ClassEntry obfClassEntry : classEntries) {
+                        try {
+                                CompilationUnit tree = deobfuscator.getSourceTree(obfClassEntry.getName());
+                                String source = deobfuscator.getSource(tree);
+                                deobfuscator.getSourceIndex(tree, source);
+                        } catch (Throwable t) {
+                                throw new Error("Unable to index " + obfClassEntry, t);
+                        }
+                }
+        }
+}
diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java
new file mode 100644
index 0000000..6758d2a
--- /dev/null
+++ b/test/cuchaz/enigma/TestTokensConstructors.java
@@ -0,0 +1,136 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import static cuchaz.enigma.EntryFactory.*;
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import cuchaz.enigma.mapping.BehaviorEntry;
+
+public class TestTokensConstructors extends TokenChecker {
+        
+        public TestTokensConstructors()
+        throws Exception {
+                super(new JarFile("build/testConstructors.obf.jar"));
+        }
+        
+        @Test
+        public void baseDeclarations() {
+                assertThat(getDeclarationToken(newConstructor("none/a", "()V")), is("a"));
+                assertThat(getDeclarationToken(newConstructor("none/a", "(I)V")), is("a"));
+        }
+        
+        @Test
+        public void subDeclarations() {
+                assertThat(getDeclarationToken(newConstructor("none/d", "()V")), is("d"));
+                assertThat(getDeclarationToken(newConstructor("none/d", "(I)V")), is("d"));
+                assertThat(getDeclarationToken(newConstructor("none/d", "(II)V")), is("d"));
+                assertThat(getDeclarationToken(newConstructor("none/d", "(III)V")), is("d"));
+        }
+        
+        @Test
+        public void subsubDeclarations() {
+                assertThat(getDeclarationToken(newConstructor("none/e", "(I)V")), is("e"));
+        }
+        
+        @Test
+        public void defaultDeclarations() {
+                assertThat(getDeclarationToken(newConstructor("none/c", "()V")), nullValue());
+        }
+        
+        @Test
+        public void baseDefaultReferences() {
+                BehaviorEntry source = newConstructor("none/a", "()V");
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "a", "()V")),
+                        containsInAnyOrder("a")
+                );
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "()V")),
+                        is(empty()) // implicit call, not decompiled to token
+                );
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(III)V")),
+                        is(empty()) // implicit call, not decompiled to token
+                );
+        }
+        
+        @Test
+        public void baseIntReferences() {
+                BehaviorEntry source = newConstructor("none/a", "(I)V");
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "b", "()V")),
+                        containsInAnyOrder("a")
+                );
+        }
+        
+        @Test
+        public void subDefaultReferences() {
+                BehaviorEntry source = newConstructor("none/d", "()V");
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "c", "()V")),
+                        containsInAnyOrder("d")
+                );
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(I)V")),
+                        containsInAnyOrder("this")
+                );
+        }
+        
+        @Test
+        public void subIntReferences() {
+                BehaviorEntry source = newConstructor("none/d", "(I)V");
+                assertThat(getReferenceTokens(
+                        newBehaviorReferenceByMethod(source, "none/b", "d", "()V")),
+                        containsInAnyOrder("d")
+                );
+                assertThat(getReferenceTokens(
+                        newBehaviorReferenceByConstructor(source, "none/d", "(II)V")),
+                        containsInAnyOrder("this")
+                );
+                assertThat(getReferenceTokens(
+                        newBehaviorReferenceByConstructor(source, "none/e", "(I)V")),
+                        containsInAnyOrder("super")
+                );
+        }
+        
+        @Test
+        public void subIntIntReferences() {
+                BehaviorEntry source = newConstructor("none/d", "(II)V");
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "e", "()V")),
+                        containsInAnyOrder("d")
+                );
+        }
+        
+        @Test
+        public void subsubIntReferences() {
+                BehaviorEntry source = newConstructor("none/e", "(I)V");
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "f", "()V")),
+                        containsInAnyOrder("e")
+                );
+        }
+        
+        @Test
+        public void defaultConstructableReferences() {
+                BehaviorEntry source = newConstructor("none/c", "()V");
+                assertThat(
+                        getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "g", "()V")),
+                        containsInAnyOrder("c")
+                );
+        }
+}
diff --git a/test/cuchaz/enigma/TestTranslator.java b/test/cuchaz/enigma/TestTranslator.java
new file mode 100644
index 0000000..290f6f0
--- /dev/null
+++ b/test/cuchaz/enigma/TestTranslator.java
@@ -0,0 +1,39 @@
+package cuchaz.enigma;
+
+import static cuchaz.enigma.EntryFactory.*;
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsReader;
+import cuchaz.enigma.mapping.TranslationDirection;
+import cuchaz.enigma.mapping.Translator;
+
+
+public class TestTranslator {
+
+        private Deobfuscator m_deobfuscator;
+        private Mappings m_mappings;
+        
+        public TestTranslator()
+        throws Exception {
+                m_deobfuscator = new Deobfuscator(new JarFile("build/testTranslation.obf.jar"));
+                try (InputStream in = getClass().getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) {
+                        m_mappings = new MappingsReader().read(new InputStreamReader(in));
+                        m_deobfuscator.setMappings(m_mappings);
+                }
+        }
+        
+        @Test
+        public void deobfuscatingTranslations()
+        throws Exception {
+                Translator translator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating);
+                assertThat(translator.translateEntry(newClass("none/a")), is(newClass("deobf/A")));
+        }
+}
diff --git a/test/cuchaz/enigma/TestType.java b/test/cuchaz/enigma/TestType.java
new file mode 100644
index 0000000..7c3cebe
--- /dev/null
+++ b/test/cuchaz/enigma/TestType.java
@@ -0,0 +1,229 @@
+package cuchaz.enigma;
+
+import org.junit.Test;
+
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import cuchaz.enigma.mapping.Type;
+
+import static cuchaz.enigma.EntryFactory.*;
+
+
+public class TestType {
+        
+        @Test
+        public void isVoid() {
+                assertThat(new Type("V").isVoid(), is(true));
+                assertThat(new Type("Z").isVoid(), is(false));
+                assertThat(new Type("B").isVoid(), is(false));
+                assertThat(new Type("C").isVoid(), is(false));
+                assertThat(new Type("I").isVoid(), is(false));
+                assertThat(new Type("J").isVoid(), is(false));
+                assertThat(new Type("F").isVoid(), is(false));
+                assertThat(new Type("D").isVoid(), is(false));
+                assertThat(new Type("LFoo;").isVoid(), is(false));
+                assertThat(new Type("[I").isVoid(), is(false));
+        }
+        
+        @Test
+        public void isPrimitive() {
+                assertThat(new Type("V").isPrimitive(), is(false));
+                assertThat(new Type("Z").isPrimitive(), is(true));
+                assertThat(new Type("B").isPrimitive(), is(true));
+                assertThat(new Type("C").isPrimitive(), is(true));
+                assertThat(new Type("I").isPrimitive(), is(true));
+                assertThat(new Type("J").isPrimitive(), is(true));
+                assertThat(new Type("F").isPrimitive(), is(true));
+                assertThat(new Type("D").isPrimitive(), is(true));
+                assertThat(new Type("LFoo;").isPrimitive(), is(false));
+                assertThat(new Type("[I").isPrimitive(), is(false));
+        }
+        
+        @Test
+        public void getPrimitive() {
+                assertThat(new Type("Z").getPrimitive(), is(Type.Primitive.Boolean));
+                assertThat(new Type("B").getPrimitive(), is(Type.Primitive.Byte));
+                assertThat(new Type("C").getPrimitive(), is(Type.Primitive.Character));
+                assertThat(new Type("I").getPrimitive(), is(Type.Primitive.Integer));
+                assertThat(new Type("J").getPrimitive(), is(Type.Primitive.Long));
+                assertThat(new Type("F").getPrimitive(), is(Type.Primitive.Float));
+                assertThat(new Type("D").getPrimitive(), is(Type.Primitive.Double));
+        }
+        
+        @Test
+        public void isClass() {
+                assertThat(new Type("V").isClass(), is(false));
+                assertThat(new Type("Z").isClass(), is(false));
+                assertThat(new Type("B").isClass(), is(false));
+                assertThat(new Type("C").isClass(), is(false));
+                assertThat(new Type("I").isClass(), is(false));
+                assertThat(new Type("J").isClass(), is(false));
+                assertThat(new Type("F").isClass(), is(false));
+                assertThat(new Type("D").isClass(), is(false));
+                assertThat(new Type("LFoo;").isClass(), is(true));
+                assertThat(new Type("[I").isClass(), is(false));
+        }
+        
+        @Test
+        public void getClassEntry() {
+                assertThat(new Type("LFoo;").getClassEntry(), is(newClass("Foo")));
+                assertThat(new Type("LFoo<Ljava/lang/String;>;").getClassEntry(), is(newClass("Foo")));
+        }
+        
+        @Test
+        public void getArrayClassEntry() {
+                assertThat(new Type("[LFoo;").getClassEntry(), is(newClass("Foo")));
+                assertThat(new Type("[[[LFoo<Ljava/lang/String;>;").getClassEntry(), is(newClass("Foo")));
+        }
+        
+        @Test
+        public void isArray() {
+                assertThat(new Type("V").isArray(), is(false));
+                assertThat(new Type("Z").isArray(), is(false));
+                assertThat(new Type("B").isArray(), is(false));
+                assertThat(new Type("C").isArray(), is(false));
+                assertThat(new Type("I").isArray(), is(false));
+                assertThat(new Type("J").isArray(), is(false));
+                assertThat(new Type("F").isArray(), is(false));
+                assertThat(new Type("D").isArray(), is(false));
+                assertThat(new Type("LFoo;").isArray(), is(false));
+                assertThat(new Type("[I").isArray(), is(true));
+        }
+        
+        @Test
+        public void getArrayDimension() {
+                assertThat(new Type("[I").getArrayDimension(), is(1));
+                assertThat(new Type("[[I").getArrayDimension(), is(2));
+                assertThat(new Type("[[[I").getArrayDimension(), is(3));
+        }
+        
+        @Test
+        public void getArrayType() {
+                assertThat(new Type("[I").getArrayType(), is(new Type("I")));
+                assertThat(new Type("[[I").getArrayType(), is(new Type("I")));
+                assertThat(new Type("[[[I").getArrayType(), is(new Type("I")));
+                assertThat(new Type("[Ljava/lang/String;").getArrayType(), is(new Type("Ljava/lang/String;")));
+        }
+        
+        @Test
+        public void hasClass() {
+                assertThat(new Type("LFoo;").hasClass(), is(true));
+                assertThat(new Type("LCow<LCheese;>;").hasClass(), is(true));
+                assertThat(new Type("[LBar;").hasClass(), is(true));
+                assertThat(new Type("[[[LCat;").hasClass(), is(true));
+
+                assertThat(new Type("V").hasClass(), is(false));
+                assertThat(new Type("[I").hasClass(), is(false));
+                assertThat(new Type("[[[I").hasClass(), is(false));
+                assertThat(new Type("Z").hasClass(), is(false));
+        }
+        
+        @Test
+        public void parseVoid() {
+                final String answer = "V";
+                assertThat(Type.parseFirst("V"), is(answer));
+                assertThat(Type.parseFirst("VVV"), is(answer));
+                assertThat(Type.parseFirst("VIJ"), is(answer));
+                assertThat(Type.parseFirst("V[I"), is(answer));
+                assertThat(Type.parseFirst("VLFoo;"), is(answer));
+                assertThat(Type.parseFirst("V[LFoo;"), is(answer));
+        }
+        
+        @Test
+        public void parsePrimitive() {
+                final String answer = "I";
+                assertThat(Type.parseFirst("I"), is(answer));
+                assertThat(Type.parseFirst("III"), is(answer));
+                assertThat(Type.parseFirst("IJZ"), is(answer));
+                assertThat(Type.parseFirst("I[I"), is(answer));
+                assertThat(Type.parseFirst("ILFoo;"), is(answer));
+                assertThat(Type.parseFirst("I[LFoo;"), is(answer));
+        }
+        
+        @Test
+        public void parseClass() {
+                {
+                        final String answer = "LFoo;";
+                        assertThat(Type.parseFirst("LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;JZ"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;[I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;[LFoo;"), is(answer));
+                }
+                {
+                        final String answer = "LFoo<LFoo;>;";
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;JZ"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;[I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;[LFoo;"), is(answer));
+                }
+                {
+                        final String answer = "LFoo<LFoo;,LBar;>;";
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;JZ"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;[I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;[LFoo;"), is(answer));
+                }
+        }
+        
+        @Test
+        public void parseArray() {
+                {
+                        final String answer = "[I";
+                        assertThat(Type.parseFirst("[I"), is(answer));
+                        assertThat(Type.parseFirst("[III"), is(answer));
+                        assertThat(Type.parseFirst("[IJZ"), is(answer));
+                        assertThat(Type.parseFirst("[I[I"), is(answer));
+                        assertThat(Type.parseFirst("[ILFoo;"), is(answer));
+                }
+                {
+                        final String answer = "[[I";
+                        assertThat(Type.parseFirst("[[I"), is(answer));
+                        assertThat(Type.parseFirst("[[III"), is(answer));
+                        assertThat(Type.parseFirst("[[IJZ"), is(answer));
+                        assertThat(Type.parseFirst("[[I[I"), is(answer));
+                        assertThat(Type.parseFirst("[[ILFoo;"), is(answer));
+                }
+                {
+                        final String answer = "[LFoo;";
+                        assertThat(Type.parseFirst("[LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("[LFoo;II"), is(answer));
+                        assertThat(Type.parseFirst("[LFoo;JZ"), is(answer));
+                        assertThat(Type.parseFirst("[LFoo;[I"), is(answer));
+                        assertThat(Type.parseFirst("[LFoo;LFoo;"), is(answer));
+                }
+        }
+        
+        @Test
+        public void equals() {
+                assertThat(new Type("V"), is(new Type("V")));
+                assertThat(new Type("Z"), is(new Type("Z")));
+                assertThat(new Type("B"), is(new Type("B")));
+                assertThat(new Type("C"), is(new Type("C")));
+                assertThat(new Type("I"), is(new Type("I")));
+                assertThat(new Type("J"), is(new Type("J")));
+                assertThat(new Type("F"), is(new Type("F")));
+                assertThat(new Type("D"), is(new Type("D")));
+                assertThat(new Type("LFoo;"), is(new Type("LFoo;")));
+                assertThat(new Type("[I"), is(new Type("[I")));
+                assertThat(new Type("[[[I"), is(new Type("[[[I")));
+                assertThat(new Type("[LFoo;"), is(new Type("[LFoo;")));
+                assertThat(new Type("LFoo<LBar;>;"), is(new Type("LFoo<LBar;>;")));
+                
+                assertThat(new Type("V"), is(not(new Type("I"))));
+                assertThat(new Type("I"), is(not(new Type("J"))));
+                assertThat(new Type("I"), is(not(new Type("LBar;"))));
+                assertThat(new Type("I"), is(not(new Type("[I"))));
+                assertThat(new Type("LFoo;"), is(not(new Type("LBar;"))));
+                assertThat(new Type("LFoo<LBar;>;"), is(not(new Type("LFoo<LCow;>;"))));
+                assertThat(new Type("[I"), is(not(new Type("[Z"))));
+                assertThat(new Type("[[[I"), is(not(new Type("[I"))));
+                assertThat(new Type("[LFoo;"), is(not(new Type("[LBar;"))));
+        }
+}
diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java
new file mode 100644
index 0000000..a72c2fc
--- /dev/null
+++ b/test/cuchaz/enigma/TokenChecker.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.List;
+import java.util.jar.JarFile;
+
+import com.google.common.collect.Lists;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.SourceIndex;
+import cuchaz.enigma.analysis.Token;
+import cuchaz.enigma.mapping.Entry;
+
+public class TokenChecker {
+        
+        private Deobfuscator m_deobfuscator;
+        
+        protected TokenChecker(JarFile jarFile)
+        throws IOException {
+                m_deobfuscator = new Deobfuscator(jarFile);
+        }
+        
+        protected String getDeclarationToken(Entry entry) {
+                // decompile the class
+                CompilationUnit tree = m_deobfuscator.getSourceTree(entry.getClassName());
+                // DEBUG
+                // tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null );
+                String source = m_deobfuscator.getSource(tree);
+                SourceIndex index = m_deobfuscator.getSourceIndex(tree, source);
+                
+                // get the token value
+                Token token = index.getDeclarationToken(entry);
+                if (token == null) {
+                        return null;
+                }
+                return source.substring(token.start, token.end);
+        }
+        
+        @SuppressWarnings("unchecked")
+        protected Collection<String> getReferenceTokens(EntryReference<? extends Entry,? extends Entry> reference) {
+                // decompile the class
+                CompilationUnit tree = m_deobfuscator.getSourceTree(reference.context.getClassName());
+                String source = m_deobfuscator.getSource(tree);
+                SourceIndex index = m_deobfuscator.getSourceIndex(tree, source);
+                
+                // get the token values
+                List<String> values = Lists.newArrayList();
+                for (Token token : index.getReferenceTokens((EntryReference<Entry,Entry>)reference)) {
+                        values.add(source.substring(token.start, token.end));
+                }
+                return values;
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/Keep.java b/test/cuchaz/enigma/inputs/Keep.java
new file mode 100644
index 0000000..390e82f
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/Keep.java
@@ -0,0 +1,7 @@
+package cuchaz.enigma.inputs;
+
+public class Keep {
+        public static void main(String[] args) {
+                System.out.println("Keep me!");
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/constructors/BaseClass.java b/test/cuchaz/enigma/inputs/constructors/BaseClass.java
new file mode 100644
index 0000000..9345308
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/constructors/BaseClass.java
@@ -0,0 +1,15 @@
+package cuchaz.enigma.inputs.constructors;
+
+// none/a
+public class BaseClass {
+        
+        // <init>()V
+        public BaseClass() {
+                System.out.println("Default constructor");
+        }
+        
+        // <init>(I)V
+        public BaseClass(int i) {
+                System.out.println("Int constructor " + i);
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/constructors/Caller.java b/test/cuchaz/enigma/inputs/constructors/Caller.java
new file mode 100644
index 0000000..5727875
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/constructors/Caller.java
@@ -0,0 +1,47 @@
+package cuchaz.enigma.inputs.constructors;
+
+// none/b
+public class Caller {
+        
+        // a()V
+        public void callBaseDefault() {
+                // none/a.<init>()V
+                System.out.println(new BaseClass());
+        }
+        
+        // b()V
+        public void callBaseInt() {
+                // none/a.<init>(I)V
+                System.out.println(new BaseClass(5));
+        }
+        
+        // c()V
+        public void callSubDefault() {
+                // none/d.<init>()V
+                System.out.println(new SubClass());
+        }
+        
+        // d()V
+        public void callSubInt() {
+                // none/d.<init>(I)V
+                System.out.println(new SubClass(6));
+        }
+        
+        // e()V
+        public void callSubIntInt() {
+                // none/d.<init>(II)V
+                System.out.println(new SubClass(4, 2));
+        }
+        
+        // f()V
+        public void callSubSubInt() {
+                // none/e.<init>(I)V
+                System.out.println(new SubSubClass(3));
+        }
+        
+        // g()V
+        public void callDefaultConstructable() {
+                // none/c.<init>()V
+                System.out.println(new DefaultConstructable());
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java
new file mode 100644
index 0000000..26a3ddb
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java
@@ -0,0 +1,5 @@
+package cuchaz.enigma.inputs.constructors;
+
+public class DefaultConstructable {
+        // only default constructor
+}
diff --git a/test/cuchaz/enigma/inputs/constructors/SubClass.java b/test/cuchaz/enigma/inputs/constructors/SubClass.java
new file mode 100644
index 0000000..fecfa2b
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/constructors/SubClass.java
@@ -0,0 +1,28 @@
+package cuchaz.enigma.inputs.constructors;
+
+// none/d extends none/a
+public class SubClass extends BaseClass {
+        
+        // <init>()V
+        public SubClass() {
+                // none/a.<init>()V
+        }
+        
+        // <init>(I)V
+        public SubClass(int num) {
+                // <init>()V
+                this();
+                System.out.println("SubClass " + num);
+        }
+        
+        // <init>(II)V
+        public SubClass(int a, int b) {
+                // <init>(I)V
+                this(a + b);
+        }
+        
+        // <init>(III)V
+        public SubClass(int a, int b, int c) {
+                // none/a.<init>()V
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java
new file mode 100644
index 0000000..ab84161
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java
@@ -0,0 +1,11 @@
+package cuchaz.enigma.inputs.constructors;
+
+// none/e extends none/d
+public class SubSubClass extends SubClass {
+        
+        // <init>(I)V
+        public SubSubClass(int i) {
+                // none/c.<init>(I)V
+                super(i);
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
new file mode 100644
index 0000000..5b416c4
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
@@ -0,0 +1,21 @@
+package cuchaz.enigma.inputs.inheritanceTree;
+
+// none/a
+public abstract class BaseClass {
+        
+        // a
+        private String m_name;
+        
+        // <init>(Ljava/lang/String;)V
+        protected BaseClass(String name) {
+                m_name = name;
+        }
+        
+        // a()Ljava/lang/String;
+        public String getName() {
+                return m_name;
+        }
+        
+        // a()V
+        public abstract void doBaseThings();
+}
diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java
new file mode 100644
index 0000000..7a99d51
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java
@@ -0,0 +1,11 @@
+package cuchaz.enigma.inputs.inheritanceTree;
+
+// none/b extends none/a
+public abstract class SubclassA extends BaseClass {
+        
+        // <init>(Ljava/lang/String;)V
+        protected SubclassA(String name) {
+                // call to none/a.<init>(Ljava/lang/String)V
+                super(name);
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
new file mode 100644
index 0000000..c9485d3
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
@@ -0,0 +1,30 @@
+package cuchaz.enigma.inputs.inheritanceTree;
+
+// none/c extends none/a
+public class SubclassB extends BaseClass {
+        
+        // a
+        private int m_numThings;
+        
+        // <init>()V
+        protected SubclassB() {
+                // none/a.<init>(Ljava/lang/String;)V
+                super("B");
+                
+                // access to a
+                m_numThings = 4;
+        }
+        
+        @Override
+        // a()V
+        public void doBaseThings() {
+                // call to none/a.a()Ljava/lang/String;
+                System.out.println("Base things by B! " + getName());
+        }
+        
+        // b()V
+        public void doBThings() {
+                // access to a
+                System.out.println("" + m_numThings + " B things!");
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java
new file mode 100644
index 0000000..afd03ac
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java
@@ -0,0 +1,24 @@
+package cuchaz.enigma.inputs.inheritanceTree;
+
+// none/d extends none/b
+public class SubsubclassAA extends SubclassA {
+        
+        protected SubsubclassAA() {
+                // call to none/b.<init>(Ljava/lang/String;)V
+                super("AA");
+        }
+        
+        @Override
+        // a()Ljava/lang/String;
+        public String getName() {
+                // call to none/b.a()Ljava/lang/String;
+                return "subsub" + super.getName();
+        }
+        
+        @Override
+        // a()V
+        public void doBaseThings() {
+                // call to none/d.a()Ljava/lang/String;
+                System.out.println("Base things by " + getName());
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java
new file mode 100644
index 0000000..f7118f6
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java
@@ -0,0 +1,14 @@
+package cuchaz.enigma.inputs.innerClasses;
+
+public class A_Anonymous {
+        
+        public void foo() {
+                Runnable runnable = new Runnable() {
+                        @Override
+                        public void run() {
+                                // don't care
+                        }
+                };
+                runnable.run();
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java b/test/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java
new file mode 100644
index 0000000..42fba9a
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java
@@ -0,0 +1,13 @@
+package cuchaz.enigma.inputs.innerClasses;
+
+public class B_AnonymousWithScopeArgs {
+        
+        public static void foo(final D_Simple arg) {
+                System.out.println(new Object() {
+                        @Override
+                        public String toString() {
+                                return arg.toString();
+                        }
+                });
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java b/test/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java
new file mode 100644
index 0000000..8fa6c5b
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java
@@ -0,0 +1,20 @@
+package cuchaz.enigma.inputs.innerClasses;
+
+@SuppressWarnings("unused")
+public class C_ConstructorArgs {
+        
+        class Inner {
+                
+                private int a;
+                
+                public Inner(int a) {
+                        this.a = a;
+                }
+        }
+        
+        Inner i;
+        
+        public void foo() {
+                i = new Inner(5);
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/innerClasses/D_Simple.java b/test/cuchaz/enigma/inputs/innerClasses/D_Simple.java
new file mode 100644
index 0000000..c4fc0ef
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/innerClasses/D_Simple.java
@@ -0,0 +1,8 @@
+package cuchaz.enigma.inputs.innerClasses;
+
+public class D_Simple {
+        
+        class Inner {
+                // nothing to do
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java b/test/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java
new file mode 100644
index 0000000..e1de53c
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java
@@ -0,0 +1,21 @@
+package cuchaz.enigma.inputs.innerClasses;
+
+public class E_AnonymousWithOuterAccess {
+        
+        // reproduction of error case documented at:
+        // https://bitbucket.org/cuchaz/enigma/issue/61/stackoverflowerror-when-deobfuscating
+        
+        public Object makeInner() {
+                outerMethod();
+                return new Object() {
+                        @Override
+                        public String toString() {
+                                return outerMethod();
+                        }
+                };
+        }
+        
+        private String outerMethod() {
+                return "foo";
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java
new file mode 100644
index 0000000..18c716e
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java
@@ -0,0 +1,14 @@
+package cuchaz.enigma.inputs.loneClass;
+
+public class LoneClass {
+        
+        private String m_name;
+        
+        public LoneClass(String name) {
+                m_name = name;
+        }
+        
+        public String getName() {
+                return m_name;
+        }
+}
diff --git a/test/cuchaz/enigma/inputs/translation/A.java b/test/cuchaz/enigma/inputs/translation/A.java
new file mode 100644
index 0000000..b8aaf11
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/translation/A.java
@@ -0,0 +1,8 @@
+package cuchaz.enigma.inputs.translation;
+
+public class A {
+        
+        public int one;
+        public float two;
+        public String three;
+}
diff --git a/test/cuchaz/enigma/resources/translation.mappings b/test/cuchaz/enigma/resources/translation.mappings
new file mode 100644
index 0000000..70755bf
--- /dev/null
+++ b/test/cuchaz/enigma/resources/translation.mappings
@@ -0,0 +1,4 @@
+CLASS none/a deobf/A
+        FIELD a one
+        FIELD b two
+        FIELD c three
\ No newline at end of file