Remove legacy ASM in favour of Mixin ASM

Mumfrey
1 parent 98dc04c3
Showing 36 changed files with 197 additions and 1213 deletions
build.gradle
src/client/java/com/mumfrey/liteloader/client/transformers/CrashReportTransformer.java
src/main/java/com/mumfrey/liteloader/common/mixin/MixinNetHandlerPlayServer.java
src/main/java/com/mumfrey/liteloader/common/transformers/LiteLoaderPacketTransformer.java
src/main/java/com/mumfrey/liteloader/common/transformers/PacketEvent.java
src/main/java/com/mumfrey/liteloader/core/event/EventProxy.java
src/main/java/com/mumfrey/liteloader/core/event/HandlerList.java
src/main/java/com/mumfrey/liteloader/core/event/IHandlerListDecorator.java
src/main/java/com/mumfrey/liteloader/core/event/ProfilingHandlerList.java
src/main/java/com/mumfrey/liteloader/launch/LiteLoaderTransformer.java
src/main/java/com/mumfrey/liteloader/launch/LiteLoaderTweaker.java
src/main/java/com/mumfrey/liteloader/transformers/ByteCodeUtilities.java
src/main/java/com/mumfrey/liteloader/transformers/CallbackInjectionTransformer.java
src/main/java/com/mumfrey/liteloader/transformers/ClassOverlayTransformer.java
src/main/java/com/mumfrey/liteloader/transformers/ClassTransformer.java
src/main/java/com/mumfrey/liteloader/transformers/IsolatedClassWriter.java
src/main/java/com/mumfrey/liteloader/transformers/event/AccessorTransformer.java
src/main/java/com/mumfrey/liteloader/transformers/event/Event.java
src/main/java/com/mumfrey/liteloader/transformers/event/EventInfo.java
src/main/java/com/mumfrey/liteloader/transformers/event/EventInjectionTransformer.java
@@ -72,7 +72,7 @@ repositories {
 }
  
 dependencies {
-    compile('org.spongepowered:mixin:0.7.3-SNAPSHOT') {
+    compile('org.spongepowered:mixin:0.7.4-SNAPSHOT') {
         exclude module: 'asm-commons'
         exclude module: 'asm-tree'
         exclude module: 'launchwrapper'
@@ -81,6 +81,12 @@ dependencies {
     }
 }
  
+configurations {
+    forgeGradleMcDeps {
+        exclude module: 'asm-debug-all'
+    }
+}
+
 minecraft {
     version = project.mcVersion
     mappings = project.mcMappings
@@ -7,13 +7,13 @@ package com.mumfrey.liteloader.client.transformers;
  
 import java.util.ListIterator;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.VarInsnNode;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.lib.tree.MethodInsnNode;
+import org.spongepowered.asm.lib.tree.MethodNode;
+import org.spongepowered.asm.lib.tree.VarInsnNode;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.transformers.ClassTransformer;
@@ -5,7 +5,7 @@
  */
 package com.mumfrey.liteloader.common.mixin;
  
-import org.objectweb.asm.Opcodes;
+import org.spongepowered.asm.lib.Opcodes;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -5,10 +5,11 @@
  */
 package com.mumfrey.liteloader.common.transformers;
  
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.core.runtime.Packets;
 import com.mumfrey.liteloader.transformers.event.EventInjectionTransformer;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
 import com.mumfrey.liteloader.transformers.event.inject.MethodHead;
  
@@ -8,13 +8,13 @@ package com.mumfrey.liteloader.common.transformers;
 import java.util.HashSet;
 import java.util.Set;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.InsnNode;
-import org.objectweb.asm.tree.IntInsnNode;
-import org.objectweb.asm.tree.LdcInsnNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.VarInsnNode;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.lib.tree.InsnNode;
+import org.spongepowered.asm.lib.tree.IntInsnNode;
+import org.spongepowered.asm.lib.tree.LdcInsnNode;
+import org.spongepowered.asm.lib.tree.MethodInsnNode;
+import org.spongepowered.asm.lib.tree.VarInsnNode;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.core.runtime.Packets;
@@ -9,9 +9,9 @@ import java.util.concurrent.Callable;
  
 import javax.management.RuntimeErrorException;
  
-import org.objectweb.asm.Type;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.util.SignaturePrinter;
  
-import com.mumfrey.liteloader.transformers.ByteCodeUtilities;
 import com.mumfrey.liteloader.transformers.event.EventInfo;
  
 import net.minecraft.crash.CrashReport;
@@ -181,7 +181,7 @@ public final class EventProxy
                 }
                 return false;
             default:
-                tpl.append(ByteCodeUtilities.getTypeName(type));
+                tpl.append(SignaturePrinter.getTypeName(type, false));
                 return false;
         }
     }
@@ -20,26 +20,14 @@ import java.util.List;
 import java.util.Set;
  
 import org.apache.commons.io.FileUtils;
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Label;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.FieldInsnNode;
-import org.objectweb.asm.tree.FieldNode;
-import org.objectweb.asm.tree.InsnNode;
-import org.objectweb.asm.tree.IntInsnNode;
-import org.objectweb.asm.tree.JumpInsnNode;
-import org.objectweb.asm.tree.LabelNode;
-import org.objectweb.asm.tree.LdcInsnNode;
-import org.objectweb.asm.tree.LineNumberNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.TypeInsnNode;
-import org.objectweb.asm.tree.VarInsnNode;
-import org.objectweb.asm.util.CheckClassAdapter;
+import org.spongepowered.asm.lib.ClassReader;
+import org.spongepowered.asm.lib.ClassWriter;
+import org.spongepowered.asm.lib.Label;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.*;
+import org.spongepowered.asm.lib.util.CheckClassAdapter;
+import org.spongepowered.asm.util.Bytecode;
  
 import com.mumfrey.liteloader.Priority;
 import com.mumfrey.liteloader.core.runtime.Obf;
@@ -1008,7 +996,7 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
  
             method.instructions.add(new InsnNode(returnType.getOpcode(Opcodes.IRETURN)));
  
-            int argsSize = ByteCodeUtilities.getArgsSize(args);
+            int argsSize = Bytecode.getFirstNonArgLocalIndex(args, false);
             method.maxLocals = argsSize + 1;
             method.maxStack = argsSize + 1;
         }
@@ -1023,7 +1011,7 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
             boolean isOrOperation = this.logicOp.isOr();
             boolean breakOnMatch = this.logicOp.breakOnMatch();
             int initialValue = isOrOperation && (!this.logicOp.assumeTrue() || this.size > 0) ? Opcodes.ICONST_0 : Opcodes.ICONST_1;
-            int localIndex = ByteCodeUtilities.getArgsSize(args) + 1;
+            int localIndex = Bytecode.getFirstNonArgLocalIndex(args, false) + 1;
  
             method.instructions.add(new InsnNode(initialValue));
             method.instructions.add(new VarInsnNode(Opcodes.ISTORE, localIndex));
@@ -7,9 +7,9 @@ package com.mumfrey.liteloader.core.event;
  
 import java.util.List;
  
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.MethodNode;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.lib.tree.MethodNode;
  
 import com.mumfrey.liteloader.core.event.HandlerList.BakedHandlerList;
 import com.mumfrey.liteloader.core.runtime.Obf;
@@ -9,14 +9,14 @@ import java.lang.reflect.Constructor;
 import java.util.ArrayList;
 import java.util.List;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.InsnNode;
-import org.objectweb.asm.tree.LdcInsnNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.VarInsnNode;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.lib.tree.InsnNode;
+import org.spongepowered.asm.lib.tree.LdcInsnNode;
+import org.spongepowered.asm.lib.tree.MethodInsnNode;
+import org.spongepowered.asm.lib.tree.MethodNode;
+import org.spongepowered.asm.lib.tree.VarInsnNode;
  
 import com.mumfrey.liteloader.api.Listener;
 import com.mumfrey.liteloader.core.runtime.Obf;
@@ -5,11 +5,11 @@
  */
 package com.mumfrey.liteloader.launch;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.FieldNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.lib.tree.FieldNode;
