diff --git a/Sigil/Emit.ArgumentList.cs b/Sigil/Emit.ArgumentList.cs
index 0ee1f66..68daa57 100644
--- a/Sigil/Emit.ArgumentList.cs
+++ b/Sigil/Emit.ArgumentList.cs
@@ -23,7 +23,7 @@ public Emit<DelegateType> ArgumentList()
                 throw new InvalidOperationException("ArgumentList can only be called in VarArgs methods");
             }
 
-            UpdateState(OpCodes.Arglist, StackTransition.Push<NativeIntType>().Wrap("ArgumentList"));
+            UpdateState(OpCodes.Arglist, Wrap(StackTransition.Push<NativeIntType>(), "ArgumentList"));
 
             return this;
         }
diff --git a/Sigil/Emit.Arithmetic.cs b/Sigil/Emit.Arithmetic.cs
index a669929..e9fcbeb 100644
--- a/Sigil/Emit.Arithmetic.cs
+++ b/Sigil/Emit.Arithmetic.cs
@@ -42,7 +42,7 @@ private void VerifyAndDoArithmetic(string name, OpCode addOp, bool allowReferenc
                     };
             }
 
-            UpdateState(addOp, transitions.Wrap(name));
+            UpdateState(addOp, Wrap(transitions, name));
         }
 
         /// <summary>
@@ -202,7 +202,7 @@ public Emit<DelegateType> Negate()
                     new StackTransition(new [] { typeof(double) }, new [] { typeof(double) })
                 };
 
-            UpdateState(OpCodes.Neg, transitions.Wrap("Negate"));
+            UpdateState(OpCodes.Neg, Wrap(transitions, "Negate"));
 
             return this;
         }
diff --git a/Sigil/Emit.Bitwise.cs b/Sigil/Emit.Bitwise.cs
index 00e7f14..3a24250 100644
--- a/Sigil/Emit.Bitwise.cs
+++ b/Sigil/Emit.Bitwise.cs
@@ -16,7 +16,7 @@ private void VerifyAndBinaryBitwise(string name, OpCode op)
                     new StackTransition(new [] { typeof(NativeIntType), typeof(NativeIntType) }, new [] { typeof(NativeIntType) }),
                 };
 
-            UpdateState(op, transitions.Wrap(name));
+            UpdateState(op, Wrap(transitions, name));
         }
 
         /// <summary>
@@ -62,7 +62,7 @@ public Emit<DelegateType> Not()
                     new StackTransition(new [] { typeof(NativeIntType) }, new [] { typeof(NativeIntType) }),
                 };
 
-            UpdateState(OpCodes.Not, transitions.Wrap("Not"));
+            UpdateState(OpCodes.Not, Wrap(transitions, "Not"));
 
             return this;
         }
@@ -80,7 +80,7 @@ private void VerifyAndShift(string name, OpCode op)
                     new StackTransition(new [] { typeof(int), typeof(long) }, new [] { typeof(long) })
                 };
 
-            UpdateState(op, transitions.Wrap(name));
+            UpdateState(op, Wrap(transitions, name));
         }
 
         /// <summary>
diff --git a/Sigil/Emit.Box.cs b/Sigil/Emit.Box.cs
index 04bfed6..31bc75c 100644
--- a/Sigil/Emit.Box.cs
+++ b/Sigil/Emit.Box.cs
@@ -41,7 +41,7 @@ public Emit<DelegateType> Box(Type valueType)
                     new StackTransition(new [] { valueType }, new [] { typeof(object) })
                 };
 
-            UpdateState(OpCodes.Box, valueType, transitions.Wrap("Box"));
+            UpdateState(OpCodes.Box, valueType, Wrap(transitions, "Box"));
 
             return this;
         }
diff --git a/Sigil/Emit.Branch.cs b/Sigil/Emit.Branch.cs
index dd01d9c..c2aa974 100644
--- a/Sigil/Emit.Branch.cs
+++ b/Sigil/Emit.Branch.cs
@@ -24,7 +24,7 @@ public Emit<DelegateType> Branch(Label label)
             UnusedLabels.Remove(label);
 
             UpdateOpCodeDelegate update;
-            UpdateState(OpCodes.Br, label, StackTransition.None().Wrap("Branch"), out update);
+            UpdateState(OpCodes.Br, label, Wrap(StackTransition.None(), "Branch"), out update);
 
             CurrentVerifier.Branch(label);
             CheckBranchesAndLabels("Branch", label);
@@ -75,7 +75,7 @@ public Emit<DelegateType> BranchIfEqual(Label label)
             
 
             UpdateOpCodeDelegate update;
-            UpdateState(OpCodes.Beq, label, transitions.Wrap("BranchIfEqual"), out update);
+            UpdateState(OpCodes.Beq, label, Wrap(transitions, "BranchIfEqual"), out update);
 
             CurrentVerifier.Branch(label);
             CheckBranchesAndLabels("BranchIfEqual", label);
@@ -123,7 +123,7 @@ public Emit<DelegateType> UnsignedBranchIfNotEqual(Label label)
                 };
 
             UpdateOpCodeDelegate update;
-            UpdateState(OpCodes.Bne_Un, label, transitions.Wrap("UnsignedBranchIfNotEqual"), out update);
+            UpdateState(OpCodes.Bne_Un, label, Wrap(transitions, "UnsignedBranchIfNotEqual"), out update);
 
             CurrentVerifier.Branch(label);
             CheckBranchesAndLabels("UnsignedBranchIfNotEqual", label);
@@ -150,16 +150,19 @@ public Emit<DelegateType> UnsignedBranchIfNotEqual(string name)
         private TransitionWrapper BranchComparableTransitions(string name)
         {
             return
-                new[]
-                {
-                    new StackTransition(new [] { typeof(int), typeof(int) }, Type.EmptyTypes),
-                    new StackTransition(new [] { typeof(int), typeof(NativeIntType) }, Type.EmptyTypes),
-                    new StackTransition(new [] { typeof(NativeIntType), typeof(int) }, Type.EmptyTypes),
-                    new StackTransition(new [] { typeof(NativeIntType), typeof(NativeIntType) }, Type.EmptyTypes),
-                    new StackTransition(new [] { typeof(long), typeof(long) }, Type.EmptyTypes),
-                    new StackTransition(new [] { typeof(float), typeof(float) }, Type.EmptyTypes),
-                    new StackTransition(new [] { typeof(double), typeof(double) }, Type.EmptyTypes)
-                }.Wrap(name);
+                Wrap(
+                    new[]
+                    {
+                        new StackTransition(new [] { typeof(int), typeof(int) }, Type.EmptyTypes),
+                        new StackTransition(new [] { typeof(int), typeof(NativeIntType) }, Type.EmptyTypes),
+                        new StackTransition(new [] { typeof(NativeIntType), typeof(int) }, Type.EmptyTypes),
+                        new StackTransition(new [] { typeof(NativeIntType), typeof(NativeIntType) }, Type.EmptyTypes),
+                        new StackTransition(new [] { typeof(long), typeof(long) }, Type.EmptyTypes),
+                        new StackTransition(new [] { typeof(float), typeof(float) }, Type.EmptyTypes),
+                        new StackTransition(new [] { typeof(double), typeof(double) }, Type.EmptyTypes)
+                    },
+                    name
+                );
         }
 
         /// <summary>
@@ -525,7 +528,7 @@ public Emit<DelegateType> BranchIfFalse(Label label)
                 };
 
             UpdateOpCodeDelegate update;
-            UpdateState(OpCodes.Brfalse, label, transitions.Wrap("BranchIfFalse"), out update);
+            UpdateState(OpCodes.Brfalse, label, Wrap(transitions, "BranchIfFalse"), out update);
 
             CurrentVerifier.Branch(label);
             CheckBranchesAndLabels("BranchIfFalse", label);
@@ -577,7 +580,7 @@ public Emit<DelegateType> BranchIfTrue(Label label)
                 };
 
             UpdateOpCodeDelegate update;
-            UpdateState(OpCodes.Brtrue, label, transitions.Wrap("BranchIfTrue"), out update);
+            UpdateState(OpCodes.Brtrue, label, Wrap(transitions, "BranchIfTrue"), out update);
 
             CurrentVerifier.Branch(label);
             CheckBranchesAndLabels("BranchIfTrue", label);
diff --git a/Sigil/Emit.Break.cs b/Sigil/Emit.Break.cs
index e9d381b..ecb66be 100644
--- a/Sigil/Emit.Break.cs
+++ b/Sigil/Emit.Break.cs
@@ -10,7 +10,7 @@ public partial class Emit<DelegateType>
         /// </summary>
         public Emit<DelegateType> Break()
         {
-            UpdateState(OpCodes.Break, StackTransition.None().Wrap("Break"));
+            UpdateState(OpCodes.Break, Wrap(StackTransition.None(), "Break"));
 
             return this;
         }
diff --git a/Sigil/Emit.Call.cs b/Sigil/Emit.Call.cs
index f7a6178..ba77d57 100644
--- a/Sigil/Emit.Call.cs
+++ b/Sigil/Emit.Call.cs
@@ -120,7 +120,7 @@ public Emit<DelegateType> Call(MethodInfo method, Type[] arglist = null)
                     };
             }
 
-            UpdateState(OpCodes.Call, method, transitions.Wrap("Call"), firstParamIsThis: firstParamIsThis, arglist: arglist);
+            UpdateState(OpCodes.Call, method, Wrap(transitions, "Call"), firstParamIsThis: firstParamIsThis, arglist: arglist);
 
             return this;
         }
