mscorlib-4.0-offline-doxygenated-documentation/html/_op_codes_8cs_source.html

 using System.Runtime.InteropServices;

 namespace System.Reflection.Emit
 {
     [ComVisible(true)]
     [__DynamicallyInvokable]
     public class OpCodes
     {
         [__DynamicallyInvokable]
         public static readonly OpCode Nop = new OpCode(OpCodeValues.Nop, 6556325);

         [__DynamicallyInvokable]
         public static readonly OpCode Break = new OpCode(OpCodeValues.Break, 6556197);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldarg_0 = new OpCode(OpCodeValues.Ldarg_0, 275120805);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldarg_1 = new OpCode(OpCodeValues.Ldarg_1, 275120805);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldarg_2 = new OpCode(OpCodeValues.Ldarg_2, 275120805);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldarg_3 = new OpCode(OpCodeValues.Ldarg_3, 275120805);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldloc_0 = new OpCode(OpCodeValues.Ldloc_0, 275120805);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldloc_1 = new OpCode(OpCodeValues.Ldloc_1, 275120805);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldloc_2 = new OpCode(OpCodeValues.Ldloc_2, 275120805);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldloc_3 = new OpCode(OpCodeValues.Ldloc_3, 275120805);

         [__DynamicallyInvokable]
         public static readonly OpCode Stloc_0 = new OpCode(OpCodeValues.Stloc_0, -261877083);

         [__DynamicallyInvokable]
         public static readonly OpCode Stloc_1 = new OpCode(OpCodeValues.Stloc_1, -261877083);

         [__DynamicallyInvokable]
         public static readonly OpCode Stloc_2 = new OpCode(OpCodeValues.Stloc_2, -261877083);

         [__DynamicallyInvokable]
         public static readonly OpCode Stloc_3 = new OpCode(OpCodeValues.Stloc_3, -261877083);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldarg_S = new OpCode(OpCodeValues.Ldarg_S, 275120818);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldarga_S = new OpCode(OpCodeValues.Ldarga_S, 275382962);

         [__DynamicallyInvokable]
         public static readonly OpCode Starg_S = new OpCode(OpCodeValues.Starg_S, -261877070);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldloc_S = new OpCode(OpCodeValues.Ldloc_S, 275120818);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldloca_S = new OpCode(OpCodeValues.Ldloca_S, 275382962);

         [__DynamicallyInvokable]
         public static readonly OpCode Stloc_S = new OpCode(OpCodeValues.Stloc_S, -261877070);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldnull = new OpCode(OpCodeValues.Ldnull, 275909285);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_M1 = new OpCode(OpCodeValues.Ldc_I4_M1, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_0 = new OpCode(OpCodeValues.Ldc_I4_0, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_1 = new OpCode(OpCodeValues.Ldc_I4_1, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_2 = new OpCode(OpCodeValues.Ldc_I4_2, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_3 = new OpCode(OpCodeValues.Ldc_I4_3, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_4 = new OpCode(OpCodeValues.Ldc_I4_4, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_5 = new OpCode(OpCodeValues.Ldc_I4_5, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_6 = new OpCode(OpCodeValues.Ldc_I4_6, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_7 = new OpCode(OpCodeValues.Ldc_I4_7, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_8 = new OpCode(OpCodeValues.Ldc_I4_8, 275382949);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4_S = new OpCode(OpCodeValues.Ldc_I4_S, 275382960);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I4 = new OpCode(OpCodeValues.Ldc_I4, 275384994);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_I8 = new OpCode(OpCodeValues.Ldc_I8, 275516067);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_R4 = new OpCode(OpCodeValues.Ldc_R4, 275647153);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldc_R8 = new OpCode(OpCodeValues.Ldc_R8, 275778215);

         [__DynamicallyInvokable]
         public static readonly OpCode Dup = new OpCode(OpCodeValues.Dup, 275258021);

         [__DynamicallyInvokable]
         public static readonly OpCode Pop = new OpCode(OpCodeValues.Pop, -261875035);

         [__DynamicallyInvokable]
         public static readonly OpCode Jmp = new OpCode(OpCodeValues.Jmp, 23333444);

         [__DynamicallyInvokable]
         public static readonly OpCode Call = new OpCode(OpCodeValues.Call, 7842372);

         [__DynamicallyInvokable]
         public static readonly OpCode Calli = new OpCode(OpCodeValues.Calli, 7842377);

         [__DynamicallyInvokable]
         public static readonly OpCode Ret = new OpCode(OpCodeValues.Ret, 23440101);

         [__DynamicallyInvokable]
         public static readonly OpCode Br_S = new OpCode(OpCodeValues.Br_S, 23331343);

         [__DynamicallyInvokable]
         public static readonly OpCode Brfalse_S = new OpCode(OpCodeValues.Brfalse_S, -261868945);

         [__DynamicallyInvokable]
         public static readonly OpCode Brtrue_S = new OpCode(OpCodeValues.Brtrue_S, -261868945);

         [__DynamicallyInvokable]
         public static readonly OpCode Beq_S = new OpCode(OpCodeValues.Beq_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Bge_S = new OpCode(OpCodeValues.Bge_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Bgt_S = new OpCode(OpCodeValues.Bgt_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Ble_S = new OpCode(OpCodeValues.Ble_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Blt_S = new OpCode(OpCodeValues.Blt_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Bne_Un_S = new OpCode(OpCodeValues.Bne_Un_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Bge_Un_S = new OpCode(OpCodeValues.Bge_Un_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Bgt_Un_S = new OpCode(OpCodeValues.Bgt_Un_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Ble_Un_S = new OpCode(OpCodeValues.Ble_Un_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Blt_Un_S = new OpCode(OpCodeValues.Blt_Un_S, -530308497);

         [__DynamicallyInvokable]
         public static readonly OpCode Br = new OpCode(OpCodeValues.Br, 23333376);

         [__DynamicallyInvokable]
         public static readonly OpCode Brfalse = new OpCode(OpCodeValues.Brfalse, -261866912);

         [__DynamicallyInvokable]
         public static readonly OpCode Brtrue = new OpCode(OpCodeValues.Brtrue, -261866912);

         [__DynamicallyInvokable]
         public static readonly OpCode Beq = new OpCode(OpCodeValues.Beq, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Bge = new OpCode(OpCodeValues.Bge, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Bgt = new OpCode(OpCodeValues.Bgt, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Ble = new OpCode(OpCodeValues.Ble, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Blt = new OpCode(OpCodeValues.Blt, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Bne_Un = new OpCode(OpCodeValues.Bne_Un, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Bge_Un = new OpCode(OpCodeValues.Bge_Un, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Bgt_Un = new OpCode(OpCodeValues.Bgt_Un, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Ble_Un = new OpCode(OpCodeValues.Ble_Un, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Blt_Un = new OpCode(OpCodeValues.Blt_Un, -530308512);

         [__DynamicallyInvokable]
         public static readonly OpCode Switch = new OpCode(OpCodeValues.Switch, -261866901);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_I1 = new OpCode(OpCodeValues.Ldind_I1, 6961829);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_U1 = new OpCode(OpCodeValues.Ldind_U1, 6961829);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_I2 = new OpCode(OpCodeValues.Ldind_I2, 6961829);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_U2 = new OpCode(OpCodeValues.Ldind_U2, 6961829);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_I4 = new OpCode(OpCodeValues.Ldind_I4, 6961829);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_U4 = new OpCode(OpCodeValues.Ldind_U4, 6961829);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_I8 = new OpCode(OpCodeValues.Ldind_I8, 7092901);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_I = new OpCode(OpCodeValues.Ldind_I, 6961829);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_R4 = new OpCode(OpCodeValues.Ldind_R4, 7223973);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_R8 = new OpCode(OpCodeValues.Ldind_R8, 7355045);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldind_Ref = new OpCode(OpCodeValues.Ldind_Ref, 7486117);

         [__DynamicallyInvokable]
         public static readonly OpCode Stind_Ref = new OpCode(OpCodeValues.Stind_Ref, -530294107);

         [__DynamicallyInvokable]
         public static readonly OpCode Stind_I1 = new OpCode(OpCodeValues.Stind_I1, -530294107);

         [__DynamicallyInvokable]
         public static readonly OpCode Stind_I2 = new OpCode(OpCodeValues.Stind_I2, -530294107);

         [__DynamicallyInvokable]
         public static readonly OpCode Stind_I4 = new OpCode(OpCodeValues.Stind_I4, -530294107);

         [__DynamicallyInvokable]
         public static readonly OpCode Stind_I8 = new OpCode(OpCodeValues.Stind_I8, -530290011);

         [__DynamicallyInvokable]
         public static readonly OpCode Stind_R4 = new OpCode(OpCodeValues.Stind_R4, -530281819);

         [__DynamicallyInvokable]
         public static readonly OpCode Stind_R8 = new OpCode(OpCodeValues.Stind_R8, -530277723);

         [__DynamicallyInvokable]
         public static readonly OpCode Add = new OpCode(OpCodeValues.Add, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Sub = new OpCode(OpCodeValues.Sub, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Mul = new OpCode(OpCodeValues.Mul, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Div = new OpCode(OpCodeValues.Div, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Div_Un = new OpCode(OpCodeValues.Div_Un, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Rem = new OpCode(OpCodeValues.Rem, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Rem_Un = new OpCode(OpCodeValues.Rem_Un, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode And = new OpCode(OpCodeValues.And, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Or = new OpCode(OpCodeValues.Or, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Xor = new OpCode(OpCodeValues.Xor, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Shl = new OpCode(OpCodeValues.Shl, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Shr = new OpCode(OpCodeValues.Shr, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Shr_Un = new OpCode(OpCodeValues.Shr_Un, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Neg = new OpCode(OpCodeValues.Neg, 6691493);

         [__DynamicallyInvokable]
         public static readonly OpCode Not = new OpCode(OpCodeValues.Not, 6691493);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_I1 = new OpCode(OpCodeValues.Conv_I1, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_I2 = new OpCode(OpCodeValues.Conv_I2, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_I4 = new OpCode(OpCodeValues.Conv_I4, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_I8 = new OpCode(OpCodeValues.Conv_I8, 7084709);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_R4 = new OpCode(OpCodeValues.Conv_R4, 7215781);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_R8 = new OpCode(OpCodeValues.Conv_R8, 7346853);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_U4 = new OpCode(OpCodeValues.Conv_U4, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_U8 = new OpCode(OpCodeValues.Conv_U8, 7084709);

         [__DynamicallyInvokable]
         public static readonly OpCode Callvirt = new OpCode(OpCodeValues.Callvirt, 7841348);

         [__DynamicallyInvokable]
         public static readonly OpCode Cpobj = new OpCode(OpCodeValues.Cpobj, -530295123);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldobj = new OpCode(OpCodeValues.Ldobj, 6698669);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldstr = new OpCode(OpCodeValues.Ldstr, 275908266);

         [__DynamicallyInvokable]
         public static readonly OpCode Newobj = new OpCode(OpCodeValues.Newobj, 276014660);

         [ComVisible(true)]
         [__DynamicallyInvokable]
         public static readonly OpCode Castclass = new OpCode(OpCodeValues.Castclass, 7513773);

         [__DynamicallyInvokable]
         public static readonly OpCode Isinst = new OpCode(OpCodeValues.Isinst, 6989485);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_R_Un = new OpCode(OpCodeValues.Conv_R_Un, 7346853);

         [__DynamicallyInvokable]
         public static readonly OpCode Unbox = new OpCode(OpCodeValues.Unbox, 6990509);

         [__DynamicallyInvokable]
         public static readonly OpCode Throw = new OpCode(OpCodeValues.Throw, -245061883);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldfld = new OpCode(OpCodeValues.Ldfld, 6727329);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldflda = new OpCode(OpCodeValues.Ldflda, 6989473);

         [__DynamicallyInvokable]
         public static readonly OpCode Stfld = new OpCode(OpCodeValues.Stfld, -530270559);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldsfld = new OpCode(OpCodeValues.Ldsfld, 275121825);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldsflda = new OpCode(OpCodeValues.Ldsflda, 275383969);

         [__DynamicallyInvokable]
         public static readonly OpCode Stsfld = new OpCode(OpCodeValues.Stsfld, -261876063);

         [__DynamicallyInvokable]
         public static readonly OpCode Stobj = new OpCode(OpCodeValues.Stobj, -530298195);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I1_Un = new OpCode(OpCodeValues.Conv_Ovf_I1_Un, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I2_Un = new OpCode(OpCodeValues.Conv_Ovf_I2_Un, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I4_Un = new OpCode(OpCodeValues.Conv_Ovf_I4_Un, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I8_Un = new OpCode(OpCodeValues.Conv_Ovf_I8_Un, 7084709);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U1_Un = new OpCode(OpCodeValues.Conv_Ovf_U1_Un, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U2_Un = new OpCode(OpCodeValues.Conv_Ovf_U2_Un, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U4_Un = new OpCode(OpCodeValues.Conv_Ovf_U4_Un, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U8_Un = new OpCode(OpCodeValues.Conv_Ovf_U8_Un, 7084709);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I_Un = new OpCode(OpCodeValues.Conv_Ovf_I_Un, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U_Un = new OpCode(OpCodeValues.Conv_Ovf_U_Un, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Box = new OpCode(OpCodeValues.Box, 7477933);

         [__DynamicallyInvokable]
         public static readonly OpCode Newarr = new OpCode(OpCodeValues.Newarr, 7485101);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldlen = new OpCode(OpCodeValues.Ldlen, 6989477);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelema = new OpCode(OpCodeValues.Ldelema, -261437779);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_I1 = new OpCode(OpCodeValues.Ldelem_I1, -261437787);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_U1 = new OpCode(OpCodeValues.Ldelem_U1, -261437787);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_I2 = new OpCode(OpCodeValues.Ldelem_I2, -261437787);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_U2 = new OpCode(OpCodeValues.Ldelem_U2, -261437787);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_I4 = new OpCode(OpCodeValues.Ldelem_I4, -261437787);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_U4 = new OpCode(OpCodeValues.Ldelem_U4, -261437787);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_I8 = new OpCode(OpCodeValues.Ldelem_I8, -261306715);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_I = new OpCode(OpCodeValues.Ldelem_I, -261437787);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_R4 = new OpCode(OpCodeValues.Ldelem_R4, -261175643);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_R8 = new OpCode(OpCodeValues.Ldelem_R8, -261044571);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem_Ref = new OpCode(OpCodeValues.Ldelem_Ref, -260913499);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem_I = new OpCode(OpCodeValues.Stelem_I, -798697819);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem_I1 = new OpCode(OpCodeValues.Stelem_I1, -798697819);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem_I2 = new OpCode(OpCodeValues.Stelem_I2, -798697819);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem_I4 = new OpCode(OpCodeValues.Stelem_I4, -798697819);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem_I8 = new OpCode(OpCodeValues.Stelem_I8, -798693723);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem_R4 = new OpCode(OpCodeValues.Stelem_R4, -798689627);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem_R8 = new OpCode(OpCodeValues.Stelem_R8, -798685531);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem_Ref = new OpCode(OpCodeValues.Stelem_Ref, -798681435);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldelem = new OpCode(OpCodeValues.Ldelem, -261699923);

         [__DynamicallyInvokable]
         public static readonly OpCode Stelem = new OpCode(OpCodeValues.Stelem, 6669997);

         [__DynamicallyInvokable]
         public static readonly OpCode Unbox_Any = new OpCode(OpCodeValues.Unbox_Any, 6727341);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I1 = new OpCode(OpCodeValues.Conv_Ovf_I1, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U1 = new OpCode(OpCodeValues.Conv_Ovf_U1, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I2 = new OpCode(OpCodeValues.Conv_Ovf_I2, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U2 = new OpCode(OpCodeValues.Conv_Ovf_U2, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I4 = new OpCode(OpCodeValues.Conv_Ovf_I4, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U4 = new OpCode(OpCodeValues.Conv_Ovf_U4, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I8 = new OpCode(OpCodeValues.Conv_Ovf_I8, 7084709);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U8 = new OpCode(OpCodeValues.Conv_Ovf_U8, 7084709);

         [__DynamicallyInvokable]
         public static readonly OpCode Refanyval = new OpCode(OpCodeValues.Refanyval, 6953645);

         [__DynamicallyInvokable]
         public static readonly OpCode Ckfinite = new OpCode(OpCodeValues.Ckfinite, 7346853);

         [__DynamicallyInvokable]
         public static readonly OpCode Mkrefany = new OpCode(OpCodeValues.Mkrefany, 6699693);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldtoken = new OpCode(OpCodeValues.Ldtoken, 275385004);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_U2 = new OpCode(OpCodeValues.Conv_U2, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_U1 = new OpCode(OpCodeValues.Conv_U1, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_I = new OpCode(OpCodeValues.Conv_I, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_I = new OpCode(OpCodeValues.Conv_Ovf_I, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_Ovf_U = new OpCode(OpCodeValues.Conv_Ovf_U, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Add_Ovf = new OpCode(OpCodeValues.Add_Ovf, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Add_Ovf_Un = new OpCode(OpCodeValues.Add_Ovf_Un, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Mul_Ovf = new OpCode(OpCodeValues.Mul_Ovf, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Mul_Ovf_Un = new OpCode(OpCodeValues.Mul_Ovf_Un, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Sub_Ovf = new OpCode(OpCodeValues.Sub_Ovf, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Sub_Ovf_Un = new OpCode(OpCodeValues.Sub_Ovf_Un, -261739867);

         [__DynamicallyInvokable]
         public static readonly OpCode Endfinally = new OpCode(OpCodeValues.Endfinally, 23333605);

         [__DynamicallyInvokable]
         public static readonly OpCode Leave = new OpCode(OpCodeValues.Leave, 23333376);

         [__DynamicallyInvokable]
         public static readonly OpCode Leave_S = new OpCode(OpCodeValues.Leave_S, 23333391);

         [__DynamicallyInvokable]
         public static readonly OpCode Stind_I = new OpCode(OpCodeValues.Stind_I, -530294107);

         [__DynamicallyInvokable]
         public static readonly OpCode Conv_U = new OpCode(OpCodeValues.Conv_U, 6953637);

         [__DynamicallyInvokable]
         public static readonly OpCode Prefix7 = new OpCode(OpCodeValues.Prefix7, 6554757);

         [__DynamicallyInvokable]
         public static readonly OpCode Prefix6 = new OpCode(OpCodeValues.Prefix6, 6554757);

         [__DynamicallyInvokable]
         public static readonly OpCode Prefix5 = new OpCode(OpCodeValues.Prefix5, 6554757);

         [__DynamicallyInvokable]
         public static readonly OpCode Prefix4 = new OpCode(OpCodeValues.Prefix4, 6554757);

         [__DynamicallyInvokable]
         public static readonly OpCode Prefix3 = new OpCode(OpCodeValues.Prefix3, 6554757);

         [__DynamicallyInvokable]
         public static readonly OpCode Prefix2 = new OpCode(OpCodeValues.Prefix2, 6554757);

         [__DynamicallyInvokable]
         public static readonly OpCode Prefix1 = new OpCode(OpCodeValues.Prefix1, 6554757);

         [__DynamicallyInvokable]
         public static readonly OpCode Prefixref = new OpCode(OpCodeValues.Prefixref, 6554757);

         [__DynamicallyInvokable]
         public static readonly OpCode Arglist = new OpCode(OpCodeValues.Arglist, 279579301);

         [__DynamicallyInvokable]
         public static readonly OpCode Ceq = new OpCode(OpCodeValues.Ceq, -257283419);

         [__DynamicallyInvokable]
         public static readonly OpCode Cgt = new OpCode(OpCodeValues.Cgt, -257283419);

         [__DynamicallyInvokable]
         public static readonly OpCode Cgt_Un = new OpCode(OpCodeValues.Cgt_Un, -257283419);

         [__DynamicallyInvokable]
         public static readonly OpCode Clt = new OpCode(OpCodeValues.Clt, -257283419);

         [__DynamicallyInvokable]
         public static readonly OpCode Clt_Un = new OpCode(OpCodeValues.Clt_Un, -257283419);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldftn = new OpCode(OpCodeValues.Ldftn, 279579300);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldvirtftn = new OpCode(OpCodeValues.Ldvirtftn, 11184804);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldarg = new OpCode(OpCodeValues.Ldarg, 279317166);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldarga = new OpCode(OpCodeValues.Ldarga, 279579310);

         [__DynamicallyInvokable]
         public static readonly OpCode Starg = new OpCode(OpCodeValues.Starg, -257680722);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldloc = new OpCode(OpCodeValues.Ldloc, 279317166);

         [__DynamicallyInvokable]
         public static readonly OpCode Ldloca = new OpCode(OpCodeValues.Ldloca, 279579310);

         [__DynamicallyInvokable]
         public static readonly OpCode Stloc = new OpCode(OpCodeValues.Stloc, -257680722);

         [__DynamicallyInvokable]
         public static readonly OpCode Localloc = new OpCode(OpCodeValues.Localloc, 11156133);

         [__DynamicallyInvokable]
         public static readonly OpCode Endfilter = new OpCode(OpCodeValues.Endfilter, -240895259);

         [__DynamicallyInvokable]
         public static readonly OpCode Unaligned = new OpCode(OpCodeValues.Unaligned_, 10750096);

         [__DynamicallyInvokable]
         public static readonly OpCode Volatile = new OpCode(OpCodeValues.Volatile_, 10750085);

         [__DynamicallyInvokable]
         public static readonly OpCode Tailcall = new OpCode(OpCodeValues.Tail_, 10750085);

         [__DynamicallyInvokable]
         public static readonly OpCode Initobj = new OpCode(OpCodeValues.Initobj, -257673555);

         [__DynamicallyInvokable]
         public static readonly OpCode Constrained = new OpCode(OpCodeValues.Constrained_, 10750093);

         [__DynamicallyInvokable]
         public static readonly OpCode Cpblk = new OpCode(OpCodeValues.Cpblk, -794527067);

         [__DynamicallyInvokable]
         public static readonly OpCode Initblk = new OpCode(OpCodeValues.Initblk, -794527067);

         [__DynamicallyInvokable]
         public static readonly OpCode Rethrow = new OpCode(OpCodeValues.Rethrow, 27526917);

         [__DynamicallyInvokable]
         public static readonly OpCode Sizeof = new OpCode(OpCodeValues.Sizeof, 279579309);

         [__DynamicallyInvokable]
         public static readonly OpCode Refanytype = new OpCode(OpCodeValues.Refanytype, 11147941);

         [__DynamicallyInvokable]
         public static readonly OpCode Readonly = new OpCode(OpCodeValues.Readonly_, 10750085);

         private OpCodes()
         {
         }

         [__DynamicallyInvokable]
         public static bool TakesSingleByteArgument(OpCode inst)
         {
             switch (inst.OperandType)
             {
             case OperandType.ShortInlineBrTarget:
             case OperandType.ShortInlineI:
             case OperandType.ShortInlineVar:
                 return true;
             default:
                 return false;
             }
         }
     }
 }
System.Reflection.Emit.OpCodes.Prefix3
static readonly OpCode Prefix3
This is a reserved instruction.
Definition: OpCodes.cs:793

System.Reflection.Emit.OpCodes.Not
static readonly OpCode Not
Computes the bitwise complement of the integer value on top of the stack and pushes the result onto t...
Definition: OpCodes.cs:416

System.Reflection.Emit.OpCode.OperandType
OperandType OperandType
The operand type of an intermediate language (IL) instruction.
Definition: OpCode.cs:63

System.Reflection.Emit.OpCodes.Conv_R8
static readonly OpCode Conv_R8
Converts the value on top of the evaluation stack to float64.
Definition: OpCodes.cs:440

System.Reflection.Emit.OpCodes.Conv_Ovf_U1_Un
static readonly OpCode Conv_Ovf_U1_Un
Converts the unsigned value on top of the evaluation stack to unsigned int8 and extends it to int32,...
Definition: OpCodes.cs:537

System.Reflection.Emit.OpCodes.Throw
static readonly OpCode Throw
Throws the exception object currently on the evaluation stack.
Definition: OpCodes.cs:489

System.Reflection.Emit
Definition: __ExceptionInfo.cs:1

System.Reflection.Emit.OpCodes.Ldc_I8
static readonly OpCode Ldc_I8
Pushes a supplied value of type int64 onto the evaluation stack as an int64.
Definition: OpCodes.cs:144

System.Reflection.Emit.OpCodes.Unaligned
static readonly OpCode Unaligned
Indicates that an address currently atop the evaluation stack might not be aligned to the natural siz...
Definition: OpCodes.cs:873

System.Reflection.Emit.OpCodes.Div
static readonly OpCode Div
Divides two values and pushes the result as a floating-point (type F) or quotient (type int32) onto t...
Definition: OpCodes.cs:372

System.Reflection.Emit.OpCodes.Starg
static readonly OpCode Starg
Stores the value on top of the evaluation stack in the argument slot at a specified index.
Definition: OpCodes.cs:849

System.Reflection.Emit.OpCodes.Ldc_I4_5
static readonly OpCode Ldc_I4_5
Pushes the integer value of 5 onto the evaluation stack as an int32.
Definition: OpCodes.cs:120

System.Reflection.Emit.OpCodes.Refanytype
static readonly OpCode Refanytype
Retrieves the type token embedded in a typed reference.
Definition: OpCodes.cs:909

System.Reflection.Emit.OpCodes.Ldind_Ref
static readonly OpCode Ldind_Ref
Loads an object reference as a type O (object reference) onto the evaluation stack indirectly.
Definition: OpCodes.cs:328

System.Reflection.Emit.OpCodes.Conv_R4
static readonly OpCode Conv_R4
Converts the value on top of the evaluation stack to float32.
Definition: OpCodes.cs:436

System.Reflection.Emit.OpCodes.Endfinally
static readonly OpCode Endfinally
Transfers control from the fault or finally clause of an exception block back to the Common Language ...
Definition: OpCodes.cs:757

System.Reflection.Emit.OpCodes.Ldarg_2
static readonly OpCode Ldarg_2
Loads the argument at index 2 onto the evaluation stack.
Definition: OpCodes.cs:28

System.Reflection.Emit.OpCodes.Sub_Ovf
static readonly OpCode Sub_Ovf
Subtracts one integer value from another, performs an overflow check, and pushes the result onto the ...
Definition: OpCodes.cs:749

System.Reflection.Emit.OpCodes.Conv_Ovf_U4_Un
static readonly OpCode Conv_Ovf_U4_Un
Converts the unsigned value on top of the evaluation stack to unsigned int32, throwing T:System....
Definition: OpCodes.cs:545

System.Reflection.Emit.OpCodes.Conv_R_Un
static readonly OpCode Conv_R_Un
Converts the unsigned integer value on top of the evaluation stack to float32.
Definition: OpCodes.cs:481

System.Reflection.Emit.OpCodes.Bgt_Un_S
static readonly OpCode Bgt_Un_S
Transfers control to a target instruction (short form) if the first value is greater than the second ...
Definition: OpCodes.cs:220

System.Reflection.Emit.OpCodes.Initblk
static readonly OpCode Initblk
Initializes a specified block of memory at a specific address to a given size and initial value.
Definition: OpCodes.cs:897

System.Reflection.Emit.OpCodes.Ldelem_R8
static readonly OpCode Ldelem_R8
Loads the element with type float64 at a specified array index onto the top of the evaluation stack a...
Definition: OpCodes.cs:613

System.Reflection.Emit.OpCodes.Conv_I2
static readonly OpCode Conv_I2
Converts the value on top of the evaluation stack to int16, then extends (pads) it to int32.
Definition: OpCodes.cs:424

System.Reflection.Emit.OpCodes.Brfalse
static readonly OpCode Brfalse
Transfers control to a target instruction if value  is false, a null reference (Nothing in Visual Bas...
Definition: OpCodes.cs:236

System.Reflection.Emit.OpCodes.Conv_Ovf_I4
static readonly OpCode Conv_Ovf_I4
Converts the signed value on top of the evaluation stack to signed int32, throwing T:System....
Definition: OpCodes.cs:681

System.Reflection.Emit.OpCodes.Tailcall
static readonly OpCode Tailcall
Performs a postfixed method call instruction such that the current method's stack frame is removed be...
Definition: OpCodes.cs:881

System.Reflection.Emit.OpCodes.Ldarg
static readonly OpCode Ldarg
Loads an argument (referenced by a specified index value) onto the stack.
Definition: OpCodes.cs:841

System.Reflection.Emit.OpCodes.Ldsflda
static readonly OpCode Ldsflda
Pushes the address of a static field onto the evaluation stack.
Definition: OpCodes.cs:509

System.Reflection.Emit.OperandType
OperandType
Describes the operand type of Microsoft intermediate language (MSIL) instruction.
Definition: OperandType.cs:9

System.Reflection.Emit.OpCodes.Br
static readonly OpCode Br
Unconditionally transfers control to a target instruction.
Definition: OpCodes.cs:232

System.Reflection.Emit.OpCodes.Cgt_Un
static readonly OpCode Cgt_Un
Compares two unsigned or unordered values. If the first value is greater than the second,...
Definition: OpCodes.cs:821

System.Reflection.Emit.OpCodes.Conv_I4
static readonly OpCode Conv_I4
Converts the value on top of the evaluation stack to int32.
Definition: OpCodes.cs:428

System.Reflection.Emit.OpCodes.Ldarg_0
static readonly OpCode Ldarg_0
Loads the argument at index 0 onto the evaluation stack.
Definition: OpCodes.cs:20

System.Reflection.Emit.OpCodes.Ldelem_I
static readonly OpCode Ldelem_I
Loads the element with type native int at a specified array index onto the top of the evaluation stac...
Definition: OpCodes.cs:605

System.Reflection.Emit.OpCodes.Constrained
static readonly OpCode Constrained
Constrains the type on which a virtual method call is made.
Definition: OpCodes.cs:889

System.Reflection.Emit.OpCodes.Clt_Un
static readonly OpCode Clt_Un
Compares the unsigned or unordered values value1  and value2 . If value1  is less than value2 ,...
Definition: OpCodes.cs:829

System.Reflection.Emit.OpCodes.Ldelem_U4
static readonly OpCode Ldelem_U4
Loads the element with type unsigned int32 at a specified array index onto the top of the evaluation ...
Definition: OpCodes.cs:597

System.Reflection.Emit.OpCodes.Stloc_3
static readonly OpCode Stloc_3
Pops the current value from the top of the evaluation stack and stores it in a the local variable lis...
Definition: OpCodes.cs:64

System.Runtime.InteropServices
Definition: _Activator.cs:1

System.Reflection.Emit.OpCodes.Conv_I8
static readonly OpCode Conv_I8
Converts the value on top of the evaluation stack to int64.
Definition: OpCodes.cs:432

System.Reflection.Emit.OpCodes.Ldind_U4
static readonly OpCode Ldind_U4
Loads a value of type unsigned int32 as an int32 onto the evaluation stack indirectly.
Definition: OpCodes.cs:308

System.Reflection.Emit.OpCodes.Ldind_I1
static readonly OpCode Ldind_I1
Loads a value of type int8 as an int32 onto the evaluation stack indirectly.
Definition: OpCodes.cs:288

System.Reflection.Emit.OpCodes.Conv_Ovf_I8
static readonly OpCode Conv_Ovf_I8
Converts the signed value on top of the evaluation stack to signed int64, throwing T:System....
Definition: OpCodes.cs:689

System.Reflection.Emit.OpCodes.Volatile
static readonly OpCode Volatile
Specifies that an address currently atop the evaluation stack might be volatile, and the results of r...
Definition: OpCodes.cs:877

System.Reflection.Emit.OpCodes.Br_S
static readonly OpCode Br_S
Unconditionally transfers control to a target instruction (short form).
Definition: OpCodes.cs:180

System.Runtime
Definition: AssemblyTargetedPatchBandAttribute.cs:1

System.Reflection.Emit.OpCodes.Ldloc_2
static readonly OpCode Ldloc_2
Loads the local variable at index 2 onto the evaluation stack.
Definition: OpCodes.cs:44

System.Reflection.Emit.OpCodes.Stind_I8
static readonly OpCode Stind_I8
Stores a value of type int64 at a supplied address.
Definition: OpCodes.cs:348

System.Reflection.Emit.OpCodes.Stfld
static readonly OpCode Stfld
Replaces the value stored in the field of an object reference or pointer with a new value.
Definition: OpCodes.cs:501

System.Reflection.Emit.OpCodes.Conv_Ovf_U4
static readonly OpCode Conv_Ovf_U4
Converts the signed value on top of the evaluation stack to unsigned int32, throwing T:System....
Definition: OpCodes.cs:685

System.Reflection.Emit.OpCodes.Nop
static readonly OpCode Nop
Fills space if opcodes are patched. No meaningful operation is performed although a processing cycle ...
Definition: OpCodes.cs:12

System.Reflection.Emit.OpCodes.Stsfld
static readonly OpCode Stsfld
Replaces the value of a static field with a value from the evaluation stack.
Definition: OpCodes.cs:513

System.Reflection.Emit.OpCodes.Neg
static readonly OpCode Neg
Negates a value and pushes the result onto the evaluation stack.
Definition: OpCodes.cs:412

System.Reflection.Emit.OpCodes.Ldind_U1
static readonly OpCode Ldind_U1
Loads a value of type unsigned int8 as an int32 onto the evaluation stack indirectly.
Definition: OpCodes.cs:292

System.Reflection.Emit.OpCodes.Unbox_Any
static readonly OpCode Unbox_Any
Converts the boxed representation of a type specified in the instruction to its unboxed form.
Definition: OpCodes.cs:661

System
Definition: __Canon.cs:3

System.Reflection.Emit.OpCodes.Conv_Ovf_U2_Un
static readonly OpCode Conv_Ovf_U2_Un
Converts the unsigned value on top of the evaluation stack to unsigned int16 and extends it to int32,...
Definition: OpCodes.cs:541

System.Reflection.Emit.OpCodes.Conv_Ovf_I2_Un
static readonly OpCode Conv_Ovf_I2_Un
Converts the unsigned value on top of the evaluation stack to signed int16 and extends it to int32,...
Definition: OpCodes.cs:525

System.Reflection.Emit.OpCodes.Ldc_I4_8
static readonly OpCode Ldc_I4_8
Pushes the integer value of 8 onto the evaluation stack as an int32.
Definition: OpCodes.cs:132

System.Reflection.Emit.OpCodes.Mul_Ovf_Un
static readonly OpCode Mul_Ovf_Un
Multiplies two unsigned integer values, performs an overflow check, and pushes the result onto the ev...
Definition: OpCodes.cs:745

System.Reflection.Emit.OpCodes.Bge_Un_S
static readonly OpCode Bge_Un_S
Transfers control to a target instruction (short form) if the first value is greater than the second ...
Definition: OpCodes.cs:216

System.Reflection.Emit.OpCodes.Stelem_I4
static readonly OpCode Stelem_I4
Replaces the array element at a given index with the int32 value on the evaluation stack.
Definition: OpCodes.cs:633

System.Reflection.Emit.OpCodes.Mul
static readonly OpCode Mul
Multiplies two values and pushes the result on the evaluation stack.
Definition: OpCodes.cs:368

System.Reflection.Emit.OpCodes.Ldelema
static readonly OpCode Ldelema
Loads the address of the array element at a specified array index onto the top of the evaluation stac...
Definition: OpCodes.cs:573

System.Reflection.Emit.OpCodes.Stelem_R8
static readonly OpCode Stelem_R8
Replaces the array element at a given index with the float64 value on the evaluation stack.
Definition: OpCodes.cs:645

System.Reflection.Emit.OpCodes.Rethrow
static readonly OpCode Rethrow
Rethrows the current exception.
Definition: OpCodes.cs:901

System.Reflection.Emit.OpCodes.Blt_S
static readonly OpCode Blt_S
Transfers control to a target instruction (short form) if the first value is less than the second val...
Definition: OpCodes.cs:208

System.Reflection.Emit.OpCodes.Stind_I
static readonly OpCode Stind_I
Stores a value of type native int at a supplied address.
Definition: OpCodes.cs:769

System.Reflection.Emit.OpCodes.Prefix5
static readonly OpCode Prefix5
This is a reserved instruction.
Definition: OpCodes.cs:785

System.Reflection.Emit.OpCodes.Conv_U4
static readonly OpCode Conv_U4
Converts the value on top of the evaluation stack to unsigned int32, and extends it to int32.
Definition: OpCodes.cs:444

System.Reflection.Emit.OpCodes.Blt_Un_S
static readonly OpCode Blt_Un_S
Transfers control to a target instruction (short form) if the first value is less than the second val...
Definition: OpCodes.cs:228

System.Reflection.Emit.OpCodes.Ldelem
static readonly OpCode Ldelem
Loads the element at a specified array index onto the top of the evaluation stack as the type specifi...
Definition: OpCodes.cs:653

System.Reflection.Emit.OpCodes.Stelem_I8
static readonly OpCode Stelem_I8
Replaces the array element at a given index with the int64 value on the evaluation stack.
Definition: OpCodes.cs:637

System.Reflection.Emit.OpCodes.Ldelem_Ref
static readonly OpCode Ldelem_Ref
Loads the element containing an object reference at a specified array index onto the top of the evalu...
Definition: OpCodes.cs:617

System.Reflection.Emit.OpCodes.Stind_I4
static readonly OpCode Stind_I4
Stores a value of type int32 at a supplied address.
Definition: OpCodes.cs:344

System.Reflection.Emit.OpCodes.Ble
static readonly OpCode Ble
Transfers control to a target instruction if the first value is less than or equal to the second valu...
Definition: OpCodes.cs:256

System.Reflection.Emit.OpCodes.Conv_Ovf_I1_Un
static readonly OpCode Conv_Ovf_I1_Un
Converts the unsigned value on top of the evaluation stack to signed int8 and extends it to int32,...
Definition: OpCodes.cs:521

System.Reflection.Emit.OpCodes.Ldelem_I2
static readonly OpCode Ldelem_I2
Loads the element with type int16 at a specified array index onto the top of the evaluation stack as ...
Definition: OpCodes.cs:585

System.Reflection.Emit.OpCodes.Ldloca_S
static readonly OpCode Ldloca_S
Loads the address of the local variable at a specific index onto the evaluation stack,...
Definition: OpCodes.cs:84

System.Reflection.Emit.OpCodes.Cpblk
static readonly OpCode Cpblk
Copies a specified number bytes from a source address to a destination address.
Definition: OpCodes.cs:893

System.Reflection.Emit.OpCodes.Brtrue
static readonly OpCode Brtrue
Transfers control to a target instruction if value  is true, not null, or non-zero.
Definition: OpCodes.cs:240

System.Reflection.Emit.OpCodes.And
static readonly OpCode And
Computes the bitwise AND of two values and pushes the result onto the evaluation stack.
Definition: OpCodes.cs:388

System.Reflection.Emit.OpCodes.Conv_Ovf_U8
static readonly OpCode Conv_Ovf_U8
Converts the signed value on top of the evaluation stack to unsigned int64, throwing T:System....
Definition: OpCodes.cs:693

System.Reflection.Emit.OpCodes.Sub
static readonly OpCode Sub
Subtracts one value from another and pushes the result onto the evaluation stack.
Definition: OpCodes.cs:364

System.Reflection.Emit.OpCodes.Ldc_I4_1
static readonly OpCode Ldc_I4_1
Pushes the integer value of 1 onto the evaluation stack as an int32.
Definition: OpCodes.cs:104

System.Reflection.Emit.OpCodes.Conv_Ovf_I_Un
static readonly OpCode Conv_Ovf_I_Un
Converts the unsigned value on top of the evaluation stack to signed native int, throwing T:System....
Definition: OpCodes.cs:553

System.Reflection.Emit.OpCodes.Clt
static readonly OpCode Clt
Compares two values. If the first value is less than the second, the integer value 1 (int32) is pushe...
Definition: OpCodes.cs:825

System.Reflection.Emit.OpCodes.Add_Ovf
static readonly OpCode Add_Ovf
Adds two integers, performs an overflow check, and pushes the result onto the evaluation stack.
Definition: OpCodes.cs:733

System.Reflection.Emit.OpCodes.Conv_Ovf_I
static readonly OpCode Conv_Ovf_I
Converts the signed value on top of the evaluation stack to signed native int, throwing T:System....
Definition: OpCodes.cs:725

System.Reflection.Emit.OpCodes.Ldc_I4_4
static readonly OpCode Ldc_I4_4
Pushes the integer value of 4 onto the evaluation stack as an int32.
Definition: OpCodes.cs:116

System.Reflection.Emit.OpCodes.Conv_U8
static readonly OpCode Conv_U8
Converts the value on top of the evaluation stack to unsigned int64, and extends it to int64.
Definition: OpCodes.cs:448

System.Reflection.Emit.OpCodes.Stind_I2
static readonly OpCode Stind_I2
Stores a value of type int16 at a supplied address.
Definition: OpCodes.cs:340

System.Reflection.Emit.OpCodes.Ldind_R8
static readonly OpCode Ldind_R8
Loads a value of type float64 as a type F (float) onto the evaluation stack indirectly.
Definition: OpCodes.cs:324

System.Reflection.Emit.OpCodes.Ldobj
static readonly OpCode Ldobj
Copies the value type object pointed to by an address to the top of the evaluation stack.
Definition: OpCodes.cs:460

System.Reflection.Emit.OpCodes.Break
static readonly OpCode Break
Signals the Common Language Infrastructure (CLI) to inform the debugger that a break point has been t...
Definition: OpCodes.cs:16

System.Reflection.Emit.OpCodes.Unbox
static readonly OpCode Unbox
Converts the boxed representation of a value type to its unboxed form.
Definition: OpCodes.cs:485

System.Reflection.Emit.OpCodes.TakesSingleByteArgument
static bool TakesSingleByteArgument(OpCode inst)
Returns true or false if the supplied opcode takes a single byte argument.
Definition: OpCodes.cs:924

System.Reflection.Emit.OpCodes.Ldarg_S
static readonly OpCode Ldarg_S
Loads the argument (referenced by a specified short form index) onto the evaluation stack.
Definition: OpCodes.cs:68

System.Reflection.Emit.OpCodes.Stloc_0
static readonly OpCode Stloc_0
Pops the current value from the top of the evaluation stack and stores it in a the local variable lis...
Definition: OpCodes.cs:52

System.Reflection.Emit.OpCodes.Prefix4
static readonly OpCode Prefix4
This is a reserved instruction.
Definition: OpCodes.cs:789

System.Reflection.Emit.OpCodes.Conv_Ovf_U2
static readonly OpCode Conv_Ovf_U2
Converts the signed value on top of the evaluation stack to unsigned int16 and extends it to int32,...
Definition: OpCodes.cs:677

System.Reflection.Emit.OpCodes.Or
static readonly OpCode Or
Compute the bitwise complement of the two integer values on top of the stack and pushes the result on...
Definition: OpCodes.cs:392

System.Reflection.Emit.OpCodes.Bne_Un_S
static readonly OpCode Bne_Un_S
Transfers control to a target instruction (short form) when two unsigned integer values or unordered ...
Definition: OpCodes.cs:212

System.Reflection.Emit.OpCodes.Bgt_Un
static readonly OpCode Bgt_Un
Transfers control to a target instruction if the first value is greater than the second value,...
Definition: OpCodes.cs:272

System.Reflection.Emit.OpCodes.Cgt
static readonly OpCode Cgt
Compares two values. If the first value is greater than the second, the integer value 1 (int32) is pu...
Definition: OpCodes.cs:817

System.Reflection.Emit.OpCodes.Ldtoken
static readonly OpCode Ldtoken
Converts a metadata token to its runtime representation, pushing it onto the evaluation stack.
Definition: OpCodes.cs:709

System.Reflection.Emit.OpCodes.Prefix6
static readonly OpCode Prefix6
This is a reserved instruction.
Definition: OpCodes.cs:781

System.Reflection.Emit.OpCodes.Arglist
static readonly OpCode Arglist
Returns an unmanaged pointer to the argument list of the current method.
Definition: OpCodes.cs:809

System.Reflection.Emit.OpCodes.Conv_I
static readonly OpCode Conv_I
Converts the value on top of the evaluation stack to native int.
Definition: OpCodes.cs:721

System.Reflection.Emit.OpCodes.Ret
static readonly OpCode Ret
Returns from the current method, pushing a return value (if present) from the callee's evaluation sta...
Definition: OpCodes.cs:176

System.Reflection.Emit.OpCodes.Ldc_R4
static readonly OpCode Ldc_R4
Pushes a supplied value of type float32 onto the evaluation stack as type F (float).
Definition: OpCodes.cs:148

System.Reflection.Emit.OpCodes.Endfilter
static readonly OpCode Endfilter
Transfers control from the filter clause of an exception back to the Common Language Infrastructure (...
Definition: OpCodes.cs:869

System.Reflection.Emit.OpCodes.Stind_R4
static readonly OpCode Stind_R4
Stores a value of type float32 at a supplied address.
Definition: OpCodes.cs:352

System.Reflection.Emit.OpCodes.Conv_Ovf_U1
static readonly OpCode Conv_Ovf_U1
Converts the signed value on top of the evaluation stack to unsigned int8 and extends it to int32,...
Definition: OpCodes.cs:669

System.Reflection.Emit.OpCodes.Add
static readonly OpCode Add
Adds two values and pushes the result onto the evaluation stack.
Definition: OpCodes.cs:360

System.Reflection.Emit.OpCodes.Ldloca
static readonly OpCode Ldloca
Loads the address of the local variable at a specific index onto the evaluation stack.
Definition: OpCodes.cs:857

System.Reflection.Emit.OpCodes.Beq_S
static readonly OpCode Beq_S
Transfers control to a target instruction (short form) if two values are equal.
Definition: OpCodes.cs:192

System.Reflection.Emit.OpCodes.Ldelem_U1
static readonly OpCode Ldelem_U1
Loads the element with type unsigned int8 at a specified array index onto the top of the evaluation s...
Definition: OpCodes.cs:581

System.Reflection.Emit.OpCodes.Stind_R8
static readonly OpCode Stind_R8
Stores a value of type float64 at a supplied address.
Definition: OpCodes.cs:356

System.Reflection.Emit.OpCodes.Bge_Un
static readonly OpCode Bge_Un
Transfers control to a target instruction if the first value is greater than the second value,...
Definition: OpCodes.cs:268

System.Reflection.Emit.OpCodes.Ldarg_3
static readonly OpCode Ldarg_3
Loads the argument at index 3 onto the evaluation stack.
Definition: OpCodes.cs:32

System.Reflection.Emit.OpCodes.Conv_Ovf_U8_Un
static readonly OpCode Conv_Ovf_U8_Un
Converts the unsigned value on top of the evaluation stack to unsigned int64, throwing T:System....
Definition: OpCodes.cs:549

System.Reflection.Emit.OpCodes.Stelem_Ref
static readonly OpCode Stelem_Ref
Replaces the array element at a given index with the object ref value (type O) on the evaluation stac...
Definition: OpCodes.cs:649

System.Reflection.Emit.OpCodes.Stind_Ref
static readonly OpCode Stind_Ref
Stores a object reference value at a supplied address.
Definition: OpCodes.cs:332

System.Reflection.Emit.OpCodes.Ldc_I4_2
static readonly OpCode Ldc_I4_2
Pushes the integer value of 2 onto the evaluation stack as an int32.
Definition: OpCodes.cs:108

System.Reflection.Emit.OpCodes.Prefix2
static readonly OpCode Prefix2
This is a reserved instruction.
Definition: OpCodes.cs:797

System.Reflection.Emit.OpCodes.Mkrefany
static readonly OpCode Mkrefany
Pushes a typed reference to an instance of a specific type onto the evaluation stack.
Definition: OpCodes.cs:705

System.Reflection.Emit.OpCodes.Ldflda
static readonly OpCode Ldflda
Finds the address of a field in the object whose reference is currently on the evaluation stack.
Definition: OpCodes.cs:497

System.Reflection.Emit.OpCodes.Prefix1
static readonly OpCode Prefix1
This is a reserved instruction.
Definition: OpCodes.cs:801

System.Reflection.Emit.OpCodes.Stelem
static readonly OpCode Stelem
Replaces the array element at a given index with the value on the evaluation stack,...
Definition: OpCodes.cs:657

System.Reflection.Emit.OpCodes.Shr_Un
static readonly OpCode Shr_Un
Shifts an unsigned integer value (in zeroes) to the right by a specified number of bits,...
Definition: OpCodes.cs:408

System.Reflection.Emit.OpCodes.Ldind_I4
static readonly OpCode Ldind_I4
Loads a value of type int32 as an int32 onto the evaluation stack indirectly.
Definition: OpCodes.cs:304

System.Reflection.Emit.OpCodes.Conv_U1
static readonly OpCode Conv_U1
Converts the value on top of the evaluation stack to unsigned int8, and extends it to int32.
Definition: OpCodes.cs:717

System.Reflection.Emit.OpCodes.Jmp
static readonly OpCode Jmp
Exits current method and jumps to specified method.
Definition: OpCodes.cs:164

System.Reflection.Emit.OpCodes.Ldind_I8
static readonly OpCode Ldind_I8
Loads a value of type int64 as an int64 onto the evaluation stack indirectly.
Definition: OpCodes.cs:312

System.Reflection.Emit.OpCodes.Prefix7
static readonly OpCode Prefix7
This is a reserved instruction.
Definition: OpCodes.cs:777

System.Reflection.Emit.OpCodes.Bgt_S
static readonly OpCode Bgt_S
Transfers control to a target instruction (short form) if the first value is greater than the second ...
Definition: OpCodes.cs:200

System.Reflection.Emit.OpCodes.Ldind_I
static readonly OpCode Ldind_I
Loads a value of type native int as a native int onto the evaluation stack indirectly.
Definition: OpCodes.cs:316

System.Reflection.Emit.OpCodes.Conv_Ovf_I4_Un
static readonly OpCode Conv_Ovf_I4_Un
Converts the unsigned value on top of the evaluation stack to signed int32, throwing T:System....
Definition: OpCodes.cs:529

System.Reflection.Emit.OpCodes.Ble_Un
static readonly OpCode Ble_Un
Transfers control to a target instruction if the first value is less than or equal to the second valu...
Definition: OpCodes.cs:276

System.Reflection.Emit.OpCodes.Ble_Un_S
static readonly OpCode Ble_Un_S
Transfers control to a target instruction (short form) if the first value is less than or equal to th...
Definition: OpCodes.cs:224

System.Reflection.Emit.OpCodes.Bne_Un
static readonly OpCode Bne_Un
Transfers control to a target instruction when two unsigned integer values or unordered float values ...
Definition: OpCodes.cs:264

System.Reflection.Emit.OpCodes.Conv_Ovf_U
static readonly OpCode Conv_Ovf_U
Converts the signed value on top of the evaluation stack to unsigned native int, throwing T:System....
Definition: OpCodes.cs:729

System.Reflection.Emit.OpCodes.Ldloc_S
static readonly OpCode Ldloc_S
Loads the local variable at a specific index onto the evaluation stack, short form.
Definition: OpCodes.cs:80

System.Reflection.Emit.OpCodes.Brfalse_S
static readonly OpCode Brfalse_S
Transfers control to a target instruction if value  is false, a null reference, or zero.
Definition: OpCodes.cs:184

System.Reflection.Emit.OpCodes.Refanyval
static readonly OpCode Refanyval
Retrieves the address (type &) embedded in a typed reference.
Definition: OpCodes.cs:697

System.Reflection.Emit.OpCodes.Starg_S
static readonly OpCode Starg_S
Stores the value on top of the evaluation stack in the argument slot at a specified index,...
Definition: OpCodes.cs:76

System.Reflection.Emit.OpCodes.Box
static readonly OpCode Box
Converts a value type to an object reference (type O).
Definition: OpCodes.cs:561

System.Reflection.Emit.OpCodes.Call
static readonly OpCode Call
Calls the method indicated by the passed method descriptor.
Definition: OpCodes.cs:168

System.Reflection.Emit.OpCodes.Ldlen
static readonly OpCode Ldlen
Pushes the number of elements of a zero-based, one-dimensional array onto the evaluation stack.
Definition: OpCodes.cs:569

System.Reflection.Emit.OpCodes.Stloc_1
static readonly OpCode Stloc_1
Pops the current value from the top of the evaluation stack and stores it in a the local variable lis...
Definition: OpCodes.cs:56

System.Reflection.Emit.OpCodes.Rem_Un
static readonly OpCode Rem_Un
Divides two unsigned values and pushes the remainder onto the evaluation stack.
Definition: OpCodes.cs:384

System.Reflection.Emit.OpCodes.Ldsfld
static readonly OpCode Ldsfld
Pushes the value of a static field onto the evaluation stack.
Definition: OpCodes.cs:505

System.Reflection.Emit.OpCodes.Isinst
static readonly OpCode Isinst
Tests whether an object reference (type O) is an instance of a particular class.
Definition: OpCodes.cs:477

System.Reflection.Emit.OpCodes.Mul_Ovf
static readonly OpCode Mul_Ovf
Multiplies two integer values, performs an overflow check, and pushes the result onto the evaluation ...
Definition: OpCodes.cs:741

System.Reflection.Emit.OpCodes.Conv_Ovf_I1
static readonly OpCode Conv_Ovf_I1
Converts the signed value on top of the evaluation stack to signed int8 and extends it to int32,...
Definition: OpCodes.cs:665

System.Reflection.Emit.OpCodes.Ldc_I4_S
static readonly OpCode Ldc_I4_S
Pushes the supplied int8 value onto the evaluation stack as an int32, short form.
Definition: OpCodes.cs:136

System.Reflection.Emit.OpCodes.Stelem_R4
static readonly OpCode Stelem_R4
Replaces the array element at a given index with the float32 value on the evaluation stack.
Definition: OpCodes.cs:641

System.Reflection.Emit.OpCodes.Ldind_I2
static readonly OpCode Ldind_I2
Loads a value of type int16 as an int32 onto the evaluation stack indirectly.
Definition: OpCodes.cs:296

System.Reflection.Emit.OpCodes
Provides field representations of the Microsoft Intermediate Language (MSIL) instructions for emissio...
Definition: OpCodes.cs:8

System.Reflection.Emit.OpCodes.Calli
static readonly OpCode Calli
Calls the method indicated on the evaluation stack (as a pointer to an entry point) with arguments de...
Definition: OpCodes.cs:172

System.Reflection.Emit.OpCodes.Shl
static readonly OpCode Shl
Shifts an integer value to the left (in zeroes) by a specified number of bits, pushing the result ont...
Definition: OpCodes.cs:400

System.Reflection.Emit.OpCodes.Stelem_I2
static readonly OpCode Stelem_I2
Replaces the array element at a given index with the int16 value on the evaluation stack.
Definition: OpCodes.cs:629

System.Reflection.Emit.OpCodes.Conv_U
static readonly OpCode Conv_U
Converts the value on top of the evaluation stack to unsigned native int, and extends it to native in...
Definition: OpCodes.cs:773

System.Reflection.Emit.OpCodes.Ldc_I4_M1
static readonly OpCode Ldc_I4_M1
Pushes the integer value of -1 onto the evaluation stack as an int32.
Definition: OpCodes.cs:96

System.Reflection.Emit.OpCodes.Ldloc_1
static readonly OpCode Ldloc_1
Loads the local variable at index 1 onto the evaluation stack.
Definition: OpCodes.cs:40

System.Reflection.Emit.OpCodes.Ceq
static readonly OpCode Ceq
Compares two values. If they are equal, the integer value 1 (int32) is pushed onto the evaluation sta...
Definition: OpCodes.cs:813

System.Reflection.Emit.OpCodes.Ldarga
static readonly OpCode Ldarga
Load an argument address onto the evaluation stack.
Definition: OpCodes.cs:845

System.Reflection.Emit.OpCodes.Ldind_U2
static readonly OpCode Ldind_U2
Loads a value of type unsigned int16 as an int32 onto the evaluation stack indirectly.
Definition: OpCodes.cs:300

System.Reflection.Emit.OpCodes.Conv_Ovf_U_Un
static readonly OpCode Conv_Ovf_U_Un
Converts the unsigned value on top of the evaluation stack to unsigned native int,...
Definition: OpCodes.cs:557

System.Reflection.Emit.OpCodes.Ldnull
static readonly OpCode Ldnull
Pushes a null reference (type O) onto the evaluation stack.
Definition: OpCodes.cs:92

System.Reflection.Emit.OpCodes.Bge
static readonly OpCode Bge
Transfers control to a target instruction if the first value is greater than or equal to the second v...
Definition: OpCodes.cs:248

System.Reflection.Emit.OpCodes.Conv_Ovf_I2
static readonly OpCode Conv_Ovf_I2
Converts the signed value on top of the evaluation stack to signed int16 and extending it to int32,...
Definition: OpCodes.cs:673

System.Reflection.Emit.OpCodes.Ldarg_1
static readonly OpCode Ldarg_1
Loads the argument at index 1 onto the evaluation stack.
Definition: OpCodes.cs:24

System.Reflection.Emit.OpCodes.Sub_Ovf_Un
static readonly OpCode Sub_Ovf_Un
Subtracts one unsigned integer value from another, performs an overflow check, and pushes the result ...
Definition: OpCodes.cs:753

System.Reflection.Emit.OpCodes.Ldind_R4
static readonly OpCode Ldind_R4
Loads a value of type float32 as a type F (float) onto the evaluation stack indirectly.
Definition: OpCodes.cs:320

System.Reflection.Emit.OpCodes.Rem
static readonly OpCode Rem
Divides two values and pushes the remainder onto the evaluation stack.
Definition: OpCodes.cs:380

System.Reflection.Emit.OpCodes.Newarr
static readonly OpCode Newarr
Pushes an object reference to a new zero-based, one-dimensional array whose elements are of a specifi...
Definition: OpCodes.cs:565

System.Reflection.Emit.OpCodes.Ldelem_R4
static readonly OpCode Ldelem_R4
Loads the element with type float32 at a specified array index onto the top of the evaluation stack a...
Definition: OpCodes.cs:609

System.Reflection.Emit.OpCodes.Ldc_I4_3
static readonly OpCode Ldc_I4_3
Pushes the integer value of 3 onto the evaluation stack as an int32.
Definition: OpCodes.cs:112

System.Reflection.Emit.OpCodes.Initobj
static readonly OpCode Initobj
Initializes each field of the value type at a specified address to a null reference or a 0 of the app...
Definition: OpCodes.cs:885

System.Reflection.Emit.OpCodes.Add_Ovf_Un
static readonly OpCode Add_Ovf_Un
Adds two unsigned integer values, performs an overflow check, and pushes the result onto the evaluati...
Definition: OpCodes.cs:737

System.Reflection.Emit.OpCodes.Ldfld
static readonly OpCode Ldfld
Finds the value of a field in the object whose reference is currently on the evaluation stack.
Definition: OpCodes.cs:493

System.Reflection.Emit.OpCodes.Ldarga_S
static readonly OpCode Ldarga_S
Load an argument address, in short form, onto the evaluation stack.
Definition: OpCodes.cs:72

System.Reflection.Emit.OpCodes.Ldloc_3
static readonly OpCode Ldloc_3
Loads the local variable at index 3 onto the evaluation stack.
Definition: OpCodes.cs:48

System.Reflection.Emit.OpCodes.Blt
static readonly OpCode Blt
Transfers control to a target instruction if the first value is less than the second value.
Definition: OpCodes.cs:260

System.Reflection.Emit.OpCode
Describes an intermediate language (IL) instruction.
Definition: OpCode.cs:9

System.Reflection.Emit.OpCodes.Stloc_S
static readonly OpCode Stloc_S
Pops the current value from the top of the evaluation stack and stores it in a the local variable lis...
Definition: OpCodes.cs:88

System.Reflection.Emit.OpCodes.Ldftn
static readonly OpCode Ldftn
Pushes an unmanaged pointer (type native int) to the native code implementing a specific method onto ...
Definition: OpCodes.cs:833

System.Reflection.Emit.OpCodes.Ldc_R8
static readonly OpCode Ldc_R8
Pushes a supplied value of type float64 onto the evaluation stack as type F (float).
Definition: OpCodes.cs:152

System.Reflection.Emit.OpCodes.Bgt
static readonly OpCode Bgt
Transfers control to a target instruction if the first value is greater than the second value.
Definition: OpCodes.cs:252

System.Reflection.Emit.OpCodes.Cpobj
static readonly OpCode Cpobj
Copies the value type located at the address of an object (type &, * or native int) to the address of...
Definition: OpCodes.cs:456

System.Reflection.Emit.OpCodes.Leave_S
static readonly OpCode Leave_S
Exits a protected region of code, unconditionally transferring control to a target instruction (short...
Definition: OpCodes.cs:765

System.Reflection.Emit.OpCodes.Castclass
static readonly OpCode Castclass
Attempts to cast an object passed by reference to the specified class.
Definition: OpCodes.cs:473

System.Reflection.Emit.OpCodes.Callvirt
static readonly OpCode Callvirt
Calls a late-bound method on an object, pushing the return value onto the evaluation stack.
Definition: OpCodes.cs:452

System.Reflection.Emit.OpCodes.Conv_Ovf_I8_Un
static readonly OpCode Conv_Ovf_I8_Un
Converts the unsigned value on top of the evaluation stack to signed int64, throwing T:System....
Definition: OpCodes.cs:533

System.Reflection.Emit.OpCodes.Stind_I1
static readonly OpCode Stind_I1
Stores a value of type int8 at a supplied address.
Definition: OpCodes.cs:336

System.Reflection.Emit.OpCodes.Dup
static readonly OpCode Dup
Copies the current topmost value on the evaluation stack, and then pushes the copy onto the evaluatio...
Definition: OpCodes.cs:156

System.Reflection.Emit.OpCodes.Bge_S
static readonly OpCode Bge_S
Transfers control to a target instruction (short form) if the first value is greater than or equal to...
Definition: OpCodes.cs:196

System.Reflection.Emit.OpCodes.Ldvirtftn
static readonly OpCode Ldvirtftn
Pushes an unmanaged pointer (type native int) to the native code implementing a particular virtual me...
Definition: OpCodes.cs:837

System.Reflection.Emit.OpCodes.Ldloc
static readonly OpCode Ldloc
Loads the local variable at a specific index onto the evaluation stack.
Definition: OpCodes.cs:853

System.Reflection.Emit.OpCodes.Switch
static readonly OpCode Switch
Implements a jump table.
Definition: OpCodes.cs:284

System.Reflection.Emit.OpCodes.Shr
static readonly OpCode Shr
Shifts an integer value (in sign) to the right by a specified number of bits, pushing the result onto...
Definition: OpCodes.cs:404

System.Reflection.Emit.OpCodes.Pop
static readonly OpCode Pop
Removes the value currently on top of the evaluation stack.
Definition: OpCodes.cs:160

System.Reflection.Emit.OpCodes.Blt_Un
static readonly OpCode Blt_Un
Transfers control to a target instruction if the first value is less than the second value,...
Definition: OpCodes.cs:280

System.Reflection.Emit.OpCodes.Stelem_I1
static readonly OpCode Stelem_I1
Replaces the array element at a given index with the int8 value on the evaluation stack.
Definition: OpCodes.cs:625

System.Reflection.Emit.OpCodes.Beq
static readonly OpCode Beq
Transfers control to a target instruction if two values are equal.
Definition: OpCodes.cs:244

System.Reflection.Emit.OpCodes.Conv_I1
static readonly OpCode Conv_I1
Converts the value on top of the evaluation stack to int8, then extends (pads) it to int32.
Definition: OpCodes.cs:420

System.Reflection.Emit.OpCodes.Sizeof
static readonly OpCode Sizeof
Pushes the size, in bytes, of a supplied value type onto the evaluation stack.
Definition: OpCodes.cs:905

System.Reflection.Emit.OpCodes.Ldelem_I1
static readonly OpCode Ldelem_I1
Loads the element with type int8 at a specified array index onto the top of the evaluation stack as a...
Definition: OpCodes.cs:577

System.Reflection.Emit.OpCodes.Ldc_I4_7
static readonly OpCode Ldc_I4_7
Pushes the integer value of 7 onto the evaluation stack as an int32.
Definition: OpCodes.cs:128

System.Reflection.Emit.OpCodes.Brtrue_S
static readonly OpCode Brtrue_S
Transfers control to a target instruction (short form) if value  is true, not null,...
Definition: OpCodes.cs:188

System.Reflection.Emit.OpCodes.Ldloc_0
static readonly OpCode Ldloc_0
Loads the local variable at index 0 onto the evaluation stack.
Definition: OpCodes.cs:36

System.Reflection.Emit.OpCodes.Ckfinite
static readonly OpCode Ckfinite
Throws T:System.ArithmeticException if value is not a finite number.
Definition: OpCodes.cs:701

System.Reflection.Emit.OpCodes.Xor
static readonly OpCode Xor
Computes the bitwise XOR of the top two values on the evaluation stack, pushing the result onto the e...
Definition: OpCodes.cs:396

System.Reflection.Emit.OpCodes.Ldc_I4
static readonly OpCode Ldc_I4
Pushes a supplied value of type int32 onto the evaluation stack as an int32.
Definition: OpCodes.cs:140

System.Reflection.Emit.OpCodes.Leave
static readonly OpCode Leave
Exits a protected region of code, unconditionally transferring control to a specific target instructi...
Definition: OpCodes.cs:761

System.Reflection.Emit.OpCodes.Ldc_I4_0
static readonly OpCode Ldc_I4_0
Pushes the integer value of 0 onto the evaluation stack as an int32.
Definition: OpCodes.cs:100

System.Reflection.Emit.OpCodes.Localloc
static readonly OpCode Localloc
Allocates a certain number of bytes from the local dynamic memory pool and pushes the address (a tran...
Definition: OpCodes.cs:865

System.Reflection.Emit.OpCodes.Newobj
static readonly OpCode Newobj
Creates a new object or a new instance of a value type, pushing an object reference (type O) onto the...
Definition: OpCodes.cs:468

System.Reflection.Emit.OpCodes.Stobj
static readonly OpCode Stobj
Copies a value of a specified type from the evaluation stack into a supplied memory address.
Definition: OpCodes.cs:517

System.Reflection.Emit.OpCodes.Readonly
static readonly OpCode Readonly
Specifies that the subsequent array address operation performs no type check at run time,...
Definition: OpCodes.cs:913

System.Reflection.Emit.OpCodes.Stloc_2
static readonly OpCode Stloc_2
Pops the current value from the top of the evaluation stack and stores it in a the local variable lis...
Definition: OpCodes.cs:60

System.Reflection.Emit.OpCodes.Prefixref
static readonly OpCode Prefixref
This is a reserved instruction.
Definition: OpCodes.cs:805

System.Reflection.Emit.OpCodes.Ldelem_U2
static readonly OpCode Ldelem_U2
Loads the element with type unsigned int16 at a specified array index onto the top of the evaluation ...
Definition: OpCodes.cs:589

System.Reflection.Emit.OpCodes.Ble_S
static readonly OpCode Ble_S
Transfers control to a target instruction (short form) if the first value is less than or equal to th...
Definition: OpCodes.cs:204

System.Reflection.Emit.OpCodes.Ldstr
static readonly OpCode Ldstr
Pushes a new object reference to a string literal stored in the metadata.
Definition: OpCodes.cs:464

System.Reflection.Emit.OpCodes.Div_Un
static readonly OpCode Div_Un
Divides two unsigned integer values and pushes the result (int32) onto the evaluation stack.
Definition: OpCodes.cs:376

System.Reflection.Emit.OpCodes.Ldc_I4_6
static readonly OpCode Ldc_I4_6
Pushes the integer value of 6 onto the evaluation stack as an int32.
Definition: OpCodes.cs:124

System.Reflection.Emit.OpCodes.Stloc
static readonly OpCode Stloc
Pops the current value from the top of the evaluation stack and stores it in a the local variable lis...
Definition: OpCodes.cs:861

System.Reflection.Emit.OpCodes.Ldelem_I4
static readonly OpCode Ldelem_I4
Loads the element with type int32 at a specified array index onto the top of the evaluation stack as ...
Definition: OpCodes.cs:593

System.Reflection.Emit.OpCodes.Conv_U2
static readonly OpCode Conv_U2
Converts the value on top of the evaluation stack to unsigned int16, and extends it to int32.
Definition: OpCodes.cs:713

System.Reflection.Emit.OpCodes.Stelem_I
static readonly OpCode Stelem_I
Replaces the array element at a given index with the native int value on the evaluation stack.
Definition: OpCodes.cs:621

System.Reflection.Emit.OpCodes.Ldelem_I8
static readonly OpCode Ldelem_I8
Loads the element with type int64 at a specified array index onto the top of the evaluation stack as ...
Definition: OpCodes.cs:601