+import org.spongepowered.asm.lib.tree.MethodInsnNode;
+import org.spongepowered.asm.lib.tree.MethodNode;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.transformers.ClassTransformer;
@@ -16,6 +16,7 @@ import java.util.Set;
 import java.util.TreeSet;
  
 import org.spongepowered.asm.launch.MixinBootstrap;
+import org.spongepowered.asm.service.MixinService;
  
 import com.google.common.base.Preconditions;
 import com.mumfrey.liteloader.launch.LoaderEnvironment.EnvironmentType;
@@ -374,7 +375,7 @@ public class LiteLoaderTweaker implements ITweaker
         {
             this.transformerManager.injectDownstreamTransformers(Launch.classLoader);
             this.bootstrap.preBeginGame();
-            MixinBootstrap.addProxy();
+            MixinService.getService().beginPhase();
             StartupState.BEGINGAME.completed();
         }
         catch (Throwable th)
@@ -6,33 +6,15 @@
 package com.mumfrey.liteloader.transformers;
  
 import java.io.IOException;
-import java.lang.annotation.Annotation;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
-
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.AnnotationNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.FieldNode;
-import org.objectweb.asm.tree.FrameNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.LabelNode;
-import org.objectweb.asm.tree.LocalVariableNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.TypeInsnNode;
-import org.objectweb.asm.tree.VarInsnNode;
-import org.objectweb.asm.tree.analysis.Analyzer;
-import org.objectweb.asm.tree.analysis.AnalyzerException;
-import org.objectweb.asm.tree.analysis.BasicValue;
-import org.objectweb.asm.tree.analysis.Frame;
-import org.objectweb.asm.tree.analysis.SimpleVerifier;
+
+import org.spongepowered.asm.lib.ClassReader;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.AnnotationNode;
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.lib.tree.FieldNode;
+import org.spongepowered.asm.lib.tree.MethodNode;
+import org.spongepowered.asm.util.Annotations;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
  