diff --git a/Sigil/Emit.CallIndirect.cs b/Sigil/Emit.CallIndirect.cs
index 7d36327..004596c 100644
--- a/Sigil/Emit.CallIndirect.cs
+++ b/Sigil/Emit.CallIndirect.cs
@@ -388,7 +388,7 @@ public Emit<DelegateType> CallIndirect(CallingConventions callConventions, Type
                 }
             }
 
-            UpdateState(OpCodes.Calli, callConventions, returnType, parameterTypes, transitions.Wrap("CallIndirect"), arglist);
+            UpdateState(OpCodes.Calli, callConventions, returnType, parameterTypes, Wrap(transitions, "CallIndirect"), arglist);
 
             return this;
         }
diff --git a/Sigil/Emit.CallVirtual.cs b/Sigil/Emit.CallVirtual.cs
index 57eb809..7e97f4a 100644
--- a/Sigil/Emit.CallVirtual.cs
+++ b/Sigil/Emit.CallVirtual.cs
@@ -59,7 +59,7 @@ public Emit<DelegateType> CallVirtual(MethodInfo method, Type constrained = null
             // Shove the constrained prefix in if it's supplied
             if (constrained != null)
             {
-                UpdateState(OpCodes.Constrained, constrained, StackTransition.None().Wrap("CallVirtual"));
+                UpdateState(OpCodes.Constrained, constrained, Wrap(StackTransition.None(), "CallVirtual"));
             }
 
             IEnumerable<StackTransition> transitions;
@@ -81,7 +81,7 @@ public Emit<DelegateType> CallVirtual(MethodInfo method, Type constrained = null
                     };
             }
 
-            UpdateState(OpCodes.Callvirt, method, transitions.Wrap("CallVirtual"), arglist: arglist);
+            UpdateState(OpCodes.Callvirt, method, Wrap(transitions, "CallVirtual"), arglist: arglist);
 
             return this;
         }
diff --git a/Sigil/Emit.CastClass.cs b/Sigil/Emit.CastClass.cs
index f9c5af4..a9c0f6d 100644
--- a/Sigil/Emit.CastClass.cs
+++ b/Sigil/Emit.CastClass.cs
@@ -68,7 +68,7 @@ public Emit<DelegateType> CastClass(Type referenceType)
                         new StackTransition(new [] { typeof(object) }, new [] { referenceType }, before: before)
                     };
 
-            UpdateState(OpCodes.Castclass, referenceType, transitions.Wrap("CastClass"));
+            UpdateState(OpCodes.Castclass, referenceType, Wrap(transitions, "CastClass"));
 
             return this;
         }
diff --git a/Sigil/Emit.CheckFinite.cs b/Sigil/Emit.CheckFinite.cs
index 2506763..f83dd1b 100644
--- a/Sigil/Emit.CheckFinite.cs
+++ b/Sigil/Emit.CheckFinite.cs
@@ -20,7 +20,7 @@ public Emit<DelegateType> CheckFinite()
                 };
 
             // ckfinite leaves the value on the stack, oddly enough
-            UpdateState(OpCodes.Ckfinite, transitions.Wrap("CheckFinite"));
+            UpdateState(OpCodes.Ckfinite, Wrap(transitions, "CheckFinite"));
 
             return this;
         }
diff --git a/Sigil/Emit.Compare.cs b/Sigil/Emit.Compare.cs
index 9645c7f..9eaa25f 100644
--- a/Sigil/Emit.Compare.cs
+++ b/Sigil/Emit.Compare.cs
@@ -8,14 +8,17 @@ public partial class Emit<DelegateType>
         private TransitionWrapper ValidateComparable(string method)
         {
             return
-                new[]
-                {
-                    new StackTransition(new [] { typeof(int), typeof(int) }, new [] { typeof(int) }),
-                    new StackTransition(new [] { typeof(NativeIntType), typeof(NativeIntType) }, new [] { typeof(int) }),
-                    new StackTransition(new [] { typeof(long), typeof(long) }, new [] { typeof(int) }),
-                    new StackTransition(new [] { typeof(float), typeof(float) }, new [] { typeof(int) }),
-                    new StackTransition(new [] { typeof(double), typeof(double) }, new [] { typeof(int) }),
-                }.Wrap(method);
+                Wrap(
+                    new[]
+                    {
+                        new StackTransition(new [] { typeof(int), typeof(int) }, new [] { typeof(int) }),
+                        new StackTransition(new [] { typeof(NativeIntType), typeof(NativeIntType) }, new [] { typeof(int) }),
+                        new StackTransition(new [] { typeof(long), typeof(long) }, new [] { typeof(int) }),
+                        new StackTransition(new [] { typeof(float), typeof(float) }, new [] { typeof(int) }),
+                        new StackTransition(new [] { typeof(double), typeof(double) }, new [] { typeof(int) }),
+                    },
+                    method
+                );
         }
 
         /// <summary>
@@ -31,7 +34,7 @@ public Emit<DelegateType> CompareEqual()
                     new StackTransition(new [] { typeof(WildcardType), typeof(WildcardType) }, new [] { typeof(int) })
                 };
 
-            UpdateState(OpCodes.Ceq, transitions.Wrap("CompareEqual"));
+            UpdateState(OpCodes.Ceq, Wrap(transitions, "CompareEqual"));
 
             return this;
         }
diff --git a/Sigil/Emit.Convert.cs b/Sigil/Emit.Convert.cs
index 89bb81b..50b0aab 100644
--- a/Sigil/Emit.Convert.cs
+++ b/Sigil/Emit.Convert.cs
@@ -9,20 +9,23 @@ public partial class Emit<DelegateType>
         private TransitionWrapper CheckConvertible(string method, Type toType)
         {
             return
-                new[]
-                {
-                    new StackTransition(new [] { typeof(int) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(NativeIntType) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(long) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(float) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(double) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType }),
-                    new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType })
+                Wrap(
+                    new[]
+                    {
+                        new StackTransition(new [] { typeof(int) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(NativeIntType) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(long) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(float) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(double) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType }),
+                        new StackTransition(new [] { typeof(AnyPointerType) }, new [] { toType })
                     
-                }.Wrap(method);
+                    },
+                    method
+                );
         }
 
         /// <summary>
diff --git a/Sigil/Emit.CopyBlock.cs b/Sigil/Emit.CopyBlock.cs
index c4659d6..f4f47b5 100644
--- a/Sigil/Emit.CopyBlock.cs
+++ b/Sigil/Emit.CopyBlock.cs
@@ -25,12 +25,12 @@ public Emit<DelegateType> CopyBlock(bool isVolatile = false, int? unaligned = nu
 
             if (isVolatile)
             {
-                UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("CopyBlock"));
+                UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(),"CopyBlock"));
             }
 
             if (unaligned.HasValue)
             {
-                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, StackTransition.None().Wrap("CopyBlock"));
+                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, Wrap(StackTransition.None(), "CopyBlock"));
             }
 
             var transition =
@@ -47,7 +47,7 @@ public Emit<DelegateType> CopyBlock(bool isVolatile = false, int? unaligned = nu
                     new StackTransition(new[] { typeof(int), typeof(byte).MakeByRefType(), typeof(byte).MakeByRefType() }, Type.EmptyTypes)
                 };
 
-            UpdateState(OpCodes.Cpblk, transition.Wrap("CopyBlock"));
+            UpdateState(OpCodes.Cpblk, Wrap(transition, "CopyBlock"));
 
             return this;
         }
diff --git a/Sigil/Emit.CopyObject.cs b/Sigil/Emit.CopyObject.cs
index e903272..d84c0cb 100644
--- a/Sigil/Emit.CopyObject.cs
+++ b/Sigil/Emit.CopyObject.cs
@@ -48,7 +48,7 @@ public Emit<DelegateType> CopyObject(Type valueType)
                     new StackTransition(new [] { valueType.MakeByRefType(), valueType.MakeByRefType() }, Type.EmptyTypes),
                 };
 
-            UpdateState(OpCodes.Cpobj, valueType, transitions.Wrap("CopyObject"));
+            UpdateState(OpCodes.Cpobj, valueType, Wrap(transitions, "CopyObject"));
 
             return this;
         }
diff --git a/Sigil/Emit.Duplicate.cs b/Sigil/Emit.Duplicate.cs
index a2358e9..6dee291 100644
--- a/Sigil/Emit.Duplicate.cs
+++ b/Sigil/Emit.Duplicate.cs
@@ -10,7 +10,7 @@ public partial class Emit<DelegateType>
         /// </summary>
         public Emit<DelegateType> Duplicate()
         {
-            UpdateState(OpCodes.Dup, (new [] { new StackTransition(isDuplicate: true) }).Wrap("Duplicate"));
+            UpdateState(OpCodes.Dup, Wrap(new [] { new StackTransition(isDuplicate: true) }, "Duplicate"));
 
             return this;
         }
diff --git a/Sigil/Emit.InitializeBlock.cs b/Sigil/Emit.InitializeBlock.cs
index fee443f..069e2b2 100644
--- a/Sigil/Emit.InitializeBlock.cs
+++ b/Sigil/Emit.InitializeBlock.cs
@@ -25,12 +25,12 @@ public Emit<DelegateType> InitializeBlock(bool isVolatile = false, int? unaligne
 
             if(isVolatile)
             {
-                UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("InitializeBlock"));
+                UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "InitializeBlock"));
             }
 
             if (unaligned.HasValue)
             {
-                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, StackTransition.None().Wrap("InitializeBlock"));
+                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, Wrap(StackTransition.None(), "InitializeBlock"));
             }
 
             var transition =