@@ -46,498 +28,8 @@ import net.minecraft.launchwrapper.Launch;
  */
 public abstract class ByteCodeUtilities
 {
-    private static Map<String, List<LocalVariableNode>> calculatedLocalVariables = new HashMap<String, List<LocalVariableNode>>();
-
     private ByteCodeUtilities() {}
-
-    /**
-     * Replace all constructor invocations for the target class in the supplied
-     * classNode with invocations of the replacement class.
-     * 
-     * @param classNode Class to search in
-     * @param target Target type
-     * @param replacement Replacement type
-     */
-    public static void replaceConstructors(ClassNode classNode, Obf target, Obf replacement)
-    {
-        for (MethodNode method : classNode.methods)
-        {
-            ByteCodeUtilities.replaceConstructors(method, target, replacement);
-        }
-    }
-
-    /**
-     * Replace all constructor invocations for the target class in the supplied
-     * method with invocations of the replacement class.
-     * 
-     * @param method Method to look in
-     * @param target Target type
-     * @param replacement Replacement type
-     */
-    public static void replaceConstructors(MethodNode method, Obf target, Obf replacement)
-    {
-        Iterator<AbstractInsnNode> iter = method.instructions.iterator();
-        while (iter.hasNext())
-        {
-            AbstractInsnNode insn = iter.next();
-            if (insn.getOpcode() == Opcodes.NEW)
-            {
-                TypeInsnNode typeInsn = (TypeInsnNode)insn;
-                if (target.obf.equals(typeInsn.desc) || target.ref.equals(typeInsn.desc))
-                {
-                    typeInsn.desc = replacement.ref;
-                }
-            }
-            else if (insn instanceof MethodInsnNode && insn.getOpcode() == Opcodes.INVOKESPECIAL)
-            {
-                MethodInsnNode methodInsn = (MethodInsnNode)insn;
-                if ((target.obf.equals(methodInsn.owner) || target.ref.equals(methodInsn.owner)) && "<init>".equals(methodInsn.name))
-                {
-                    methodInsn.owner = replacement.ref;
-                }
-            }
-        }
-    }
-
-    /**
-     * Injects appropriate LOAD opcodes into the supplied InsnList appropriate
-     * for each entry in the args array starting at pos.
-     * 
-     * @param args Argument types
-     * @param insns Instruction List to inject into
-     * @param pos Start position
-     */
-    public static void loadArgs(Type[] args, InsnList insns, int pos)
-    {
-        ByteCodeUtilities.loadArgs(args, insns, pos, -1);
-    }
-
-    /**
-     * Injects appropriate LOAD opcodes into the supplied InsnList appropriate
-     * for each entry in the args array starting at start and ending at end.
-     * 
-     * @param args Argument types
-     * @param insns Instruction List to inject into
-     * @param start Start position
-     * @param end End position
-     */
-    public static void loadArgs(Type[] args, InsnList insns, int start, int end)
-    {
-        int pos = start;
-
-        for (Type type : args)
-        {
-            insns.add(new VarInsnNode(type.getOpcode(Opcodes.ILOAD), pos));
-            pos += type.getSize();
-            if (end >= start && pos >= end) return;
-        }
-    }
-
-    /**
-     * Injects appropriate LOAD opcodes into the supplied InsnList for each
-     * entry in the supplied locals array starting at pos.
-     * 
-     * @param locals Local types (can contain nulls for uninitialised, TOP, or
-     *      RETURN values in locals)
-     * @param insns Instruction List to inject into
-     * @param pos Start position
-     */
-    public static void loadLocals(Type[] locals, InsnList insns, int pos)
-    {
-        for (; pos < locals.length; pos++)
-        {
-            if (locals[pos] != null)
-            {
-                insns.add(new VarInsnNode(locals[pos].getOpcode(Opcodes.ILOAD), pos));
-            }
-        }
-    }
-
-    /**
-     * Get the first variable index in the supplied method which is not an
-     * argument or "this" reference, this corresponds to the size of the
-     * arguments passed in to the method plus an extra spot for "this" if the
-     * method is non-static. 
-     * 
-     * @param method MethodNode to inspect
-     * @return first available local index which is NOT used by a method
-     *      argument or "this"
-     */
-    public static int getFirstNonArgLocalIndex(MethodNode method)
-    {
-        return ByteCodeUtilities.getFirstNonArgLocalIndex(Type.getArgumentTypes(method.desc), (method.access & Opcodes.ACC_STATIC) == 0);
-    }
-
-    /**
-     * Get the first non-arg variable index based on the supplied arg array and
-     * whether to include the "this" reference, this corresponds to the size of
-     * the arguments passed in to the method plus an extra spot for "this" is
-     * specified.
-     * 
-     * @param args Method arguments
-     * @param includeThis Whether to include a slot for "this" (generally true
-     *      for all non-static methods)
-     * @return first available local index which is NOT used by a method
-     *      argument or "this"
-     */
-    public static int getFirstNonArgLocalIndex(Type[] args, boolean includeThis)
-    {
-        return ByteCodeUtilities.getArgsSize(args) + (includeThis ? 1 : 0);
-    }
-
-    /**
-     * Get the size of the specified args array in local variable terms (eg.
-     * doubles and longs take two spaces).
-     * 
-     * @param args Method argument types as array
-     * @return size of the specified arguments array in terms of stack slots
-     */
-    public static int getArgsSize(Type[] args)
-    {
-        int size = 0;
-
-        for (Type type : args)
-        {
-            size += type.getSize();
-        }
-
-        return size;
-    }
-
-    /**
-     * Attempts to identify available locals at an arbitrary point in the
-     * bytecode specified by node.
-     * 
-     * <p>This method builds an approximate view of the locals available at an
-     * arbitrary point in the bytecode by examining the following features in
-     * the bytecode:</p>
-     * 
-     * <ul>
-     *     <li>Any available stack map frames</li>
-     *     <li>STORE opcodes</li>
-     *     <li>The local variable table</li>
-     * </ul>
-     *  
-     * <p>Inference proceeds by walking the bytecode from the start of the
-     * method looking for stack frames and STORE opcodes. When either of these
-     * is encountered, an attempt is made to cross-reference the values in the
-     * stack map or STORE opcode with the value in the local variable table
-     * which covers the code range. Stack map frames overwrite the entire
-     * simulated local variable table with their own value types, STORE opcodes
-     * overwrite only the local slot to which they pertain. Values in the
-     * simulated locals array are spaced according to their size (unlike the
-     * representation in FrameNode) and this TOP, NULL and UNINTITIALIZED_THIS
-     * opcodes will be represented as null values in the simulated frame.</p>
-     * 
-     * <p>This code does not currently simulate the prescribed JVM behaviour
-     * where overwriting the second slot of a DOUBLE or LONG actually
-     * invalidates the DOUBLE or LONG stored in the previous location, so we
-     * have to hope (for now) that this behaviour isn't emitted by the compiler
-     * or any upstream transformers. I may have to re-think this strategy if
-     * this situation is encountered in the wild.</p> 
-     * 
-     * @param classNode ClassNode containing the method, used to initialise the
-     *      implicit "this" reference in simple methods with no stack frames
-     * @param method MethodNode to explore
-     * @param node Node indicating the position at which to determine the locals
-     *      state. The locals will be enumerated UP TO the specified node, so
-     *      bear in mind that if the specified node is itself a STORE opcode,
-     *      then we will be looking at the state of the locals PRIOR to its
-     *      invocation
-     * @return A sparse array containing a view (hopefully) of the locals at the
-     *      specified location
-     */
-    public static LocalVariableNode[] getLocalsAt(ClassNode classNode, MethodNode method, AbstractInsnNode node)
-    {
-        LocalVariableNode[] frame = new LocalVariableNode[method.maxLocals];
-
-        // Initialise implicit "this" reference in non-static methods
-        if ((method.access & Opcodes.ACC_STATIC) == 0)
-        {
-            frame[0] = new LocalVariableNode("this", classNode.name, null, null, null, 0);
-        }
-
-        for (Iterator<AbstractInsnNode> iter = method.instructions.iterator(); iter.hasNext();)
-        {
-            AbstractInsnNode insn = iter.next();
-            if (insn instanceof FrameNode)
-            {
-                FrameNode frameNode = (FrameNode)insn;
-
-                // localPos tracks the location in the frame node's locals list, which doesn't leave space for TOP entries
-                for (int localPos = 0, framePos = 0; framePos < frame.length; framePos++, localPos++)
-                {
-                    // Get the local at the current position in the FrameNode's locals list
-                    final Object localType = (localPos < frameNode.local.size()) ? frameNode.local.get(localPos) : null;
-
-                    if (localType instanceof String) // String refers to a reference type
-                    {
-                        frame[framePos] = ByteCodeUtilities.getLocalVariableAt(classNode, method, node, framePos);
-                    }
-                    else if (localType instanceof Integer) // Integer refers to a primitive type or other marker
-                    {
-                        boolean isMarkerType = localType == Opcodes.UNINITIALIZED_THIS || localType == Opcodes.TOP || localType == Opcodes.NULL;
-                        boolean is32bitValue = localType == Opcodes.INTEGER || localType == Opcodes.FLOAT;
-                        boolean is64bitValue = localType == Opcodes.DOUBLE || localType == Opcodes.LONG;
-                        if (isMarkerType)
-                        {
-                            frame[framePos] = null;
-                        }
-                        else if (is32bitValue || is64bitValue)
-                        {
-                            frame[framePos] = ByteCodeUtilities.getLocalVariableAt(classNode, method, node, framePos);
-
-                            if (is64bitValue)
-                            {
-                                framePos++;
-                                frame[framePos] = null; // TOP
-                            }
-                        }
-                        else
-                        {
-                            throw new RuntimeException("Unrecognised locals opcode " + localType + " in locals array at position " + localPos + " in "
-                                    + classNode.name + "." + method.name + method.desc);
-                        }
-                    }
-                    else if (localType == null)
-                    {
-                        frame[framePos] = null;
-                    }
-                    else
-                    {
-                        throw new RuntimeException("Invalid value " + localType + " in locals array at position " + localPos + " in " + classNode.name
-                                + "." + method.name + method.desc);
-                    }
-                }
-            }
-            else if (insn instanceof VarInsnNode)
-            {
-                VarInsnNode varNode = (VarInsnNode)insn;
-                frame[varNode.var] = ByteCodeUtilities.getLocalVariableAt(classNode, method, node, varNode.var);
-            }
-            else if (insn == node)
-            {
-                break;
-            }
-        }
-
-        return frame;
-    }
-
-    /**
-     * Attempts to locate the appropriate entry in the local variable table for
-     * the specified local variable index at the location specified by node.
-     * 
-     * @param classNode Containing class
-     * @param method Method
-     * @param node Instruction defining the location to get the local variable
-     *      table at
-     * @param var Local variable index
-     * @return a LocalVariableNode containing information about the local
-     *      variable at the specified location in the specified local slot
-     */
-    public static LocalVariableNode getLocalVariableAt(ClassNode classNode, MethodNode method, AbstractInsnNode node, int var)
-    {
-        LocalVariableNode localVariableNode = null;
-
-        int pos = method.instructions.indexOf(node);
-
-        List<LocalVariableNode> localVariables = ByteCodeUtilities.getLocalVariableTable(classNode, method);
-        for (LocalVariableNode local : localVariables)
-        {
-            if (local.index != var) continue;
-            int start = method.instructions.indexOf(local.start);
-            int end = method.instructions.indexOf(local.end);
-            if (localVariableNode == null || start < pos && end > pos)
-            {
-                localVariableNode = local;
-            }
-        }
-
-        return localVariableNode;
-    }
-
-    /**
-     * Fetches or generates the local variable table for the specified method.
-     * Since Mojang strip the local variable table as part of the obfuscation
-     * process, we need to generate the local variable table when running
-     * obfuscated. We cache the generated tables so that we only need to do the
-     * relatively expensive calculation once per method we encounter.
-     * 
-     * @param classNode Containing class
-     * @param method Method
-     */
-    public static List<LocalVariableNode> getLocalVariableTable(ClassNode classNode, MethodNode method)
-    {
-        if (method.localVariables.isEmpty())
-        {
-            String signature = String.format("%s.%s%s", classNode.name, method.name, method.desc);
-
-            List<LocalVariableNode> localVars = ByteCodeUtilities.calculatedLocalVariables.get(signature);
-            if (localVars != null)
-            {
-                return localVars;
-            }
-
-            localVars = ByteCodeUtilities.generateLocalVariableTable(classNode, method);
-            ByteCodeUtilities.calculatedLocalVariables.put(signature, localVars);
-            return localVars;
-        }
-
-        return method.localVariables;
-    }
-
-    /**
-     * Use ASM Analyzer to generate the local variable table for the specified
-     * method.
-     * 
-     * @param classNode Containing class
-     * @param method Method
-     */
-    public static List<LocalVariableNode> generateLocalVariableTable(ClassNode classNode, MethodNode method)
-    {
-        List<Type> interfaces = null;
-        if (classNode.interfaces != null)
-        {
-            interfaces = new ArrayList<Type>();
-            for (String iface : classNode.interfaces)
-            {
-                interfaces.add(Type.getObjectType(iface));
-            }
-        }
-
-        Type objectType = null;
-        if (classNode.superName != null)
-        {
-            objectType = Type.getObjectType(classNode.superName);
-        }
-
-        // Use Analyzer to generate the bytecode frames
-        Analyzer<BasicValue> analyzer = new Analyzer<BasicValue>(new SimpleVerifier(Type.getObjectType(classNode.name),
-                objectType, interfaces, false));
-        try
-        {
-            analyzer.analyze(classNode.name, method);
-        }
-        catch (AnalyzerException ex)
-        {
-            ex.printStackTrace();
-        }
-
-        // Get frames from the Analyzer
-        Frame<BasicValue>[] frames = analyzer.getFrames();
-
-        // Record the original size of hte method
-        int methodSize = method.instructions.size();
-
-        // List of LocalVariableNodes to return 
-        List<LocalVariableNode> localVariables = new ArrayList<LocalVariableNode>();
-
-        LocalVariableNode[] localNodes = new LocalVariableNode[method.maxLocals]; // LocalVariableNodes for current frame
-        BasicValue[] locals = new BasicValue[method.maxLocals]; // locals in previous frame, used to work out what changes between frames
-        LabelNode[] labels = new LabelNode[methodSize]; // Labels to add to the method, for the markers
-
-        // Traverse the frames and work out when locals begin and end
-        for (int i = 0; i < methodSize; i++)
-        {
-            Frame<BasicValue> f = frames[i];
-            if (f == null) continue;
-            LabelNode label = null;
-
-            for (int j = 0; j < f.getLocals(); j++)
-            {
-                BasicValue local = f.getLocal(j);
-                if (local == null && locals[j] == null) continue;
-                if (local != null && local.equals(locals[j])) continue;
-
-                if (label == null)
-                {
-                    label = new LabelNode();
-                    labels[i] = label;
-                }
-
-                if (local == null && locals[j] != null)
-                {
-                    localVariables.add(localNodes[j]);
-                    localNodes[j].end = label;
-                    localNodes[j] = null;
-                }
-                else if (local != null)
-                {
-                    if (locals[j] != null)
-                    {
-                        localVariables.add(localNodes[j]);
-                        localNodes[j].end = label;
-                        localNodes[j] = null;
-                    }
-
-                    String desc = (local.getType() != null) ? local.getType().getDescriptor() : null;
-                    localNodes[j] = new LocalVariableNode("var" + j, desc, null, label, null, j);
-                }
-
-                locals[j] = local;
-            }
-        }
-
-        // Reached the end of the method so flush all current locals and mark the end
-        LabelNode label = null;
-        for (int k = 0; k < localNodes.length; k++)
-        {
-            if (localNodes[k] != null)
-            {
-                if (label == null)
-                {
-                    label = new LabelNode();
-                    method.instructions.add(label);
-                }
-
-                localNodes[k].end = label;
-                localVariables.add(localNodes[k]);
-            }
-        }
-
-        // Insert generated labels into the method body
-        for (int n = methodSize - 1; n >= 0; n--)
-        {
-            if (labels[n] != null)
-            {
-                method.instructions.insert(method.instructions.get(n), labels[n]);
-            }
-        }
-
-        return localVariables;
-    }
-
-    /**
-     * Get the source code name for the specified type.
-     * 
-     * @param type Type to generate a friendly name for
-     * @return String representation of the specified type, eg "int" for an
-     *      integer primitive or "String" for java.lang.String
-     */
-    public static String getTypeName(Type type)
-    {
-        switch (type.getSort())
-        {
-            case Type.BOOLEAN: return "boolean";
-            case Type.CHAR:    return "char";
-            case Type.BYTE:    return "byte";
-            case Type.SHORT:   return "short";
-            case Type.INT:     return "int";
-            case Type.FLOAT:   return "float";
-            case Type.LONG:    return "long";
-            case Type.DOUBLE:  return "double";
-            case Type.ARRAY:   return ByteCodeUtilities.getTypeName(type.getElementType()) + "[]";
-            case Type.OBJECT:
-                String typeName = type.getClassName();
-                typeName = typeName.substring(typeName.lastIndexOf('.') + 1);
-                return typeName;
-            default:
-                return "Object";
-        }
-
-    }
-
+    
     /**
      * Finds a method in the target class, uses names specified in the
      * {@link Obfuscated} annotation if present.
@@ -555,10 +47,10 @@ public abstract class ByteCodeUtilities
             }
         }
  
-        AnnotationNode obfuscatedAnnotation = ByteCodeUtilities.getVisibleAnnotation(searchFor, Obfuscated.class);
+        AnnotationNode obfuscatedAnnotation = Annotations.getVisible(searchFor, Obfuscated.class);
         if (obfuscatedAnnotation != null)
         {
-            for (String obfuscatedName : ByteCodeUtilities.<List<String>>getAnnotationValue(obfuscatedAnnotation))
+            for (String obfuscatedName : Annotations.<String>getValue(obfuscatedAnnotation, "value", true))
             {
                 for (MethodNode target : targetClass.methods)
                 {
@@ -590,10 +82,10 @@ public abstract class ByteCodeUtilities
             }
         }
  
-        AnnotationNode obfuscatedAnnotation = ByteCodeUtilities.getVisibleAnnotation(searchFor, Obfuscated.class);
+        AnnotationNode obfuscatedAnnotation = Annotations.getVisible(searchFor, Obfuscated.class);
         if (obfuscatedAnnotation != null)
         {
-            for (String obfuscatedName : ByteCodeUtilities.<List<String>>getAnnotationValue(obfuscatedAnnotation))
+            for (String obfuscatedName : Annotations.<String>getValue(obfuscatedAnnotation, "value", true))
             {
                 for (FieldNode target : targetClass.fields)
                 {
@@ -708,107 +200,6 @@ public abstract class ByteCodeUtilities
     }
  
     /**
-     * Get an annotation of the specified class from the supplied field node
-     */
-    public static AnnotationNode getVisibleAnnotation(FieldNode field, Class<? extends Annotation> annotationClass)
-    {
-        return ByteCodeUtilities.getAnnotation(field.visibleAnnotations, Type.getDescriptor(annotationClass));
-    }
-
-    /**
-     * Get an annotation of the specified class from the supplied field node
-     */
-    public static AnnotationNode getInvisibleAnnotation(FieldNode field, Class<? extends Annotation> annotationClass)
-    {
-        return ByteCodeUtilities.getAnnotation(field.invisibleAnnotations, Type.getDescriptor(annotationClass));
-    }
-
-    /**
-     * Get an annotation of the specified class from the supplied method node
-     */
-    public static AnnotationNode getVisibleAnnotation(MethodNode method, Class<? extends Annotation> annotationClass)
-    {
-        return ByteCodeUtilities.getAnnotation(method.visibleAnnotations, Type.getDescriptor(annotationClass));
-    }
-
-    /**
-     * Get an annotation of the specified class from the supplied method node
-     */
-    public static AnnotationNode getInvisibleAnnotation(MethodNode method, Class<? extends Annotation> annotationClass)
-    {
-        return ByteCodeUtilities.getAnnotation(method.invisibleAnnotations, Type.getDescriptor(annotationClass));
-    }
-
-    /**
-     * Get an annotation of the specified class from the supplied class node
-     */
-    public static AnnotationNode getVisibleAnnotation(ClassNode classNode, Class<? extends Annotation> annotationClass)
-    {
-        return ByteCodeUtilities.getAnnotation(classNode.visibleAnnotations, Type.getDescriptor(annotationClass));
-    }
-
-    /**
-     * Get an annotation of the specified class from the supplied class node
-     */
-    public static AnnotationNode getInvisibleAnnotation(ClassNode classNode, Class<? extends Annotation> annotationClass)
-    {
-        return ByteCodeUtilities.getAnnotation(classNode.invisibleAnnotations, Type.getDescriptor(annotationClass));
-    }
-
-    /**
-     * Get an annotation of the specified class from the supplied list of
-     * annotations, returns null if no matching annotation was found
-     */
-    public static AnnotationNode getAnnotation(List<AnnotationNode> annotations, String annotationType)
-    {
-        if (annotations != null)
-        {
-            for (AnnotationNode annotation : annotations)
-            {
-                if (annotationType.equals(annotation.desc))
-                {
-                    return annotation;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Get the value of an annotation node (the value at key "value")
-     * 
-     * @param annotation Annotation node to inspect
-     */
-    public static <T> T getAnnotationValue(AnnotationNode annotation)
-    {
-        return ByteCodeUtilities.getAnnotationValue(annotation, "value");
-    }
-
-    /**
-     * Get the value of an annotation node
-     * 
-     * @param annotation
-     * @param key
-     */
-    @SuppressWarnings("unchecked")
-    public static <T> T getAnnotationValue(AnnotationNode annotation, String key)
-    {
-        if (annotation == null || annotation.values == null)
-        {
-            return null;
-        }
-
-        boolean getNextValue = false;
-        for (Object value : annotation.values)
-        {
-            if (getNextValue) return (T)value;
-            if (value.equals(key)) getNextValue = true;
-        }
-        return null;
-    }
-
-    /**
      * @param returnType
      * @param args
      */
@@ -10,17 +10,17 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.InsnNode;
-import org.objectweb.asm.tree.IntInsnNode;
-import org.objectweb.asm.tree.LdcInsnNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.VarInsnNode;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.lib.tree.InsnNode;
+import org.spongepowered.asm.lib.tree.IntInsnNode;
+import org.spongepowered.asm.lib.tree.LdcInsnNode;
+import org.spongepowered.asm.lib.tree.MethodInsnNode;
+import org.spongepowered.asm.lib.tree.MethodNode;
+import org.spongepowered.asm.lib.tree.VarInsnNode;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.transformers.Callback.CallbackType;
@@ -13,20 +13,20 @@
 //import java.util.Map;
 //import java.util.Set;
 //
-//import org.objectweb.asm.ClassReader;
-//import org.objectweb.asm.ClassWriter;
-//import org.objectweb.asm.Opcodes;
-//import org.objectweb.asm.Type;
-//import org.objectweb.asm.commons.RemappingClassAdapter;
-//import org.objectweb.asm.commons.SimpleRemapper;
-//import org.objectweb.asm.tree.AbstractInsnNode;
-//import org.objectweb.asm.tree.AnnotationNode;
-//import org.objectweb.asm.tree.ClassNode;
-//import org.objectweb.asm.tree.FieldInsnNode;
-//import org.objectweb.asm.tree.FieldNode;
-//import org.objectweb.asm.tree.LineNumberNode;
-//import org.objectweb.asm.tree.MethodInsnNode;
-//import org.objectweb.asm.tree.MethodNode;
+//import org.spongepowered.asm.lib.ClassReader;
+//import org.spongepowered.asm.lib.ClassWriter;
+//import org.spongepowered.asm.lib.Opcodes;
+//import org.spongepowered.asm.lib.Type;
+//import org.spongepowered.asm.lib.commons.RemappingClassAdapter;
+//import org.spongepowered.asm.lib.commons.SimpleRemapper;
+//import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+//import org.spongepowered.asm.lib.tree.AnnotationNode;
+//import org.spongepowered.asm.lib.tree.ClassNode;
+//import org.spongepowered.asm.lib.tree.FieldInsnNode;
+//import org.spongepowered.asm.lib.tree.FieldNode;
+//import org.spongepowered.asm.lib.tree.LineNumberNode;
+//import org.spongepowered.asm.lib.tree.MethodInsnNode;
+//import org.spongepowered.asm.lib.tree.MethodNode;
 //
 //import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
 //
@@ -5,9 +5,9 @@
  */
 package com.mumfrey.liteloader.transformers;
  
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.tree.ClassNode;
+import org.spongepowered.asm.lib.ClassReader;
+import org.spongepowered.asm.lib.ClassWriter;
+import org.spongepowered.asm.lib.tree.ClassNode;
  
 import net.minecraft.launchwrapper.IClassTransformer;
  
@@ -5,8 +5,8 @@
  */
 package com.mumfrey.liteloader.transformers;
  
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.ClassWriter;
+import org.spongepowered.asm.lib.ClassReader;
+import org.spongepowered.asm.lib.ClassWriter;
  
 /**
  * ClassWriter isolated from ASM so that it exists in the LaunchClassLoader
@@ -12,19 +12,11 @@ import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.AnnotationNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.FieldInsnNode;
-import org.objectweb.asm.tree.FieldNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.InsnNode;
-import org.objectweb.asm.tree.LdcInsnNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.TypeInsnNode;
-import org.objectweb.asm.tree.VarInsnNode;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.*;
+import org.spongepowered.asm.util.Annotations;
+import org.spongepowered.asm.util.Bytecode;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.transformers.ByteCodeUtilities;
@@ -83,7 +75,7 @@ abstract class AccessorTransformer extends ClassTransformer
          * @throws IOException Thrown if an problem occurs when loading the
          *      interface bytecode
          */
-        protected AccessorInjection(String iface) throws IOException
+        protected AccessorInjection(String iface) throws IOException, ClassNotFoundException
         {
             this(iface, null);
         }
@@ -95,8 +87,9 @@ abstract class AccessorTransformer extends ClassTransformer
          * @param obfProvider Obfuscation provider for this context
          * @throws IOException Thrown if an problem occurs when loading the
          *      interface bytecode
+         * @throws ClassNotFoundException 
          */
-        protected AccessorInjection(String iface, ObfProvider obfProvider) throws IOException
+        protected AccessorInjection(String iface, ObfProvider obfProvider) throws IOException, ClassNotFoundException
         {
             ClassNode ifaceNode = ByteCodeUtilities.loadClass(iface, false);
  
@@ -173,12 +166,12 @@ abstract class AccessorTransformer extends ClassTransformer
         @SuppressWarnings("unchecked")
         private Class<? extends Obf> setupTable(ClassNode ifaceNode)
         {
-            AnnotationNode annotation = ByteCodeUtilities.getInvisibleAnnotation(ifaceNode, ObfTableClass.class);
+            AnnotationNode annotation = Annotations.getInvisible(ifaceNode, ObfTableClass.class);
             if (annotation != null)
             {
                 try
                 {
-                    Type obfTableType = ByteCodeUtilities.getAnnotationValue(annotation);
+                    Type obfTableType = Annotations.<Type>getValue(annotation);
                     return (Class<? extends Obf>)Class.forName(obfTableType.getClassName(), true, Launch.classLoader);
                 }
                 catch (ClassNotFoundException ex)
@@ -196,14 +189,14 @@ abstract class AccessorTransformer extends ClassTransformer
          */
         private Obf setupTarget(ClassNode ifaceNode)
         {
-            AnnotationNode annotation = ByteCodeUtilities.getInvisibleAnnotation(ifaceNode, Accessor.class);
+            AnnotationNode annotation = Annotations.getInvisible(ifaceNode, Accessor.class);
             if (annotation == null)
             {
                 throw new RuntimeException("Accessor interfaces must be annotated with an @Accessor annotation specifying the target class");
             }
  
-            List<String> targetClass = ByteCodeUtilities.<List<String>>getAnnotationValue(annotation);
-            if (targetClass == null || targetClass.isEmpty())
+            List<String> targetClass = Annotations.<String>getValue(annotation, "value", true);
+            if (targetClass.isEmpty())
             {
                 throw new RuntimeException("Invalid @Accessor annotation, the annotation must specify a target class");
             }
@@ -261,17 +254,17 @@ abstract class AccessorTransformer extends ClassTransformer
             LiteLoaderLogger.debug("[AccessorTransformer] Attempting to add %s to %s", method.name, classNode.name);
  
             List<String> targetId = null;
-            AnnotationNode accessor = ByteCodeUtilities.getInvisibleAnnotation(method, Accessor.class);
-            AnnotationNode invoker = ByteCodeUtilities.getInvisibleAnnotation(method, Invoker.class);
+            AnnotationNode accessor = Annotations.getInvisible(method, Accessor.class);
+            AnnotationNode invoker = Annotations.getInvisible(method, Invoker.class);
             if (accessor != null)
             {
-                targetId = ByteCodeUtilities.<List<String>>getAnnotationValue(accessor);
+                targetId = Annotations.<String>getValue(accessor, "value", true);
                 Obf target = this.getObf(targetId);
                 if (this.injectAccessor(classNode, method, target)) return;
             }
             else if (invoker != null)
             {
-                targetId = ByteCodeUtilities.<List<String>>getAnnotationValue(invoker);
+                targetId = Annotations.<String>getValue(invoker, "value", true);
                 Obf target = this.getObf(targetId);
                 if (this.injectInvoker(classNode, method, target)) return;
             }
@@ -355,7 +348,7 @@ abstract class AccessorTransformer extends ClassTransformer
             boolean isStatic = (field.access & Opcodes.ACC_STATIC) != 0;
  
             method.instructions.clear();
-            method.maxLocals = ByteCodeUtilities.getFirstNonArgLocalIndex(method);
+            method.maxLocals = Bytecode.getFirstNonArgLocalIndex(method);
             method.maxStack = fieldType.getSize();
  
             if (isStatic)
@@ -394,7 +387,7 @@ abstract class AccessorTransformer extends ClassTransformer
             boolean isStatic = (field.access & Opcodes.ACC_STATIC) != 0;
  
             method.instructions.clear();
-            method.maxLocals = ByteCodeUtilities.getFirstNonArgLocalIndex(method);
+            method.maxLocals = Bytecode.getFirstNonArgLocalIndex(method);
             method.maxStack = fieldType.getSize();
  
             if (isStatic)
@@ -426,17 +419,17 @@ abstract class AccessorTransformer extends ClassTransformer
             boolean isStatic = (targetMethod.access & Opcodes.ACC_STATIC) != 0;
  
             method.instructions.clear();
-            method.maxStack = (method.maxLocals = ByteCodeUtilities.getFirstNonArgLocalIndex(method)) + 1;
+            method.maxStack = (method.maxLocals = Bytecode.getFirstNonArgLocalIndex(method)) + 1;
  
             if (isStatic)
             {
-                ByteCodeUtilities.loadArgs(args, method.instructions, 0);
+                Bytecode.loadArgs(args, method.instructions, 0);
                 method.instructions.add(new MethodInsnNode(Opcodes.INVOKESTATIC, classNode.name, targetMethod.name, targetMethod.desc, false));
             }
             else
             {
                 method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
-                ByteCodeUtilities.loadArgs(args, method.instructions, 1);
+                Bytecode.loadArgs(args, method.instructions, 1);
                 method.instructions.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, classNode.name, targetMethod.name, targetMethod.desc, false));
             }
  
@@ -14,25 +14,13 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
  
-import org.objectweb.asm.Label;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.InsnNode;
-import org.objectweb.asm.tree.JumpInsnNode;
-import org.objectweb.asm.tree.LabelNode;
-import org.objectweb.asm.tree.LdcInsnNode;
-import org.objectweb.asm.tree.LineNumberNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.TryCatchBlockNode;
-import org.objectweb.asm.tree.TypeInsnNode;
-import org.objectweb.asm.tree.VarInsnNode;
+import org.spongepowered.asm.lib.Label;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.*;
+import org.spongepowered.asm.util.Bytecode;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
-import com.mumfrey.liteloader.transformers.ByteCodeUtilities;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
  
 /**
@@ -376,7 +364,7 @@ public class Event implements Comparable&lt;Event&gt;
         this.validate(injectionPoint, cancellable, globalEventID);
  
         Type[] arguments = Type.getArgumentTypes(this.method.desc);
-        int initialFrameSize = ByteCodeUtilities.getFirstNonArgLocalIndex(arguments, !this.methodIsStatic);
+        int initialFrameSize = Bytecode.getFirstNonArgLocalIndex(arguments, !this.methodIsStatic);
  
         boolean doCaptureLocals = captureLocals && locals != null && locals.length > initialFrameSize;
         String eventDescriptor = this.generateEventDescriptor(doCaptureLocals, locals, arguments, initialFrameSize);
@@ -413,10 +401,10 @@ public class Event implements Comparable&lt;Event&gt;
  
         // Call the event handler method in the proxy
         insns.add(new VarInsnNode(Opcodes.ALOAD, marshallVar));
-        ByteCodeUtilities.loadArgs(arguments, insns, this.methodIsStatic ? 0 : 1);
+        Bytecode.loadArgs(arguments, insns, this.methodIsStatic ? 0 : 1);
         if (doCaptureLocals)
         {
-            ByteCodeUtilities.loadLocals(locals, insns, initialFrameSize);
+            Bytecode.loadArgs(locals, insns, initialFrameSize);
         }
         insns.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Event.getActiveProxyRef(), handler.name, handler.desc, false));
  
@@ -646,7 +634,7 @@ public class Event implements Comparable&lt;Event&gt;
                         insns.add(lineNumberLabel);
                         insns.add(new LineNumberNode(++lineNumber, lineNumberLabel));
  
-                        ByteCodeUtilities.loadArgs(args, insns, 0);
+                        Bytecode.loadArgs(args, insns, 0);
                         insns.add(new MethodInsnNode(Opcodes.INVOKESTATIC, listener.ownerRef, listener.getOrInflectName(event.name),
                                 handlerMethod.desc, false));
                     }
@@ -5,7 +5,7 @@
  */
 package com.mumfrey.liteloader.transformers.event;
  
-import org.objectweb.asm.Type;
+import org.spongepowered.asm.lib.Type;
  
 import com.mumfrey.liteloader.core.event.Cancellable;
 import com.mumfrey.liteloader.core.event.EventCancellationException;
@@ -5,6 +5,8 @@
  */
 package com.mumfrey.liteloader.transformers.event;
  
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+
 import com.mumfrey.liteloader.transformers.ObfProvider;
  
 import net.minecraft.launchwrapper.IClassTransformer;
@@ -5,10 +5,10 @@
  */
 package com.mumfrey.liteloader.transformers.event;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.InsnNode;
-import org.objectweb.asm.tree.MethodNode;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.lib.tree.InsnNode;
+import org.spongepowered.asm.lib.tree.MethodNode;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.transformers.ClassTransformer;
@@ -17,17 +17,17 @@ import java.util.Set;
 import java.util.TreeSet;
  
 import org.apache.commons.io.FileUtils;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.LocalVariableNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.util.CheckClassAdapter;
+import org.spongepowered.asm.lib.ClassWriter;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.lib.tree.LocalVariableNode;
+import org.spongepowered.asm.lib.tree.MethodNode;
+import org.spongepowered.asm.lib.util.CheckClassAdapter;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
  
 import com.google.common.collect.Maps;
 import com.mumfrey.liteloader.core.runtime.Obf;
-import com.mumfrey.liteloader.transformers.ByteCodeUtilities;
 import com.mumfrey.liteloader.transformers.ClassTransformer;
 import com.mumfrey.liteloader.transformers.ObfProvider;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
@@ -151,16 +151,6 @@ public final class EventTransformer extends ClassTransformer
             return this.captureLocals;
         }
  
-        public void checkCaptureLocals(InjectionPoint injectionPoint)
-        {
-            if (injectionPoint.captureLocals != this.captureLocals)
-            {
-                throw new RuntimeException("Overlapping injection points defined with incompatible settings. Attempting to handle "
-                        + injectionPoint + " with capture locals [" + injectionPoint.captureLocals + "] but already defined injection point with ["
-                        + this.captureLocals + "]");
-            }
-        }
-
         public void add(Event event)
         {
             this.events.add(event);
@@ -328,43 +318,16 @@ public final class EventTransformer extends ClassTransformer
             event.attach(method);
             InjectionPoint injectionPoint = eventEntry.getValue();
             nodes.clear();
-            if (injectionPoint.find(method.desc, insns, nodes, event))
+            if (injectionPoint.find(method.desc, insns, nodes))
             {
                 for (AbstractInsnNode node : nodes)
                 {
                     Injection injection = injectionPoints.get(node);
                     if (injection == null)
                     {
-                        injection = new Injection(node, injectionPoint.captureLocals());
+                        injection = new Injection(node, false);
                         injectionPoints.put(node, injection);
                     }
-                    else
-                    {
-                        injection.checkCaptureLocals(injectionPoint);
-                    }
-
-                    if (injectionPoint.captureLocals() && !injection.hasLocals())
-                    {
-                        LocalVariableNode[] locals = ByteCodeUtilities.getLocalsAt(classNode, method, node);
-                        injection.setLocals(locals);
-                        if (injectionPoint.logLocals())
-                        {
-                            int startPos = ByteCodeUtilities.getFirstNonArgLocalIndex(method);
-
-                            LiteLoaderLogger.debug(ClassTransformer.HORIZONTAL_RULE);
-                            LiteLoaderLogger.debug("Logging local variables for " + injectionPoint);
-                            for (int i = startPos; i < locals.length; i++)
-                            {
-                                LocalVariableNode local = locals[i];
-                                if (local != null)
-                                {
-                                    LiteLoaderLogger.debug("    Local[%d] %s %s", i, ByteCodeUtilities.getTypeName(Type.getType(local.desc)),
-                                            local.name);
-                                }
-                            }
-                            LiteLoaderLogger.debug(ClassTransformer.HORIZONTAL_RULE);
-                        }
-                    }
  
                     injection.add(event);
                 }
-/*
- * This file is part of LiteLoader.
- * Copyright (C) 2012-16 Adam Mummery-Smith
- * All Rights Reserved.
- */
-package com.mumfrey.liteloader.transformers.event;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.List;
-
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.InsnList;
-
-import com.google.common.base.Joiner;
-
-/**
- * Base class for injection point discovery classes. Each subclass describes a
- * strategy for locating code injection points within a method, with the
- * {@link #find} method populating a collection with insn nodes from the method
- * which satisfy its strategy.
- * 
- * <p>This base class also contains composite strategy factory methods such as
- * {@code and} and {@code or} which allow strategies to be combined using
- * intersection (and) or union (or) relationships to allow multiple strategies
- * to be easily combined.</p>
- * 
- * <p>You are free to create your own injection point subclasses, but take note
- * that it is allowed for a single InjectionPoint instance to be used for
- * multiple injections and thus implementing classes MUST NOT cache the insn
- * list, event, or nodes instance passed to the {@code find} method, as each
- * call to {@code find} must be considered a separate functional contract and
- * the InjectionPoint's lifespan is not linked to the discovery lifespan,
- * therefore it is important that the InjectionPoint implementation is fully
- * STATELESS.</p>
- * 
- * @author Adam Mummery-Smith
- */
-public abstract class InjectionPoint
-{
-    /**
-     * Capture locals as well as args
-     */
-    protected boolean captureLocals;
-
-    protected boolean logLocals;
-
-    /**
-     * Find injection points in the supplied insn list
-     * 
-     * @param desc Method descriptor, supplied to allow return types and
-     *      arguments etc. to be determined
-     * @param insns Insn list to search in, the strategy MUST ONLY add nodes
-     *      from this list to the {@code nodes} collection
-     * @param nodes Collection of nodes to populate. Injectors should NOT make
-     *      any assumptions about the state of this collection and should only
-     *      call add()
-     * @param event Event being injected here, supplied to allow alteration of
-     *      behaviour for specific event configurations (eg. cancellable)
-     * @return true if one or more injection points were found
-     */
-    public abstract boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event);
-
-    /**
-     * Set whether this injection point should capture local variables as well
-     * as method arguments.
-     * 
-     * @param captureLocals
-     * @return this, for fluent interface
-     */
-    public InjectionPoint setCaptureLocals(boolean captureLocals)
-    {
-        this.captureLocals = captureLocals;
-        return this;
-    }
-
-    /**
-     * Get whether capture locals is enabled
-     */
-    public boolean captureLocals()
-    {
-        return this.captureLocals;
-    }
-
-    /**
-     * Since it's virtually impossible to know what locals are available at a
-     * given injection point by reading the source, this method causes the
-     * injection point to dump the locals to the debug log at injection time.
-     * 
-     * @param logLocals
-     * @return this, for fluent interface
-     */
-    public InjectionPoint setLogLocals(boolean logLocals)
-    {
-        this.logLocals = logLocals;
-        return this;
-    }
-
-    /**
-     * Get whether log locals is enabled 
-     */
-    public boolean logLocals()
-    {
-        return this.logLocals;
-    }
-
-    @Override
-    public String toString()
-    {
-        return "InjectionPoint(" + this.getClass().getSimpleName() + ")";
-    }
-
-    /**
-     * Composite injection point
-     * 
-     * @author Adam Mummery-Smith
-     */
-    abstract static class CompositeInjectionPoint extends InjectionPoint
-    {
-        protected final InjectionPoint[] components;
-
-        protected CompositeInjectionPoint(InjectionPoint... components)
-        {
-            if (components == null || components.length < 2)
-            {
-                throw new IllegalArgumentException("Must supply two or more component injection points for composite point!");
-            }
-
-            this.components = components;
-
-            for (InjectionPoint component : this.components)
-            {
-                this.captureLocals |= component.captureLocals;
-                this.logLocals |= component.logLocals;
-            }
-        }
-
-        @Override
-        public String toString()
-        {
-            return "CompositeInjectionPoint(" + this.getClass().getSimpleName() + ")[" + Joiner.on(',').join(this.components) + "]";
-        }
-    }
-
-    static final class Intersection extends InjectionPoint.CompositeInjectionPoint
-    {
-        public Intersection(InjectionPoint... points)
-        {
-            super(points);
-        }
-
-        @Override
-        public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
-        {
-            boolean found = false;
-
-            @SuppressWarnings("unchecked")
-            ArrayList<AbstractInsnNode>[] allNodes = new ArrayList[this.components.length];
-
-            for (int i = 0; i < this.components.length; i++)
-            {
-                allNodes[i] = new ArrayList<AbstractInsnNode>();
-                this.components[i].find(desc, insns, allNodes[i], event);
-            }
-
-            ArrayList<AbstractInsnNode> alpha = allNodes[0];
-            for (int nodeIndex = 0; nodeIndex < alpha.size(); nodeIndex++)
-            {
-                AbstractInsnNode node = alpha.get(nodeIndex);
-                boolean in = true;
-
-                for (int b = 1; b < allNodes.length; b++)
-                {
-                    if (!allNodes[b].contains(node))
-                    {
-                        break;
-                    }
-                }
-
-                if (!in) continue;
-
-                nodes.add(node);
-                found = true;
-            }
-
-            return found;
-        }
-    }
-
-    static final class Union extends InjectionPoint.CompositeInjectionPoint
-    {
-        public Union(InjectionPoint... points)
-        {
-            super(points);
-        }
-
-        @Override
-        public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
-        {
-            LinkedHashSet<AbstractInsnNode> allNodes = new LinkedHashSet<AbstractInsnNode>();
-
-            for (int i = 0; i < this.components.length; i++)
-            {
-                this.components[i].find(desc, insns, allNodes, event);
-            }
-
-            nodes.addAll(allNodes);
-
-            return allNodes.size() > 0;
-        }
-    }
-
-    static final class Shift extends InjectionPoint
-    {
-        private final InjectionPoint input;
-        private final int shift;
-
-        public Shift(InjectionPoint input, int shift)
-        {
-            if (input == null)
-            {
-                throw new IllegalArgumentException("Must supply an input injection point for SHIFT");
-            }
-
-            this.input = input;
-            this.shift = shift;
-        }
-
-        @Override
-        public InjectionPoint setCaptureLocals(boolean captureLocals)
-        {
-            return this.input.setCaptureLocals(captureLocals);
-        }
-
-        @Override
-        public boolean captureLocals()
-        {
-            return this.input.captureLocals();
-        }
-
-        @Override
-        public InjectionPoint setLogLocals(boolean logLocals)
-        {
-            return this.input.setLogLocals(logLocals);
-        }
-
-        @Override
-        public boolean logLocals()
-        {
-            return this.input.logLocals();
-        }
-
-        @Override
-        public String toString()
-        {
-            return "InjectionPoint(" + this.getClass().getSimpleName() + ")[" + this.input + "]";
-        }
-
-        @Override
-        public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
-        {
-            List<AbstractInsnNode> list = (nodes instanceof List) ? (List<AbstractInsnNode>)nodes : new ArrayList<AbstractInsnNode>(nodes); 
-
-            this.input.find(desc, insns, nodes, event);
-
-            for (int i = 0; i < list.size(); i++)
-            {
-                list.set(i, insns.get(insns.indexOf(list.get(i)) + this.shift));
-            }
-
-            if (nodes != list)
-            {
-                nodes.clear();
-                nodes.addAll(list);
-            }
-
-            return nodes.size() > 0;
-        }
-    }
-
-    /**
-     * Returns a composite injection point which returns the intersection of
-     * nodes from all component injection points 
-     * 
-     * @param operands
-     */
-    public static InjectionPoint and(InjectionPoint... operands)
-    {
-        return new InjectionPoint.Intersection(operands);
-    }
-
-    /**
-     * Returns a composite injection point which returns the union of nodes from
-     * all component injection points. 
-     * 
-     * @param operands
-     */
-    public static InjectionPoint or(InjectionPoint... operands)
-    {
-        return new InjectionPoint.Union(operands);
-    }
-
-    /**
-     * Returns an injection point which returns all insns immediately following
-     * insns from the supplied injection point.
-     * 
-     * @param point
-     */
-    public static InjectionPoint after(InjectionPoint point)
-    {
-        return new InjectionPoint.Shift(point, 1);
-    }
-
-    /**
-     * Returns an injection point which returns all insns immediately prior to
-     * insns from the supplied injection point.
-     * 
-     * @param point
-     */
-    public static InjectionPoint before(InjectionPoint point)
-    {
-        return new InjectionPoint.Shift(point, -1);
-    }
-
-    /**
-     * Returns an injection point which returns all insns offset by the
-     * specified "count" from insns from the supplied injection point.
-     * 
-     * @param point
-     */
-    public static InjectionPoint shift(InjectionPoint point, int count)
-    {
-        return new InjectionPoint.Shift(point, count);
-    }
-}
@@ -5,13 +5,13 @@
  */
 //package com.mumfrey.liteloader.transformers.event;
 //
-//import org.objectweb.asm.Opcodes;
-//import org.objectweb.asm.tree.AbstractInsnNode;
-//import org.objectweb.asm.tree.InsnList;
-//import org.objectweb.asm.tree.InsnNode;
-//import org.objectweb.asm.tree.JumpInsnNode;
-//import org.objectweb.asm.tree.MethodInsnNode;
-//import org.objectweb.asm.tree.VarInsnNode;
+//import org.spongepowered.asm.lib.Opcodes;
+//import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+//import org.spongepowered.asm.lib.tree.InsnList;
+//import org.spongepowered.asm.lib.tree.InsnNode;
+//import org.spongepowered.asm.lib.tree.JumpInsnNode;
+//import org.spongepowered.asm.lib.tree.MethodInsnNode;
+//import org.spongepowered.asm.lib.tree.VarInsnNode;
 //
 //public class Jump extends Event
 //{
@@ -7,8 +7,8 @@ package com.mumfrey.liteloader.transformers.event;
  
 import java.util.ListIterator;
  
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.InsnList;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.InsnList;
  
 /**
  * Read-only wrapper for InsnList
@@ -5,7 +5,7 @@
  */
 package com.mumfrey.liteloader.transformers.event;
  
-import org.objectweb.asm.Type;
+import org.spongepowered.asm.lib.Type;
  
 import com.mumfrey.liteloader.core.event.EventCancellationException;
  
@@ -5,8 +5,8 @@
  */
 package com.mumfrey.liteloader.transformers.event.inject;
  
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.FieldInsnNode;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.FieldInsnNode;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
@@ -8,14 +8,13 @@ package com.mumfrey.liteloader.transformers.event.inject;
 import java.util.Collection;
 import java.util.ListIterator;
  
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.FieldInsnNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.MethodInsnNode;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.FieldInsnNode;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.lib.tree.MethodInsnNode;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
  
 import com.mumfrey.liteloader.transformers.ClassTransformer;
-import com.mumfrey.liteloader.transformers.event.Event;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
  
@@ -281,15 +280,8 @@ public class BeforeInvoke extends InjectionPoint
         return this;
     }
  
-    /* (non-Javadoc)
-     * @see com.mumfrey.liteloader.transformers.event.InjectionStrategy
-     *      #findInjectionPoint(java.lang.String,
-     *      org.objectweb.asm.tree.InsnList,
-     *      com.mumfrey.liteloader.transformers.event.Event,
-     *      java.util.Collection)
-     */
     @Override
-    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
+    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes)
     {
         int ordinal = 0;
         boolean found = false;
@@ -8,14 +8,13 @@ package com.mumfrey.liteloader.transformers.event.inject;
 import java.util.Collection;
 import java.util.ListIterator;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.TypeInsnNode;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.lib.tree.TypeInsnNode;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
  
 import com.mumfrey.liteloader.core.runtime.Obf;
-import com.mumfrey.liteloader.transformers.event.Event;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
  
 public class BeforeNew extends InjectionPoint
 {
@@ -50,7 +49,7 @@ public class BeforeNew extends InjectionPoint
     }
  
     @Override
-    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
+    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes)
     {
         boolean found = false;
         int ordinal = 0;
@@ -8,14 +8,12 @@ package com.mumfrey.liteloader.transformers.event.inject;
 import java.util.Collection;
 import java.util.ListIterator;
  
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.InsnNode;
-
-import com.mumfrey.liteloader.transformers.event.Event;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
+import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.lib.Type;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.lib.tree.InsnNode;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
  
 /**
  * An injection point which searches for RETURN opcodes in the supplied method
@@ -38,7 +36,7 @@ public class BeforeReturn extends InjectionPoint
     }
  
     @Override
-    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
+    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes)
     {
         boolean found = false;
         int returnOpcode = Type.getReturnType(desc).getOpcode(Opcodes.IRETURN);
@@ -7,11 +7,10 @@ package com.mumfrey.liteloader.transformers.event.inject;
  
 import java.util.Collection;
  
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.LdcInsnNode;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.lib.tree.LdcInsnNode;
  
-import com.mumfrey.liteloader.transformers.event.Event;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
  
@@ -49,11 +48,11 @@ public class BeforeStringInvoke extends BeforeInvoke
     }
  
     @Override
-    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
+    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes)
     {
         this.foundLdc = false;
  
-        return super.find(desc, insns, nodes, event);
+        return super.find(desc, insns, nodes);
     }
  
     @Override
@@ -8,12 +8,10 @@ package com.mumfrey.liteloader.transformers.event.inject;
 import java.util.Collection;
 import java.util.ListIterator;
  
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.JumpInsnNode;
-
-import com.mumfrey.liteloader.transformers.event.Event;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.lib.tree.JumpInsnNode;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
  
 /**
  * An injection point which searches for JUMP opcodes (if, try/catch, continue,
@@ -47,7 +45,7 @@ public class JumpInsnPoint extends InjectionPoint
     }
  
     @Override
-    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
+    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes)
     {
         boolean found = false;
         int ordinal = 0;
@@ -7,11 +7,9 @@ package com.mumfrey.liteloader.transformers.event.inject;
  
 import java.util.Collection;
  
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.InsnList;
-
-import com.mumfrey.liteloader.transformers.event.Event;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
+import org.spongepowered.asm.lib.tree.AbstractInsnNode;
+import org.spongepowered.asm.lib.tree.InsnList;
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
  
 /**
  * An injection point which locates the first instruction in a method body
@@ -25,7 +23,7 @@ public class MethodHead extends InjectionPoint
     }
  
     @Override
-    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes, Event event)
+    public boolean find(String desc, InsnList insns, Collection<AbstractInsnNode> nodes)
     {
         nodes.add(insns.getFirst());
         return true;
@@ -9,9 +9,10 @@ import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
  
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+
 import com.google.gson.annotations.SerializedName;
 import com.mumfrey.liteloader.transformers.event.Event;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
  
 /**
@@ -8,8 +8,9 @@ package com.mumfrey.liteloader.transformers.event.json;
 import java.io.Serializable;
 import java.lang.reflect.Constructor;
  
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+
 import com.google.gson.annotations.SerializedName;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
 import com.mumfrey.liteloader.transformers.event.inject.BeforeInvoke;
 import com.mumfrey.liteloader.transformers.event.inject.BeforeReturn;
@@ -5,11 +5,12 @@
  */
 package com.mumfrey.liteloader.transformers.event.json;
  
+import org.spongepowered.asm.mixin.injection.InjectionPoint;
+
 import com.mumfrey.liteloader.transformers.ClassTransformer;
 import com.mumfrey.liteloader.transformers.ObfProvider;
 import com.mumfrey.liteloader.transformers.event.Event;
 import com.mumfrey.liteloader.transformers.event.EventInjectionTransformer;
-import com.mumfrey.liteloader.transformers.event.InjectionPoint;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
 import com.mumfrey.liteloader.transformers.event.json.ModEvents.ModEventDefinition;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;