@@ -43,7 +43,7 @@ public Emit<DelegateType> InitializeBlock(bool isVolatile = false, int? unaligne
                     new StackTransition(new [] { typeof(int), typeof(NativeIntType), typeof(byte).MakeByRefType() }, Type.EmptyTypes)
                 };
 
-            UpdateState(OpCodes.Initblk, transition.Wrap("InitializeBlock"));
+            UpdateState(OpCodes.Initblk, Wrap(transition, "InitializeBlock"));
 
             return this;
         }
diff --git a/Sigil/Emit.InitializeObject.cs b/Sigil/Emit.InitializeObject.cs
index dcd9a52..daac68b 100644
--- a/Sigil/Emit.InitializeObject.cs
+++ b/Sigil/Emit.InitializeObject.cs
@@ -36,7 +36,7 @@ public Emit<DelegateType> InitializeObject(Type valueType)
                     new StackTransition(new [] { valueType.MakeByRefType() }, Type.EmptyTypes),
                 };
 
-            UpdateState(OpCodes.Initobj, valueType, transitions.Wrap("InitializeObject"));
+            UpdateState(OpCodes.Initobj, valueType, Wrap(transitions, "InitializeObject"));
 
             return this;
         }
diff --git a/Sigil/Emit.IsInstance.cs b/Sigil/Emit.IsInstance.cs
index 1dca34d..aceda1a 100644
--- a/Sigil/Emit.IsInstance.cs
+++ b/Sigil/Emit.IsInstance.cs
@@ -52,7 +52,7 @@ public Emit<DelegateType> IsInstance(Type type)
                     new StackTransition(new[] { typeof(WildcardType) }, new [] { type }, before)
                 };
 
-            UpdateState(OpCodes.Isinst, type, transitions.Wrap("IsInstance"));
+            UpdateState(OpCodes.Isinst, type, Wrap(transitions, "IsInstance"));
 
             return this;
         }
diff --git a/Sigil/Emit.Jump.cs b/Sigil/Emit.Jump.cs
index f8e86ab..6be4c21 100644
--- a/Sigil/Emit.Jump.cs
+++ b/Sigil/Emit.Jump.cs
@@ -55,7 +55,7 @@ public Emit<DelegateType> Jump(MethodInfo method)
                 throw new InvalidOperationException("Jump cannot transfer control from an exception block");
             }
 
-            UpdateState((new [] {new StackTransition(0) }).Wrap("Jump"));
+            UpdateState(Wrap(new[] { new StackTransition(0) }, "Jump"));
 
             for (var i = 0; i < paras.Length; i++)
             {
@@ -68,7 +68,7 @@ public Emit<DelegateType> Jump(MethodInfo method)
                 }
             }
 
-            UpdateState(OpCodes.Jmp, method, StackTransition.None().Wrap("Jump"));
+            UpdateState(OpCodes.Jmp, method, Wrap(StackTransition.None(), "Jump"));
 
             return this;
         }
diff --git a/Sigil/Emit.Leave.cs b/Sigil/Emit.Leave.cs
index 8b1f93d..5854bd5 100644
--- a/Sigil/Emit.Leave.cs
+++ b/Sigil/Emit.Leave.cs
@@ -32,7 +32,7 @@ public Emit<DelegateType> Leave(Label label)
 
             // Note that Leave *always* nuked the stack; nothing survies exiting an exception block
             UpdateOpCodeDelegate update;
-            UpdateState(OpCodes.Leave, label, new[] { new StackTransition(new [] { typeof(PopAllType) }, Type.EmptyTypes) }.Wrap("Leave"), out update);
+            UpdateState(OpCodes.Leave, label, Wrap(new[] { new StackTransition(new [] { typeof(PopAllType) }, Type.EmptyTypes) }, "Leave"), out update);
 
             CheckBranchesAndLabels("Leave", label);
 
diff --git a/Sigil/Emit.LoadArgument.cs b/Sigil/Emit.LoadArgument.cs
index ac77fb8..2de5d23 100644
--- a/Sigil/Emit.LoadArgument.cs
+++ b/Sigil/Emit.LoadArgument.cs
@@ -21,7 +21,7 @@ public Emit<DelegateType> LoadArgument(ushort index)
                 throw new ArgumentException("index must be between 0 and " + (ParameterTypes.Length - 1) + ", inclusive");
             }
 
-            var transitions = StackTransition.Push(ParameterTypes[index]).Wrap("LoadArgument");
+            var transitions = Wrap(StackTransition.Push(ParameterTypes[index]), "LoadArgument");
 
             switch (index)
             {
diff --git a/Sigil/Emit.LoadArgumentAddress.cs b/Sigil/Emit.LoadArgumentAddress.cs
index 18a4fa9..6a13bdb 100644
--- a/Sigil/Emit.LoadArgumentAddress.cs
+++ b/Sigil/Emit.LoadArgumentAddress.cs
@@ -29,7 +29,7 @@ public Emit<DelegateType> LoadArgumentAddress(ushort index)
                     asByte = (byte)index;
                 }
 
-                UpdateState(OpCodes.Ldarga_S, asByte, StackTransition.Push(ParameterTypes[index].MakePointerType()).Wrap("LoadArgumentAddress"));
+                UpdateState(OpCodes.Ldarga_S, asByte, Wrap(StackTransition.Push(ParameterTypes[index].MakePointerType()), "LoadArgumentAddress"));
 
                 return this;
             }
@@ -40,7 +40,7 @@ public Emit<DelegateType> LoadArgumentAddress(ushort index)
                 asShort = (short)index;
             }
 
-            UpdateState(OpCodes.Ldarga, asShort, StackTransition.Push(ParameterTypes[index].MakePointerType()).Wrap("LoadArgumentAddress"));
+            UpdateState(OpCodes.Ldarga, asShort, Wrap(StackTransition.Push(ParameterTypes[index].MakePointerType()), "LoadArgumentAddress"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadConstant.cs b/Sigil/Emit.LoadConstant.cs
index ce76d58..9425cc1 100644
--- a/Sigil/Emit.LoadConstant.cs
+++ b/Sigil/Emit.LoadConstant.cs
@@ -24,16 +24,16 @@ public Emit<DelegateType> LoadConstant(int i)
         {
             switch (i)
             {
-                case -1: UpdateState(OpCodes.Ldc_I4_M1, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 0: UpdateState(OpCodes.Ldc_I4_0, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 1: UpdateState(OpCodes.Ldc_I4_1, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 2: UpdateState(OpCodes.Ldc_I4_2, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 3: UpdateState(OpCodes.Ldc_I4_3, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 4: UpdateState(OpCodes.Ldc_I4_4, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 5: UpdateState(OpCodes.Ldc_I4_5, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 6: UpdateState(OpCodes.Ldc_I4_6, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 7: UpdateState(OpCodes.Ldc_I4_7, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 8: UpdateState(OpCodes.Ldc_I4_8, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
+                case -1: UpdateState(OpCodes.Ldc_I4_M1, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 0: UpdateState(OpCodes.Ldc_I4_0, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 1: UpdateState(OpCodes.Ldc_I4_1, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 2: UpdateState(OpCodes.Ldc_I4_2, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 3: UpdateState(OpCodes.Ldc_I4_3, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 4: UpdateState(OpCodes.Ldc_I4_4, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 5: UpdateState(OpCodes.Ldc_I4_5, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 6: UpdateState(OpCodes.Ldc_I4_6, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 7: UpdateState(OpCodes.Ldc_I4_7, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 8: UpdateState(OpCodes.Ldc_I4_8, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
             }
 
             if (i >= sbyte.MinValue && i <= sbyte.MaxValue)
@@ -44,11 +44,11 @@ public Emit<DelegateType> LoadConstant(int i)
                     asByte = (byte)i;
                 }
 
-                UpdateState(OpCodes.Ldc_I4_S, asByte, StackTransition.Push<int>().Wrap("LoadConstant"));
+                UpdateState(OpCodes.Ldc_I4_S, asByte, Wrap(StackTransition.Push<int>(), "LoadConstant"));
                 return this;
             }
 
-            UpdateState(OpCodes.Ldc_I4, i, StackTransition.Push<int>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldc_I4, i, Wrap(StackTransition.Push<int>(), "LoadConstant"));
 
             return this;
         }
@@ -60,16 +60,16 @@ public Emit<DelegateType> LoadConstant(uint i)
         {
             switch (i)
             {
-                case uint.MaxValue: UpdateState(OpCodes.Ldc_I4_M1, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 0: UpdateState(OpCodes.Ldc_I4_0, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 1: UpdateState(OpCodes.Ldc_I4_1, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 2: UpdateState(OpCodes.Ldc_I4_2, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 3: UpdateState(OpCodes.Ldc_I4_3, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 4: UpdateState(OpCodes.Ldc_I4_4, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 5: UpdateState(OpCodes.Ldc_I4_5, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 6: UpdateState(OpCodes.Ldc_I4_6, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 7: UpdateState(OpCodes.Ldc_I4_7, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
-                case 8: UpdateState(OpCodes.Ldc_I4_8, StackTransition.Push<int>().Wrap("LoadConstant")); return this;
+                case uint.MaxValue: UpdateState(OpCodes.Ldc_I4_M1, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 0: UpdateState(OpCodes.Ldc_I4_0, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 1: UpdateState(OpCodes.Ldc_I4_1, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 2: UpdateState(OpCodes.Ldc_I4_2, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 3: UpdateState(OpCodes.Ldc_I4_3, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 4: UpdateState(OpCodes.Ldc_I4_4, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 5: UpdateState(OpCodes.Ldc_I4_5, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 6: UpdateState(OpCodes.Ldc_I4_6, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 7: UpdateState(OpCodes.Ldc_I4_7, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
+                case 8: UpdateState(OpCodes.Ldc_I4_8, Wrap(StackTransition.Push<int>(), "LoadConstant")); return this;
             }
 
             if (i <= sbyte.MaxValue)
@@ -80,11 +80,11 @@ public Emit<DelegateType> LoadConstant(uint i)
                     asByte = (byte)i;
                 }
 
-                UpdateState(OpCodes.Ldc_I4_S, asByte, StackTransition.Push<int>().Wrap("LoadConstant"));
+                UpdateState(OpCodes.Ldc_I4_S, asByte, Wrap(StackTransition.Push<int>(), "LoadConstant"));
                 return this;
             }
 
-            UpdateState(OpCodes.Ldc_I4, i, StackTransition.Push<int>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldc_I4, i, Wrap(StackTransition.Push<int>(), "LoadConstant"));
 
             return this;
         }
@@ -94,7 +94,7 @@ public Emit<DelegateType> LoadConstant(uint i)
         /// </summary>
         public Emit<DelegateType> LoadConstant(long l)
         {
-            UpdateState(OpCodes.Ldc_I8, l, StackTransition.Push<long>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldc_I8, l, Wrap(StackTransition.Push<long>(), "LoadConstant"));
 
             return this;
         }
@@ -104,7 +104,7 @@ public Emit<DelegateType> LoadConstant(long l)
         /// </summary>
         public Emit<DelegateType> LoadConstant(ulong l)
         {
-            UpdateState(OpCodes.Ldc_I8, l, StackTransition.Push<long>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldc_I8, l, Wrap(StackTransition.Push<long>(), "LoadConstant"));
 
             return this;
         }
@@ -114,7 +114,7 @@ public Emit<DelegateType> LoadConstant(ulong l)
         /// </summary>
         public Emit<DelegateType> LoadConstant(float f)
         {
-            UpdateState(OpCodes.Ldc_R4, f, StackTransition.Push<float>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldc_R4, f, Wrap(StackTransition.Push<float>(), "LoadConstant"));
 
             return this;
         }
@@ -124,7 +124,7 @@ public Emit<DelegateType> LoadConstant(float f)
         /// </summary>
         public Emit<DelegateType> LoadConstant(double d)
         {
-            UpdateState(OpCodes.Ldc_R8, d, StackTransition.Push<double>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldc_R8, d, Wrap(StackTransition.Push<double>(), "LoadConstant"));
 
             return this;
         }
@@ -134,7 +134,7 @@ public Emit<DelegateType> LoadConstant(double d)
         /// </summary>
         public Emit<DelegateType> LoadConstant(string str)
         {
-            UpdateState(OpCodes.Ldstr, str, StackTransition.Push<string>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldstr, str, Wrap(StackTransition.Push<string>(), "LoadConstant"));
 
             return this;
         }
@@ -149,7 +149,7 @@ public Emit<DelegateType> LoadConstant(FieldInfo field)
                 throw new ArgumentNullException("field");
             }
 
-            UpdateState(OpCodes.Ldtoken, field, StackTransition.Push<RuntimeFieldHandle>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldtoken, field, Wrap(StackTransition.Push<RuntimeFieldHandle>(), "LoadConstant"));
 
             return this;
         }
@@ -164,7 +164,7 @@ public Emit<DelegateType> LoadConstant(MethodInfo method)
                 throw new ArgumentNullException("method");
             }
 
-            UpdateState(OpCodes.Ldtoken, method, StackTransition.Push<RuntimeMethodHandle>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldtoken, method, Wrap(StackTransition.Push<RuntimeMethodHandle>(), "LoadConstant"));
 
             return this;
         }
@@ -187,7 +187,7 @@ public Emit<DelegateType> LoadConstant(Type type)
                 throw new ArgumentNullException("type");
             }
 
-            UpdateState(OpCodes.Ldtoken, type, StackTransition.Push<RuntimeTypeHandle>().Wrap("LoadConstant"));
+            UpdateState(OpCodes.Ldtoken, type, Wrap(StackTransition.Push<RuntimeTypeHandle>(), "LoadConstant"));
 
             return this;
         }
@@ -197,7 +197,7 @@ public Emit<DelegateType> LoadConstant(Type type)
         /// </summary>
         public Emit<DelegateType> LoadNull()
         {
-            UpdateState(OpCodes.Ldnull, StackTransition.Push<NullType>().Wrap("LoadNull"));
+            UpdateState(OpCodes.Ldnull, Wrap(StackTransition.Push<NullType>(), "LoadNull"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadElement.cs b/Sigil/Emit.LoadElement.cs
index 813ae26..c85c951 100644
--- a/Sigil/Emit.LoadElement.cs
+++ b/Sigil/Emit.LoadElement.cs
@@ -177,11 +177,11 @@ public Emit<DelegateType> LoadElement(Type elementType)
                         new StackTransition(new [] { typeof(int), arrType }, new [] { elementType }),
                     };
 
-                UpdateState(OpCodes.Ldelem, elementType, transitions.Wrap("LoadElement"));
+                UpdateState(OpCodes.Ldelem, elementType, Wrap(transitions, "LoadElement"));
                 return this;
             }
 
-            UpdateState(instr.Value, transitions.Wrap("LoadElement"));
+            UpdateState(instr.Value, Wrap(transitions, "LoadElement"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadElementAddress.cs b/Sigil/Emit.LoadElementAddress.cs
index b75baae..c524e85 100644
--- a/Sigil/Emit.LoadElementAddress.cs
+++ b/Sigil/Emit.LoadElementAddress.cs
@@ -93,7 +93,7 @@ public Emit<DelegateType> LoadElementAddress(Type elementType)
                     new StackTransition(new [] { TypeOnStack.Get<int>(), TypeOnStack.Get(arrayType) }, new [] { pushToStack })
                 };
 
-            UpdateState(OpCodes.Ldelema, elementType, transitions.Wrap("LoadElementAddress"));
+            UpdateState(OpCodes.Ldelema, elementType, Wrap(transitions, "LoadElementAddress"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadField.cs b/Sigil/Emit.LoadField.cs
index 32ae6c1..3c4aa0f 100644
--- a/Sigil/Emit.LoadField.cs
+++ b/Sigil/Emit.LoadField.cs
@@ -35,12 +35,12 @@ public Emit<DelegateType> LoadField(FieldInfo field, bool? isVolatile = null, in
             {
                 if (useVolatile)
                 {
-                    UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("LoadField"));
+                    UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "LoadField"));
                 }
 
                 if (unaligned.HasValue)
                 {
-                    UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, StackTransition.None().Wrap("LoadField"));
+                    UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, Wrap(StackTransition.None(), "LoadField"));
                 }
 
                 var transitions =
@@ -49,16 +49,16 @@ public Emit<DelegateType> LoadField(FieldInfo field, bool? isVolatile = null, in
                         new StackTransition(new [] { field.DeclaringType }, new [] { field.FieldType })
                     };
 
-                UpdateState(OpCodes.Ldfld, field, transitions.Wrap("LoadField"));
+                UpdateState(OpCodes.Ldfld, field, Wrap(transitions, "LoadField"));
             }
             else
             {
                 if (useVolatile)
                 {
-                    UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("LoadField"));
+                    UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "LoadField"));
                 }
 
-                UpdateState(OpCodes.Ldsfld, field, StackTransition.Push(field.FieldType).Wrap("LoadField"));
+                UpdateState(OpCodes.Ldsfld, field, Wrap(StackTransition.Push(field.FieldType), "LoadField"));
             }
 
             return this;
diff --git a/Sigil/Emit.LoadFieldAddress.cs b/Sigil/Emit.LoadFieldAddress.cs
index 342c675..51c58ab 100644
--- a/Sigil/Emit.LoadFieldAddress.cs
+++ b/Sigil/Emit.LoadFieldAddress.cs
@@ -31,11 +31,11 @@ public Emit<DelegateType> LoadFieldAddress(FieldInfo field)
                         new StackTransition(new [] { field.DeclaringType }, new [] { field.FieldType.MakeByRefType() })
                     };
 
-                UpdateState(OpCodes.Ldflda, field, transitions.Wrap("LoadFieldAddress"));
+                UpdateState(OpCodes.Ldflda, field, Wrap(transitions, "LoadFieldAddress"));
             }
             else
             {
-                UpdateState(OpCodes.Ldsflda, field, StackTransition.Push(field.FieldType.MakeByRefType()).Wrap("LoadFieldAddress"));
+                UpdateState(OpCodes.Ldsflda, field, Wrap(StackTransition.Push(field.FieldType.MakeByRefType()), "LoadFieldAddress"));
             }
 
             return this;
diff --git a/Sigil/Emit.LoadFunctionPointer.cs b/Sigil/Emit.LoadFunctionPointer.cs
index 47c5a55..4570ebf 100644
--- a/Sigil/Emit.LoadFunctionPointer.cs
+++ b/Sigil/Emit.LoadFunctionPointer.cs
@@ -31,7 +31,7 @@ public Emit<DelegateType> LoadFunctionPointer(MethodInfo method)
                     paramList.ToArray()
                 );
 
-            UpdateState(OpCodes.Ldftn, method, (new[] { new StackTransition(new TypeOnStack[0], new[] { type }) }).Wrap("LoadFunctionPointer"));
+            UpdateState(OpCodes.Ldftn, method, Wrap(new[] { new StackTransition(new TypeOnStack[0], new[] { type }) }, "LoadFunctionPointer"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadIndirect.cs b/Sigil/Emit.LoadIndirect.cs
index 239065e..e88bbb2 100644
--- a/Sigil/Emit.LoadIndirect.cs
+++ b/Sigil/Emit.LoadIndirect.cs
@@ -186,15 +186,15 @@ public Emit<DelegateType> LoadIndirect(Type type, bool isVolatile = false, int?
 
             if (isVolatile)
             {
-                UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("LoadIndirect"));
+                UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "LoadIndirect"));
             }
 
             if (unaligned.HasValue)
             {
-                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, StackTransition.None().Wrap("LoadIndirect"));
+                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, Wrap(StackTransition.None(), "LoadIndirect"));
             }
 
-            UpdateState(instr.Value, transitions.Wrap("LoadIndirect"));
+            UpdateState(instr.Value, Wrap(transitions, "LoadIndirect"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadLength.cs b/Sigil/Emit.LoadLength.cs
index faddd0e..e4d63b6 100644
--- a/Sigil/Emit.LoadLength.cs
+++ b/Sigil/Emit.LoadLength.cs
@@ -29,7 +29,7 @@ public Emit<DelegateType> LoadLength(Type elementType)
                     new StackTransition(new [] { elementType.MakeArrayType() }, new [] { typeof(int) })
                 };
 
-            UpdateState(OpCodes.Ldlen, transitions.Wrap("LoadLength"));
+            UpdateState(OpCodes.Ldlen, Wrap(transitions, "LoadLength"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadLocal.cs b/Sigil/Emit.LoadLocal.cs
index e46713f..00e747b 100644
--- a/Sigil/Emit.LoadLocal.cs
+++ b/Sigil/Emit.LoadLocal.cs
@@ -27,19 +27,19 @@ public Emit<DelegateType> LoadLocal(Local local)
 
             switch (local.Index)
             {
-                case 0: UpdateState(OpCodes.Ldloc_0, StackTransition.Push(local.StackType).Wrap("LoadLocal")); return this;
-                case 1: UpdateState(OpCodes.Ldloc_1, StackTransition.Push(local.StackType).Wrap("LoadLocal")); return this;
-                case 2: UpdateState(OpCodes.Ldloc_2, StackTransition.Push(local.StackType).Wrap("LoadLocal")); return this;
-                case 3: UpdateState(OpCodes.Ldloc_3, StackTransition.Push(local.StackType).Wrap("LoadLocal")); return this;
+                case 0: UpdateState(OpCodes.Ldloc_0, Wrap(StackTransition.Push(local.StackType), "LoadLocal")); return this;
+                case 1: UpdateState(OpCodes.Ldloc_1, Wrap(StackTransition.Push(local.StackType), "LoadLocal")); return this;
+                case 2: UpdateState(OpCodes.Ldloc_2, Wrap(StackTransition.Push(local.StackType), "LoadLocal")); return this;
+                case 3: UpdateState(OpCodes.Ldloc_3, Wrap(StackTransition.Push(local.StackType), "LoadLocal")); return this;
             }
 
             if (local.Index >= byte.MinValue && local.Index <= byte.MaxValue)
             {
-                UpdateState(OpCodes.Ldloc_S, (byte)local.Index, StackTransition.Push(local.StackType).Wrap("LoadLocal"));
+                UpdateState(OpCodes.Ldloc_S, (byte)local.Index, Wrap(StackTransition.Push(local.StackType), "LoadLocal"));
                 return this;
             }
 
-            UpdateState(OpCodes.Ldloc, local, StackTransition.Push(local.StackType).Wrap("LoadLocal"));
+            UpdateState(OpCodes.Ldloc, local, Wrap(StackTransition.Push(local.StackType), "LoadLocal"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadLocalAddress.cs b/Sigil/Emit.LoadLocalAddress.cs
index 96f5532..d45bf61 100644
--- a/Sigil/Emit.LoadLocalAddress.cs
+++ b/Sigil/Emit.LoadLocalAddress.cs
@@ -37,7 +37,7 @@ public Emit<DelegateType> LoadLocalAddress(Local local)
                     asByte = (byte)local.Index;
                 }
 
-                UpdateState(OpCodes.Ldloca_S, asByte, StackTransition.Push(ptrType).Wrap("LoadLocalAddress"));
+                UpdateState(OpCodes.Ldloca_S, asByte, Wrap(StackTransition.Push(ptrType), "LoadLocalAddress"));
                 return this;
             }
 
@@ -47,7 +47,7 @@ public Emit<DelegateType> LoadLocalAddress(Local local)
                 asShort = (short)local.Index;
             }
 
-            UpdateState(OpCodes.Ldloca, asShort, StackTransition.Push(ptrType).Wrap("LoadLocalAddress"));
+            UpdateState(OpCodes.Ldloca, asShort, Wrap(StackTransition.Push(ptrType), "LoadLocalAddress"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadObject.cs b/Sigil/Emit.LoadObject.cs
index 2401fc5..f4d36eb 100644
--- a/Sigil/Emit.LoadObject.cs
+++ b/Sigil/Emit.LoadObject.cs
@@ -41,12 +41,12 @@ public Emit<DelegateType> LoadObject(Type valueType, bool isVolatile = false, in
 
             if (isVolatile)
             {
-                UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("LoadObject"));
+                UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "LoadObject"));
             }
 
             if (unaligned.HasValue)
             {
-                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, StackTransition.None().Wrap("LoadObject"));
+                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, Wrap(StackTransition.None(), "LoadObject"));
             }
 
             var transitions =
@@ -57,7 +57,7 @@ public Emit<DelegateType> LoadObject(Type valueType, bool isVolatile = false, in
                         new StackTransition(new [] { valueType.MakeByRefType() }, new [] { valueType })
                     };
 
-            UpdateState(OpCodes.Ldobj, valueType, transitions.Wrap("LoadObject"));
+            UpdateState(OpCodes.Ldobj, valueType, Wrap(transitions, "LoadObject"));
 
             return this;
         }
diff --git a/Sigil/Emit.LoadVirtualFunctionPointer.cs b/Sigil/Emit.LoadVirtualFunctionPointer.cs
index 8675489..a3f6d0c 100644
--- a/Sigil/Emit.LoadVirtualFunctionPointer.cs
+++ b/Sigil/Emit.LoadVirtualFunctionPointer.cs
@@ -55,7 +55,7 @@ public Emit<DelegateType> LoadVirtualFunctionPointer(MethodInfo method)
                     new StackTransition(new [] { declaring }, new [] { typeof(NativeIntType) })
                 };
 
-            UpdateState(OpCodes.Ldvirtftn, method, transitions.Wrap("LoadVirtualFunctionPointer"));
+            UpdateState(OpCodes.Ldvirtftn, method, Wrap(transitions, "LoadVirtualFunctionPointer"));
 
             return this;
         }
diff --git a/Sigil/Emit.LocalAllocate.cs b/Sigil/Emit.LocalAllocate.cs
index 0657692..8bdb151 100644
--- a/Sigil/Emit.LocalAllocate.cs
+++ b/Sigil/Emit.LocalAllocate.cs
@@ -30,7 +30,7 @@ public Emit<DelegateType> LocalAllocate()
                 FailUnverifiable("LocalAllocate");
             }
 
-            UpdateState(new[] { new StackTransition(1) }.Wrap("LocalAllocate"));
+            UpdateState(Wrap(new[] { new StackTransition(1) }, "LocalAllocate"));
 
             var transitions =
                 new[] {
@@ -38,7 +38,7 @@ public Emit<DelegateType> LocalAllocate()
                     new StackTransition(new [] { typeof(NativeIntType) }, new [] { typeof(NativeIntType) })
                 };
 
-            UpdateState(OpCodes.Localloc, transitions.Wrap("LocalAllocate"));
+            UpdateState(OpCodes.Localloc, Wrap(transitions, "LocalAllocate"));
 
             return this;
         }
diff --git a/Sigil/Emit.MakeReferenceAny.cs b/Sigil/Emit.MakeReferenceAny.cs
index 0f54e2e..94c4f70 100644
--- a/Sigil/Emit.MakeReferenceAny.cs
+++ b/Sigil/Emit.MakeReferenceAny.cs
@@ -35,7 +35,7 @@ public Emit<DelegateType> MakeReferenceAny(Type type)
                     new StackTransition(new [] { typeof(AnyByRefType) }, new [] { typeof(TypedReference) })
                 };
 
-            UpdateState(OpCodes.Mkrefany, type, transitions.Wrap("MakeReferenceAny"));
+            UpdateState(OpCodes.Mkrefany, type, Wrap(transitions, "MakeReferenceAny"));
 
             return this;
         }
diff --git a/Sigil/Emit.NewArray.cs b/Sigil/Emit.NewArray.cs
index 3289488..306b95e 100644
--- a/Sigil/Emit.NewArray.cs
+++ b/Sigil/Emit.NewArray.cs
@@ -31,7 +31,7 @@ public Emit<DelegateType> NewArray(Type elementType)
                     new StackTransition(new [] { typeof(int) }, new[] { elementType.MakeArrayType() })
                 };
 
-            UpdateState(OpCodes.Newarr, elementType, transitions.Wrap("NewArray"));
+            UpdateState(OpCodes.Newarr, elementType, Wrap(transitions, "NewArray"));
 
             return this;
         }
diff --git a/Sigil/Emit.NewObject.cs b/Sigil/Emit.NewObject.cs
index 6f6f5e9..5f68d22 100644
--- a/Sigil/Emit.NewObject.cs
+++ b/Sigil/Emit.NewObject.cs
@@ -251,7 +251,7 @@ public Emit<DelegateType> NewObject(ConstructorInfo constructor)
                     new StackTransition(expectedParams.AsEnumerable(), new [] { makesType })
                 };
 
-            UpdateState(OpCodes.Newobj, constructor, transitions.Wrap("NewObject"));
+            UpdateState(OpCodes.Newobj, constructor, Wrap(transitions, "NewObject"));
 
             return this;
         }
diff --git a/Sigil/Emit.Nop.cs b/Sigil/Emit.Nop.cs
index 54c56f0..e598e0a 100644
--- a/Sigil/Emit.Nop.cs
+++ b/Sigil/Emit.Nop.cs
@@ -10,7 +10,7 @@ public partial class Emit<DelegateType>
         /// </summary>
         public Emit<DelegateType> Nop()
         {
-            UpdateState(OpCodes.Nop, StackTransition.None().Wrap("Nop"));
+            UpdateState(OpCodes.Nop, Wrap(StackTransition.None(), "Nop"));
 
             return this;
         }
diff --git a/Sigil/Emit.Pop.cs b/Sigil/Emit.Pop.cs
index bc29bbc..8190d78 100644
--- a/Sigil/Emit.Pop.cs
+++ b/Sigil/Emit.Pop.cs
@@ -10,7 +10,7 @@ public partial class Emit<DelegateType>
         /// </summary>
         public Emit<DelegateType> Pop()
         {
-            UpdateState(OpCodes.Pop, StackTransition.Pop<WildcardType>().Wrap("Pop"));
+            UpdateState(OpCodes.Pop, Wrap(StackTransition.Pop<WildcardType>(), "Pop"));
 
             return this;
         }
diff --git a/Sigil/Emit.ReThrow.cs b/Sigil/Emit.ReThrow.cs
index 1087a15..e0f3ffb 100644
--- a/Sigil/Emit.ReThrow.cs
+++ b/Sigil/Emit.ReThrow.cs
@@ -16,7 +16,7 @@ public Emit<DelegateType> ReThrow()
                 throw new InvalidOperationException("ReThrow is only legal in a catch block");
             }
 
-            UpdateState(OpCodes.Rethrow, StackTransition.None().Wrap("ReThrow"));
+            UpdateState(OpCodes.Rethrow, Wrap(StackTransition.None(), "ReThrow"));
 
             return this;
         }
diff --git a/Sigil/Emit.ReferenceAnyType.cs b/Sigil/Emit.ReferenceAnyType.cs
index 3b5c9fa..d0e1f4f 100644
--- a/Sigil/Emit.ReferenceAnyType.cs
+++ b/Sigil/Emit.ReferenceAnyType.cs
@@ -18,7 +18,7 @@ public Emit<DelegateType> ReferenceAnyType()
                     new StackTransition(new[] { typeof(TypedReference) }, new [] { typeof(RuntimeTypeHandle) })
                 };
 
-            UpdateState(OpCodes.Refanytype, transitions.Wrap("ReferenceAnyType"));
+            UpdateState(OpCodes.Refanytype, Wrap(transitions, "ReferenceAnyType"));
 
             return this;
         }
diff --git a/Sigil/Emit.ReferenceAnyValue.cs b/Sigil/Emit.ReferenceAnyValue.cs
index db2ff51..602b3d3 100644
--- a/Sigil/Emit.ReferenceAnyValue.cs
+++ b/Sigil/Emit.ReferenceAnyValue.cs
@@ -34,7 +34,7 @@ public Emit<DelegateType> ReferenceAnyValue(Type type)
                     new StackTransition(new[] { typeof(TypedReference) }, new[] { type.MakeByRefType() })
                 };
 
-            UpdateState(OpCodes.Refanyval, type, transitions.Wrap("ReferenceAnyValue"));
+            UpdateState(OpCodes.Refanyval, type, Wrap(transitions, "ReferenceAnyValue"));
 
             return this;
         }
diff --git a/Sigil/Emit.Return.cs b/Sigil/Emit.Return.cs
index 991196c..ed7d040 100644
--- a/Sigil/Emit.Return.cs
+++ b/Sigil/Emit.Return.cs
@@ -16,9 +16,9 @@ public Emit<DelegateType> Return()
         {
             if (ReturnType == TypeOnStack.Get(typeof(void)))
             {
-                UpdateState((new[] { new StackTransition(0) }).Wrap("Return"));
+                UpdateState(Wrap(new[] { new StackTransition(0) }, "Return"));
 
-                UpdateState(OpCodes.Ret, StackTransition.None().Wrap("Return"));
+                UpdateState(OpCodes.Ret, Wrap(StackTransition.None(), "Return"));
 
                 Returns.Add(IL.Index);
 
@@ -30,11 +30,11 @@ public Emit<DelegateType> Return()
                 return this;
             }
 
-            UpdateState(OpCodes.Ret, StackTransition.Pop(ReturnType).Wrap("Return"));
+            UpdateState(OpCodes.Ret, Wrap(StackTransition.Pop(ReturnType), "Return"));
 
             Returns.Add(IL.Index);
 
-            UpdateState((new[] { new StackTransition(0) }).Wrap("Return"));
+            UpdateState(Wrap(new[] { new StackTransition(0) }, "Return"));
 
             CheckBranchesAndLabels("Return", Labels["__start"]);
 
diff --git a/Sigil/Emit.SizeOf.cs b/Sigil/Emit.SizeOf.cs
index 2d44b91..63724f2 100644
--- a/Sigil/Emit.SizeOf.cs
+++ b/Sigil/Emit.SizeOf.cs
@@ -30,7 +30,7 @@ public Emit<DelegateType> SizeOf(Type valueType)
                 throw new ArgumentException("valueType must be a ValueType");
             }
 
-            UpdateState(OpCodes.Sizeof, valueType, StackTransition.Push<int>().Wrap("SizeOf"));
+            UpdateState(OpCodes.Sizeof, valueType, Wrap(StackTransition.Push<int>(), "SizeOf"));
 
             return this;
         }
diff --git a/Sigil/Emit.StoreArgument.cs b/Sigil/Emit.StoreArgument.cs
index 58756d9..17863e6 100644
--- a/Sigil/Emit.StoreArgument.cs
+++ b/Sigil/Emit.StoreArgument.cs
@@ -29,7 +29,7 @@ public Emit<DelegateType> StoreArgument(ushort index)
                     asByte = (byte)index;
                 }
 
-                UpdateState(OpCodes.Starg_S, asByte, StackTransition.Pop(ParameterTypes[index]).Wrap("StoreArgument"));
+                UpdateState(OpCodes.Starg_S, asByte, Wrap(StackTransition.Pop(ParameterTypes[index]), "StoreArgument"));
                 return this;
             }
 
@@ -39,7 +39,7 @@ public Emit<DelegateType> StoreArgument(ushort index)
                 asShort = (short)index;
             }
 
-            UpdateState(OpCodes.Starg, asShort, StackTransition.Pop(ParameterTypes[index]).Wrap("StoreArgument"));
+            UpdateState(OpCodes.Starg, asShort, Wrap(StackTransition.Pop(ParameterTypes[index]), "StoreArgument"));
 
             return this;
         }
diff --git a/Sigil/Emit.StoreElement.cs b/Sigil/Emit.StoreElement.cs
index c92485a..7bbff8c 100644
--- a/Sigil/Emit.StoreElement.cs
+++ b/Sigil/Emit.StoreElement.cs
@@ -127,11 +127,11 @@ public Emit<DelegateType> StoreElement(Type elementType)
                         new StackTransition(new [] { elementType, typeof(int), arrayType }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stelem, elementType, transitions.Wrap("StoreElement"));
+                UpdateState(OpCodes.Stelem, elementType, Wrap(transitions, "StoreElement"));
                 return this;
             }
 
-            UpdateState(instr.Value, transitions.Wrap("StoreElement"));
+            UpdateState(instr.Value, Wrap(transitions, "StoreElement"));
 
             return this;
         }
diff --git a/Sigil/Emit.StoreField.cs b/Sigil/Emit.StoreField.cs
index 57e4d4c..41f96a3 100644
--- a/Sigil/Emit.StoreField.cs
+++ b/Sigil/Emit.StoreField.cs
@@ -33,12 +33,12 @@ public Emit<DelegateType> StoreField(FieldInfo field, bool isVolatile = false, i
             {
                 if (isVolatile)
                 {
-                    UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("StoreField"));
+                    UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "StoreField"));
                 }
 
                 if (unaligned.HasValue)
                 {
-                    UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, StackTransition.None().Wrap("StoreField"));
+                    UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, Wrap(StackTransition.None(), "StoreField"));
                 }
 
                 var transitions =
@@ -47,13 +47,13 @@ public Emit<DelegateType> StoreField(FieldInfo field, bool isVolatile = false, i
                         new StackTransition(new [] { field.FieldType, field.DeclaringType }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stfld, field, transitions.Wrap("StoreField"));
+                UpdateState(OpCodes.Stfld, field, Wrap(transitions, "StoreField"));
             }
             else
             {
                 if (isVolatile)
                 {
-                    UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("StoreField"));
+                    UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "StoreField"));
                 }
 
                 var transitions =
@@ -62,7 +62,7 @@ public Emit<DelegateType> StoreField(FieldInfo field, bool isVolatile = false, i
                         new StackTransition(new [] { field.FieldType }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stsfld, field, transitions.Wrap("StoreField"));
+                UpdateState(OpCodes.Stsfld, field, Wrap(transitions, "StoreField"));
             }
 
             return this;
diff --git a/Sigil/Emit.StoreIndirect.cs b/Sigil/Emit.StoreIndirect.cs
index 9e1a770..29da1a0 100644
--- a/Sigil/Emit.StoreIndirect.cs
+++ b/Sigil/Emit.StoreIndirect.cs
@@ -31,19 +31,19 @@ public Emit<DelegateType> StoreIndirect(Type type, bool isVolatile = false, int?
 
             if (isVolatile)
             {
-                UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "StoreIndirect"));
             }
 
             if (unaligned.HasValue)
             {
-                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, StackTransition.None().Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, Wrap(StackTransition.None(), "StoreIndirect"));
             }
 
             if (type.IsPointer)
             {
                 var transition = new[] { new StackTransition(new[] { typeof(NativeIntType), typeof(NativeIntType) }, Type.EmptyTypes) };
 
-                UpdateState(OpCodes.Stind_I, transition.Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Stind_I, Wrap(transition, "StoreIndirect"));
                 return this;
             }
 
@@ -57,7 +57,7 @@ public Emit<DelegateType> StoreIndirect(Type type, bool isVolatile = false, int?
                         new StackTransition(new[] { type, typeof(NativeIntType) }, Type.EmptyTypes),
                     };
 
-                UpdateState(OpCodes.Stind_Ref, transition.Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Stind_Ref, Wrap(transition, "StoreIndirect"));
                 return this;
             }
 
@@ -73,7 +73,7 @@ public Emit<DelegateType> StoreIndirect(Type type, bool isVolatile = false, int?
                         new StackTransition(new[] { typeof(int), typeof(NativeIntType) }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stind_I1, transition.Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Stind_I1, Wrap(transition, "StoreIndirect"));
                 return this;
             }
 
@@ -89,7 +89,7 @@ public Emit<DelegateType> StoreIndirect(Type type, bool isVolatile = false, int?
                         new StackTransition(new[] { typeof(int), typeof(NativeIntType) }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stind_I2, transition.Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Stind_I2, Wrap(transition, "StoreIndirect"));
                 return this;
             }
 
@@ -105,7 +105,7 @@ public Emit<DelegateType> StoreIndirect(Type type, bool isVolatile = false, int?
                         new StackTransition(new[] { typeof(int), typeof(NativeIntType) }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stind_I4, transition.Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Stind_I4, Wrap(transition, "StoreIndirect"));
                 return this;
             }
 
@@ -121,7 +121,7 @@ public Emit<DelegateType> StoreIndirect(Type type, bool isVolatile = false, int?
                         new StackTransition(new[] { typeof(long), typeof(NativeIntType) }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stind_I8, transition.Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Stind_I8, Wrap(transition, "StoreIndirect"));
                 return this;
             }
 
@@ -135,7 +135,7 @@ public Emit<DelegateType> StoreIndirect(Type type, bool isVolatile = false, int?
                         new StackTransition(new[] { typeof(float), typeof(NativeIntType) }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stind_R4, transition.Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Stind_R4, Wrap(transition, "StoreIndirect"));
                 return this;
             }
 
@@ -149,7 +149,7 @@ public Emit<DelegateType> StoreIndirect(Type type, bool isVolatile = false, int?
                         new StackTransition(new[] { typeof(double), typeof(NativeIntType) }, Type.EmptyTypes)
                     };
 
-                UpdateState(OpCodes.Stind_R8, transition.Wrap("StoreIndirect"));
+                UpdateState(OpCodes.Stind_R8, Wrap(transition, "StoreIndirect"));
                 return this;
             }
 
diff --git a/Sigil/Emit.StoreLocal.cs b/Sigil/Emit.StoreLocal.cs
index def24c3..1e02c50 100644
--- a/Sigil/Emit.StoreLocal.cs
+++ b/Sigil/Emit.StoreLocal.cs
@@ -27,10 +27,10 @@ public Emit<DelegateType> StoreLocal(Local local)
 
             switch (local.Index)
             {
-                case 0: UpdateState(OpCodes.Stloc_0, StackTransition.Pop(local.StackType).Wrap("StoreLocal")); return this;
-                case 1: UpdateState(OpCodes.Stloc_1, StackTransition.Pop(local.StackType).Wrap("StoreLocal")); return this;
-                case 2: UpdateState(OpCodes.Stloc_2, StackTransition.Pop(local.StackType).Wrap("StoreLocal")); return this;
-                case 3: UpdateState(OpCodes.Stloc_3, StackTransition.Pop(local.StackType).Wrap("StoreLocal")); return this;
+                case 0: UpdateState(OpCodes.Stloc_0, Wrap(StackTransition.Pop(local.StackType), "StoreLocal")); return this;
+                case 1: UpdateState(OpCodes.Stloc_1, Wrap(StackTransition.Pop(local.StackType), "StoreLocal")); return this;
+                case 2: UpdateState(OpCodes.Stloc_2, Wrap(StackTransition.Pop(local.StackType), "StoreLocal")); return this;
+                case 3: UpdateState(OpCodes.Stloc_3, Wrap(StackTransition.Pop(local.StackType), "StoreLocal")); return this;
             }
 
             if (local.Index >= byte.MinValue && local.Index <= byte.MaxValue)
@@ -41,11 +41,11 @@ public Emit<DelegateType> StoreLocal(Local local)
                     asByte = (byte)local.Index;
                 }
 
-                UpdateState(OpCodes.Stloc_S, asByte, StackTransition.Pop(local.StackType).Wrap("StoreLocal"));
+                UpdateState(OpCodes.Stloc_S, asByte, Wrap(StackTransition.Pop(local.StackType), "StoreLocal"));
                 return this;
             }
 
-            UpdateState(OpCodes.Stloc, local, StackTransition.Pop(local.StackType).Wrap("StoreLocal"));
+            UpdateState(OpCodes.Stloc, local, Wrap(StackTransition.Pop(local.StackType), "StoreLocal"));
 
             return this;
         }
diff --git a/Sigil/Emit.StoreObject.cs b/Sigil/Emit.StoreObject.cs
index d382162..4438f87 100644
--- a/Sigil/Emit.StoreObject.cs
+++ b/Sigil/Emit.StoreObject.cs
@@ -41,12 +41,12 @@ public Emit<DelegateType> StoreObject(Type valueType, bool isVolatile = false, i
 
             if (isVolatile)
             {
-                UpdateState(OpCodes.Volatile, StackTransition.None().Wrap("StoreObject"));
+                UpdateState(OpCodes.Volatile, Wrap(StackTransition.None(), "StoreObject"));
             }
 
             if (unaligned.HasValue)
             {
-                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, StackTransition.None().Wrap("StoreObject"));
+                UpdateState(OpCodes.Unaligned, (byte)unaligned.Value, Wrap(StackTransition.None(), "StoreObject"));
             }
 
             var transitions =
@@ -57,7 +57,7 @@ public Emit<DelegateType> StoreObject(Type valueType, bool isVolatile = false, i
                         new StackTransition(new [] { valueType, valueType.MakeByRefType() }, Type.EmptyTypes)
                     };
 
-            UpdateState(OpCodes.Stobj, valueType, transitions.Wrap("StoreObject"));
+            UpdateState(OpCodes.Stobj, valueType, Wrap(transitions, "StoreObject"));
 
             return this;
         }
diff --git a/Sigil/Emit.Switch.cs b/Sigil/Emit.Switch.cs
index b344d4c..c29af6b 100644
--- a/Sigil/Emit.Switch.cs
+++ b/Sigil/Emit.Switch.cs
@@ -46,7 +46,7 @@ public Emit<DelegateType> Switch(params Label[] labels)
             var labelsCopy = ((LinqArray<Label>)labels).Select(l => l).ToArray();
 
             UpdateOpCodeDelegate update;
-            UpdateState(OpCodes.Switch, labelsCopy, transitions.Wrap("Switch"), out update);
+            UpdateState(OpCodes.Switch, labelsCopy, Wrap(transitions, "Switch"), out update);
 
             foreach (var label in labels)
             {
diff --git a/Sigil/Emit.Throw.cs b/Sigil/Emit.Throw.cs
index 28773a0..7304317 100644
--- a/Sigil/Emit.Throw.cs
+++ b/Sigil/Emit.Throw.cs
@@ -13,7 +13,7 @@ public partial class Emit<DelegateType>
         /// </summary>
         public Emit<DelegateType> Throw()
         {
-            UpdateState(OpCodes.Throw, StackTransition.Pop<Exception>().Wrap("Throw"));
+            UpdateState(OpCodes.Throw, Wrap(StackTransition.Pop<Exception>(), "Throw"));
 
             return this;
         }
diff --git a/Sigil/Emit.TryCatchFinally.cs b/Sigil/Emit.TryCatchFinally.cs
index 00febc1..4f54d8f 100644
--- a/Sigil/Emit.TryCatchFinally.cs
+++ b/Sigil/Emit.TryCatchFinally.cs
@@ -15,7 +15,7 @@ public ExceptionBlock BeginExceptionBlock()
                 MarkLabel(DefineLabel(AutoNamer.Next(this, "__autolabel")));
             }
 
-            UpdateState((new[] { new StackTransition(0) }).Wrap("BeginExceptionBlock"));
+            UpdateState(Wrap(new[] { new StackTransition(0) }, "BeginExceptionBlock"));
 
             var labelDel = IL.BeginExceptionBlock();
             var label = new Label(this, labelDel, "__exceptionBlockEnd");
@@ -202,7 +202,7 @@ public CatchBlock BeginCatchBlock(ExceptionBlock forTry, Type exceptionType)
                 MarkLabel(DefineLabel(AutoNamer.Next(this, "__autolabel")));
             }
 
-            UpdateState((new[] { new StackTransition(0) }).Wrap("BeginCatchBlock"));
+            UpdateState(Wrap(new[] { new StackTransition(0) }, "BeginCatchBlock"));
 
             var tryBlock = TryBlocks[forTry];
 
@@ -213,7 +213,7 @@ public CatchBlock BeginCatchBlock(ExceptionBlock forTry, Type exceptionType)
 
             IL.BeginCatchBlock(exceptionType);
 
-            UpdateState(StackTransition.Push(exceptionType).Wrap("BeginCatchBlock"));
+            UpdateState(Wrap(StackTransition.Push(exceptionType), "BeginCatchBlock"));
 
             var ret = new CatchBlock(exceptionType, forTry);
 
@@ -254,7 +254,7 @@ public Emit<DelegateType> EndCatchBlock(CatchBlock forCatch)
                 MarkLabel(DefineLabel(AutoNamer.Next(this, "__autolabel")));
             }
 
-            UpdateState((new[] { new StackTransition(0) }).Wrap("EndCatchBlock"));
+            UpdateState(Wrap(new[] { new StackTransition(0) }, "EndCatchBlock"));
 
             var location = CatchBlocks[forCatch];
 
@@ -325,7 +325,7 @@ public FinallyBlock BeginFinallyBlock(ExceptionBlock forTry)
                 MarkLabel(DefineLabel(AutoNamer.Next(this, "__autolabel")));
             }
 
-            UpdateState((new[] { new StackTransition(0) }).Wrap("BeginFinallyBlock"));
+            UpdateState(Wrap(new[] { new StackTransition(0) }, "BeginFinallyBlock"));
 
             var ret = new FinallyBlock(forTry);
 
@@ -363,7 +363,7 @@ public Emit<DelegateType> EndFinallyBlock(FinallyBlock forFinally)
                 MarkLabel(DefineLabel(AutoNamer.Next(this, "__autolabel")));
             }
 
-            UpdateState((new[] { new StackTransition(0) }).Wrap("EndFinallyBlock"));
+            UpdateState(Wrap(new[] { new StackTransition(0) }, "EndFinallyBlock"));
 
             IL.EndFinallyBlock();
 
diff --git a/Sigil/Emit.Unbox.cs b/Sigil/Emit.Unbox.cs
index bb59dbf..eab6e42 100644
--- a/Sigil/Emit.Unbox.cs
+++ b/Sigil/Emit.Unbox.cs
@@ -40,7 +40,7 @@ public Emit<DelegateType> Unbox(Type valueType)
 
             var transitions = new[] { new StackTransition(new[] { typeof(OnlyObjectType) }, new[] { valueType.MakeByRefType() }) };
 
-            UpdateState(OpCodes.Unbox, valueType, transitions.Wrap("Unbox"));
+            UpdateState(OpCodes.Unbox, valueType, Wrap(transitions, "Unbox"));
 
             return this;
         }
@@ -79,7 +79,7 @@ public Emit<DelegateType> UnboxAny(Type valueType)
 
             var transitions = new[] { new StackTransition(new[] { typeof(OnlyObjectType) }, new[] { valueType }) };
 
-            UpdateState(OpCodes.Unbox_Any, valueType, transitions.Wrap("UnboxAny"));
+            UpdateState(OpCodes.Unbox_Any, valueType, Wrap(transitions, "UnboxAny"));
 
             return this;
         }
diff --git a/Sigil/Emit.cs b/Sigil/Emit.cs
index b91959c..dfd8dba 100644
--- a/Sigil/Emit.cs
+++ b/Sigil/Emit.cs
@@ -431,7 +431,7 @@ private static void ValidateNewParameters<CheckDelegateType>(ValidationOptions v
         {
             var delType = typeof(CheckDelegateType);
 
-            var baseTypes = new HashSet<Type>();
+            var baseTypes = new LinqHashSet<Type>();
             baseTypes.Add(delType);
             var bType = delType.BaseType;
             while (bType != null)
@@ -465,7 +465,7 @@ private static bool AllowsUnverifiableCode(ModuleBuilder m)
             il.Emit(OpCodes.Pop);
             il.Emit(OpCodes.Ret);
 
-            var d1 = (Action)canaryMethod.CreateDelegate(typeof(Action));
+            var d1 = (SigilAction)canaryMethod.CreateDelegate(typeof(SigilAction));
 
             try
             {
@@ -1018,5 +1018,10 @@ private void UpdateState(OpCode instr, CallingConventions callConventions, Type
                 IL.EmitCalli(callConventions, returnType, parameterTypes, arglist);
             }
         }
+
+        private TransitionWrapper Wrap(IEnumerable<StackTransition> trans, string name)
+        {
+            return TransitionWrapper.Get(name, trans);
+        }
     }
 }
diff --git a/Sigil/Impl/ExtensionMethods.cs b/Sigil/Impl/ExtensionMethods.cs
index 6894c59..d6638df 100644
--- a/Sigil/Impl/ExtensionMethods.cs
+++ b/Sigil/Impl/ExtensionMethods.cs
@@ -23,11 +23,6 @@ public static bool StartsWithVowel(string str)
             return "aeiou".IndexOf(c) != -1;
         }
 
-        public static TransitionWrapper Wrap(this IEnumerable<StackTransition> transitions, string method)
-        {
-            return TransitionWrapper.Get(method, transitions);
-        }
-
         public static bool IsVolatile(FieldInfo field)
         {
             // field builder doesn't implement GetRequiredCustomModifiers
diff --git a/Sigil/Impl/LinqAlternative.Collections.cs b/Sigil/Impl/LinqAlternative.Collections.cs
index 39ca8dc..0b1acb1 100644
--- a/Sigil/Impl/LinqAlternative.Collections.cs
+++ b/Sigil/Impl/LinqAlternative.Collections.cs
@@ -274,7 +274,7 @@ internal class LinqList<T> : LinqRoot<T>
             }
         }
 
-        public int Count
+        public new int Count
         {
             get
             {
@@ -346,7 +346,7 @@ public override bool Any(SigilFunc<T, bool> p)
     internal class LinqStack<T> : LinqRoot<T>
         where T : class
     {
-        public int Count { get { return Inner.Count; } }
+        public new int Count { get { return Inner.Count; } }
 
         private Stack<T> Inner;
 
@@ -440,10 +440,29 @@ public override void Each(Action<T> a)
 
     internal class LinqHashSet<T> : LinqRoot<T>
     {
-        //private HashSet<T> Inner;
+        private class Comparer : System.Collections.IEqualityComparer
+        {
+            private IEqualityComparer<T> Inner;
+            public Comparer(IEqualityComparer<T> i) { Inner = i; }
+
+            public new bool Equals(object x, object y)
+            {
+                var xAs = (T)x;
+                var yAs = (T)y;
+
+                return Inner.Equals(xAs, yAs);
+            }
+
+            public int GetHashCode(object obj)
+            {
+                return Inner.GetHashCode((T)obj);
+            }
+        }
+
+
         private System.Collections.Hashtable Inner;
 
-        public int Count { get { return Inner.Count; } }
+        public new int Count { get { return Inner.Count; } }
 
         private LinqHashSet(System.Collections.Hashtable h)
         {
@@ -451,6 +470,7 @@ private LinqHashSet(System.Collections.Hashtable h)
         }
 
         public LinqHashSet() : this(new System.Collections.Hashtable()) { }
+        public LinqHashSet(IEqualityComparer<T> c) : this(new System.Collections.Hashtable(new Comparer(c))) { }
         public LinqHashSet(IEnumerable<T> e) : this() 
         {
             foreach (var x in e)
diff --git a/Sigil/Impl/LinqAlternative.Delegates.cs b/Sigil/Impl/LinqAlternative.Delegates.cs
index 606c9c8..37b76dd 100644
--- a/Sigil/Impl/LinqAlternative.Delegates.cs
+++ b/Sigil/Impl/LinqAlternative.Delegates.cs
@@ -2,6 +2,7 @@
 
 namespace Sigil.Impl
 {
+    internal delegate void SigilAction();
     internal delegate void SigilAction<A, B, C>(A a, B b, C c);
     
     internal delegate R SigilFunc<R>();
diff --git a/Sigil/Impl/LinqAlternative.cs b/Sigil/Impl/LinqAlternative.cs
index a3ad59b..d6f4c6a 100644
--- a/Sigil/Impl/LinqAlternative.cs
+++ b/Sigil/Impl/LinqAlternative.cs
@@ -544,7 +544,7 @@ public static bool Contains<T>( IEnumerable<T> e, T a)
 
         private static IEnumerable<T> _Distinct<T>(IEnumerable<T> e, IEqualityComparer<T> c)
         {
-            var h = new HashSet<T>(c);
+            var h = new LinqHashSet<T>(c);
             using (var i = e.GetEnumerator())
             {
                 while (i.MoveNext())
diff --git a/Sigil/Impl/VerifiableTracker.cs b/Sigil/Impl/VerifiableTracker.cs
index 753e75b..fcee322 100644
--- a/Sigil/Impl/VerifiableTracker.cs
+++ b/Sigil/Impl/VerifiableTracker.cs
@@ -313,7 +313,7 @@ private static void UpdateStack(LinqStack<LinqList<TypeOnStack>> stack, Instruct
             }
 
             var toPush = new LinqList<TypeOnStack>(legalSize);
-            var pushed = new HashSet<TypeOnStack>();
+            var pushed = new LinqHashSet<TypeOnStack>();
             for(var i = 0; i < legal.Count; i++)
             {
                 foreach (var p in legal[i].PushedToStack)