using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Threading;

// ReSharper disable InconsistentNaming
// ReSharper disable UnusedMember.Local
// ReSharper disable UnusedParameter.Local
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable EmptyGeneralCatchClause
// ReSharper disable RedundantCast
// ReSharper disable PossibleNullReferenceException
// ReSharper disable AssignNullToNotNullAttribute
// ReSharper disable UnusedMember.Global

namespace UnitTestProject.RefVm
{
    // Token: 0x02000032 RID: 50
    public class VmExecutor // \u0006\u2007
    {
        #region subclasses

	    // Token: 0x02000033 RID: 51
	    [Serializable]
	    private sealed class CatchBlockComparer // \u0002
        {
		    // Token: 0x060002B0 RID: 688 RVA: 0x00012EB4 File Offset: 0x000110B4
		    internal int Compare(CatchBlock v1, CatchBlock v2) // \u0002
            {
			    if (v1.ExcTypeId == v2.ExcTypeId)
			    {
				    return v2.Start.CompareTo(v1.Start);
			    }
			    return v1.ExcTypeId.CompareTo(v2.ExcTypeId);
		    }

		    // Token: 0x04000155 RID: 341
		    public static readonly CatchBlockComparer Instance = new CatchBlockComparer(); // \u0002

		    // Token: 0x04000156 RID: 342
		    public static Comparison<CatchBlock> MyComparison; // \u0003
	    }

        // Token: 0x02000038 RID: 56
        private sealed class StringTypePair // \u0006
        {
            // Token: 0x060002C0 RID: 704 RVA: 0x00013020 File Offset: 0x00011220
            // Token: 0x060002C1 RID: 705 RVA: 0x00013028 File Offset: 0x00011228
            // Token: 0x0400015D RID: 349
            public string Str { get; set; } // \u0002

            // Token: 0x060002C3 RID: 707 RVA: 0x0001303C File Offset: 0x0001123C
            // Token: 0x060002C2 RID: 706 RVA: 0x00013034 File Offset: 0x00011234
            // Token: 0x0400015E RID: 350
            public Type T { get; set; } // \u0002
        }

        // Token: 0x02000039 RID: 57
        // (Invoke) Token: 0x060002C5 RID: 709
        private delegate object DynamicExecutor(object obj, object[] args); // \u0008

        // Token: 0x0200003A RID: 58
        // (Invoke) Token: 0x060002C9 RID: 713
        internal delegate void VmInstrImpl(VariantBase t); // \u000E

        // Token: 0x0200003B RID: 59
        private sealed class VmInstr // \u000F
        {
            // Token: 0x060002CC RID: 716 RVA: 0x00013048 File Offset: 0x00011248
            public VmInstr(VmInstrInfo id, VmInstrImpl func)
            {
                Id = id;
                Func = func;
            }

            // Token: 0x0400015F RID: 351
            public readonly VmInstrInfo Id; // \u0002

            // Token: 0x04000160 RID: 352
            public readonly VmInstrImpl Func; // \u0003
        }

        // Token: 0x02000037 RID: 55
        private sealed class ExcHandlerFrame // \u0005
        {
            // Token: 0x060002BB RID: 699 RVA: 0x00012FF0 File Offset: 0x000111F0
            // Token: 0x060002BC RID: 700 RVA: 0x00012FF8 File Offset: 0x000111F8
            // Token: 0x0400015B RID: 347
            public uint Pos { get; set; }

            // Token: 0x060002BD RID: 701 RVA: 0x00013004 File Offset: 0x00011204
            // Token: 0x060002BE RID: 702 RVA: 0x0001300C File Offset: 0x0001120C
            // Token: 0x0400015C RID: 348
            public object Exception { get; set; }
        }

        // Token: 0x02000034 RID: 52
        internal struct MethodBaseAndVirtual : IEquatable<MethodBaseAndVirtual> // \u0002\u2000
        {
            public MethodBaseAndVirtual(MethodBase mb, bool isVirtual)
            {
                Val = mb;
                IsVirtual = isVirtual;
            }

            // Token: 0x060002B1 RID: 689 RVA: 0x00012EF8 File Offset: 0x000110F8
            // Token: 0x060002B2 RID: 690 RVA: 0x00012F00 File Offset: 0x00011100
            // Token: 0x04000157 RID: 343
            public MethodBase Val /* \u0002 */ { get; }

            // Token: 0x060002B3 RID: 691 RVA: 0x00012F0C File Offset: 0x0001110C
            // Token: 0x060002B4 RID: 692 RVA: 0x00012F14 File Offset: 0x00011114
            // Token: 0x04000158 RID: 344
            public bool IsVirtual /* \u0003 */ { get; }

            // Token: 0x060002B5 RID: 693 RVA: 0x00012F20 File Offset: 0x00011120
            public override int GetHashCode()
            {
                return Val.GetHashCode() ^ IsVirtual.GetHashCode();
            }

            // Token: 0x060002B6 RID: 694 RVA: 0x00012F48 File Offset: 0x00011148
            public override bool Equals(object o)
            {
                if (o is MethodBaseAndVirtual)
                {
                    return Equals((MethodBaseAndVirtual)o);
                }
                return false;
            }

            // Token: 0x060002B7 RID: 695 RVA: 0x00012F70 File Offset: 0x00011170
            public bool Equals(MethodBaseAndVirtual val)
            {
                return IsVirtual == val.IsVirtual && Val == val.Val;
            }
        }

        // Token: 0x02000035 RID: 53
        private struct BoolHolder // \u0003
        {
            // Token: 0x04000159 RID: 345
            public bool Val; // \u0002
        }

        // Token: 0x02000036 RID: 54
        private sealed class IntToTypeComparer<T> : IComparer<KeyValuePair<int, T>> // \u0003\u2000
        {
            // Token: 0x060002B8 RID: 696 RVA: 0x00012F94 File Offset: 0x00011194
            public IntToTypeComparer(Comparison<T> c)
            {
                _c = c;
            }

            // Token: 0x060002B9 RID: 697 RVA: 0x00012FA4 File Offset: 0x000111A4
            public int Compare(KeyValuePair<int, T> v1, KeyValuePair<int, T> v2)
            {
                var num = _c(v1.Value, v2.Value);
                if (num == 0)
                {
                    return v2.Key.CompareTo(v1.Key);
                }
                return num;
            }

            // Token: 0x0400015A RID: 346
            private readonly Comparison<T> _c;
        }

        // Token: 0x0200000B RID: 11
        private static class HiByte // \u0002\u2008
        {
            // Token: 0x06000056 RID: 86 RVA: 0x00003154 File Offset: 0x00001354
            public static int Extract(int src) // \u0002
            {
                return src & -16777216; // 0xFF000000
            }
        }

        #endregion

        #region members
        // Token: 0x04000132 RID: 306
        private static readonly Type MethodBaseType = typeof(MethodBase); // \u0002\u2001

	    // Token: 0x04000133 RID: 307
	    private VmMethodHeader _methodHeader; // \u000E

	    // Token: 0x04000134 RID: 308
	    private readonly MyCollection<VariantBase> _evalStack = new MyCollection<VariantBase>(); // \u0003\u2003

	    // Token: 0x04000135 RID: 309
	    private readonly Dictionary<int, object> AllMetadataById = new Dictionary<int, object>(); // \u0006\u2003

	    // Token: 0x04000136 RID: 310
	    private readonly VmInstrCodesDb _instrCodesDb; // \u0006\u2001

        // Token: 0x04000137 RID: 311
        private object _exception; // \u0006\u2002

	    // Token: 0x04000138 RID: 312
	    private readonly Dictionary<MethodBase, object> _mbDynamicLock = new Dictionary<MethodBase, object>(); // \u0008\u2002

	    // Token: 0x04000139 RID: 313
        private BinaryReader _srcVirtualizedStreamReader; // \u0002\u2000

	    // Token: 0x0400013A RID: 314
	    private Type _currentClass; // \u000F\u2001

	    // Token: 0x0400013B RID: 315
	    private static readonly Type AssemblyType = typeof(Assembly); // \u0002\u2003

	    // Token: 0x0400013C RID: 316
	    private readonly Dictionary<MethodBase, int> _mbCallCnt = new Dictionary<MethodBase, int>(256); // \u0006

	    // Token: 0x0400013D RID: 317
	    private Stream _srcVirtualizedStream; // \u000F\u2000

        // Token: 0x0400013E RID: 318
        private object[] _callees; // \u0005\u2000

	    // Token: 0x0400013F RID: 319
	    private readonly MyCollection<ExcHandlerFrame> _ehStack = new MyCollection<ExcHandlerFrame>(); // \u000F

	    // Token: 0x04000140 RID: 320
	    private VariantBase[] _localVariables; // \u0003\u2002

	    // Token: 0x04000141 RID: 321
	    private readonly Dictionary<MethodBaseAndVirtual, DynamicExecutor> _dynamicExecutors = new Dictionary<MethodBaseAndVirtual, DynamicExecutor>(256); // \u0002\u2002

	    // Token: 0x04000142 RID: 322
	    private bool _retFound; // \u0005\u2003

	    // Token: 0x04000143 RID: 323
	    private MyBufferReader _myBufferReader; // \u0002

	    // Token: 0x04000144 RID: 324
	    private Type[] _classGenericArgs; // \u0003

	    // Token: 0x04000145 RID: 325
	    private readonly Module _module; // \u0008\u2001

        // Token: 0x04000146 RID: 326
        private long _myBufferPos; // \u0005

	    // Token: 0x04000147 RID: 327
	    private byte[] _methodBody; // \u0008

        // Token: 0x04000148 RID: 328
        private static readonly Type ObjectArrayType = typeof(object[]); // \u000E\u2001

	    // Token: 0x04000149 RID: 329
	    private static readonly Dictionary<MethodBase, DynamicMethod> DynamicMethods = new Dictionary<MethodBase, DynamicMethod>(); // \u000E\u2003

	    // Token: 0x0400014A RID: 330
	    private bool _wasException; // \u0008\u2000

	    // Token: 0x0400014B RID: 331
	    private Type[] _methodGenericArgs; // \u0005\u2001

	    // Token: 0x0400014C RID: 332
	    private CatchBlock[] _catchBlocks; // \u000F\u2003

	    // Token: 0x0400014D RID: 333
	    private static readonly object InterlockedLock = new object(); // \u0008\u2003

	    // Token: 0x0400014E RID: 334
	    private uint? _storedPos; // \u000E\u2000

	    // Token: 0x0400014F RID: 335
	    private const bool _alwaysFalse = false; // \u000F\u2002

	    // Token: 0x04000150 RID: 336
	    private Dictionary<int, VmInstr> _vmInstrDb; // \u000E\u2002

        // Token: 0x04000151 RID: 337
        private VariantBase[] _variantOutputArgs; // \u0005\u2002

	    // Token: 0x04000152 RID: 338
	    private const bool _alwaysTrue = true; // \u0003\u2001

	    // Token: 0x04000153 RID: 339
	    private static readonly Type IntPtrType = typeof(IntPtr); // \u0003\u2000

	    // Token: 0x04000154 RID: 340
	    private static readonly Type VoidType = typeof(void); // \u0006\u2000
       
        #endregion

        // Token: 0x0600016C RID: 364 RVA: 0x00007958 File Offset: 0x00005B58
        public VmExecutor(VmInstrCodesDb instrCodesDb, Module m)
	    {
            _instrCodesDb = instrCodesDb;
		    _module = m;
		    Init();
	    }

	    // Token: 0x060001B6 RID: 438 RVA: 0x000092E0 File Offset: 0x000074E0
	    private void Init() // \u000F
        {
		    if (!_instrCodesDb.IsInitialized())
		    {
			    lock (_instrCodesDb)
			    {
				    if (!_instrCodesDb.IsInitialized())
				    {
					    _vmInstrDb = CreateVmInstrDb();
					    DoNothing();
					    _instrCodesDb.SetInitialized(true);
				    }
			    }
		    }
		    if (_vmInstrDb == null)
		    {
			    _vmInstrDb = CreateVmInstrDb();
		    }
	    }

        // Token: 0x060001BD RID: 445 RVA: 0x00009534 File Offset: 0x00007734
        private void DoNothing() // \u0006
        {}

        // Token: 0x06000239 RID: 569 RVA: 0x0000F9C4 File Offset: 0x0000DBC4
        private VariantBase PopVariant() // \u0002
        {
		    return _evalStack.PopBack();
	    }

        // Token: 0x060002A0 RID: 672 RVA: 0x000127D8 File Offset: 0x000109D8
        private long PopLong() // \u0002
        {
            var top = PopVariant();
            switch (top.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum: return VariantBase.SignedLongFromEnum((EnumVariant)top); // bug was fixed and unit tested (Convert.ToInt64(((EnumVariant)top).GetValue());)
                case VariantBase.Vtc.Tc13UIntPtr: return (long)((UIntPtrVariant)top).GetValue().ToUInt64();
                case VariantBase.Vtc.Tc17IntPtr: return ((IntPtrVariant)top).GetValue().ToInt64();
                case VariantBase.Vtc.Tc19Int: return ((IntVariant)top).GetValue();
            }
            throw new Exception(StringDecryptor.GetString(-1550345551) /* Unexpected value on the stack. */);
        }

        // Token: 0x060001A1 RID: 417 RVA: 0x00008CC4 File Offset: 0x00006EC4
        private void Ldelem(Type t) // \u0002 
        {
            var index = PopLong();
            var array = (Array)PopVariant().GetValueAbstract();
            PushVariant(VariantFactory.Convert(array.GetValue(index), t));
        }

        // Token: 0x0600020C RID: 524 RVA: 0x0000C528 File Offset: 0x0000A728
        private void Ldelem_(VariantBase vTypeId) // \u0006\u200A\u2000
        {
            var typeId = ((IntVariant)vTypeId).GetValue();
            var type = GetTypeById(typeId);
            Ldelem(type);
        }

        // Token: 0x060002A5 RID: 677 RVA: 0x00012A80 File Offset: 0x00010C80
        private void PushVariant(VariantBase obj) // \u0008\u2000\u2001
        {
		    if (obj == null)
		    {
			    throw new ArgumentNullException(StringDecryptor.GetString(-1550345950) /* obj */);
		    }
		    VariantBase push;
		    if (obj.GetVariantType() != null)
		    {
			    push = obj;
		    }
		    else
		    {
			    switch (obj.GetTypeCode())
			    {
			        case VariantBase.Vtc.Tc1Bool:
			        {
				        var tmp = new IntVariant();
				        tmp.SetValue(((BoolVariant)obj).GetValue() ? 1 : 0);
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc6Char:
			        {
				        var tmp = new IntVariant();
				        tmp.SetValue(((CharVariant)obj).GetValue());
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc7Ulong:
			        {
				        var tmp = new LongVariant();
				        tmp.SetValue((long)((UlongVariant)obj).GetValue());
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc8Float:
			        {
				        var tmp = new FloatVariant();
				        tmp.SetValue(((FloatVariant)obj).GetValue());
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc9Uint:
			        {
				        var tmp = new IntVariant();
				        tmp.SetValue((int)((UintVariant)obj).GetValue());
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc10Ushort:
			        {
				        var tmp = new IntVariant();
				        tmp.SetValue(((UshortVariant)obj).GetValue());
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc12Sbyte:
			        {
				        var tmp = new IntVariant();
				        tmp.SetValue(((SbyteVariant)obj).GetValue());
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc14Byte:
			        {
				        var tmp = new IntVariant();
				        tmp.SetValue(((ByteVariant)obj).GetValue());
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc15Short:
			        {
				        var tmp = new IntVariant();
				        tmp.SetValue(((ShortVariant)obj).GetValue());
				        tmp.SetVariantType(obj.GetVariantType());
				        push = tmp;
				        break;
			        }
			        case VariantBase.Vtc.Tc18Object:
			        {
				        var abs = obj.GetValueAbstract();
				        if (abs == null)
				        {
					        push = obj;
					        break;
				        }
				        var type = abs.GetType();
				        if (type.HasElementType && !type.IsArray)
				        {
					        type = type.GetElementType();
				        }
				        if (type != null && !type.IsValueType && !type.IsEnum)
				        {
					        push = obj;
					        break;
				        }
				        push = VariantFactory.Convert(abs, type);
				        break;
			        }
                    case VariantBase.Vtc.Tc17IntPtr:
                    case VariantBase.Vtc.Tc13UIntPtr:
                        if(IntPtr.Size == 4)
                        {
                            var tmp = new IntVariant();
                            tmp.CopyFrom(obj);
                            tmp.SetVariantType(obj.GetVariantType());
                            push = tmp;
                        }
                        else
                        {
                            var tmp = new LongVariant();
                            tmp.CopyFrom(obj);
                            tmp.SetVariantType(obj.GetVariantType());
                            push = tmp;
                        }
                        break;
                    default:
			            push = obj;
                        break;
			    }
            }
		    _evalStack.PushBack(push);
	    }

	    // Token: 0x0600027D RID: 637 RVA: 0x00011C24 File Offset: 0x0000FE24
	    private void Conv_ovf_i4_un_(VariantBase dummy) // \u0003\u200B
        {
		    Conv_i4(true, false);
	    }

	    // Token: 0x06000283 RID: 643 RVA: 0x00011E9C File Offset: 0x0001009C
	    public static void Sort<T>(T[] arr, Comparison<T> c) // \u0002
        {
		    var array = new KeyValuePair<int, T>[arr.Length];
		    for (var i = 0; i < arr.Length; i++)
		    {
			    array[i] = new KeyValuePair<int, T>(i, arr[i]);
		    }
		    Array.Sort(array, arr, new IntToTypeComparer<T>(c));
	    }
	    
        // Token: 0x060001BE RID: 446 RVA: 0x00009538 File Offset: 0x00007738
	    private void SortCatchBlocks() // \u0003\u2000
	    {
		    if (CatchBlockComparer.MyComparison == null)
		    {
			    CatchBlockComparer.MyComparison = CatchBlockComparer.Instance.Compare;
		    }
		    Sort(_catchBlocks, CatchBlockComparer.MyComparison);
	    }

	    // Token: 0x0600016D RID: 365 RVA: 0x000079C8 File Offset: 0x00005BC8
	    public VmExecutor(VmInstrCodesDb instrCodesDb, Stream virtualizedStream = null) : this(instrCodesDb, typeof(VmExecutor).Module) // \u0006\u2007
        {
            _srcVirtualizedStream = virtualizedStream;
        }

        // Token: 0x0600023C RID: 572 RVA: 0x0000FA0C File Offset: 0x0000DC0C
        public object Invoke(Stream virtualizedStream, string pos, object[] args) // \u0002
        {
            // ReSharper disable once IntroduceOptionalParameters.Global
            return Invoke(virtualizedStream, pos, args, null, null, null);
        }

	    // Token: 0x0600017A RID: 378 RVA: 0x00007DCC File Offset: 0x00005FCC
	    public object Invoke(Stream virtualizedStream, string pos, object[] args, Type[] methodGenericArgs, Type[] classGenericArgs, object[] callees) // \u0002
        {
            _srcVirtualizedStream = virtualizedStream;
		    Seek(pos, virtualizedStream);
		    return Invoke(args, methodGenericArgs, classGenericArgs, callees);
	    }

	    // Token: 0x060001C5 RID: 453 RVA: 0x00009A34 File Offset: 0x00007C34
	    private Type GetTypeById(int id) // \u0002
	    {
		    Type result;
		    lock (AllMetadataById)
		    {
			    var flag = true;
			    object o;
			    if (AllMetadataById.TryGetValue(id, out o))
			    {
				    result = (Type)o;
			    }
			    else
			    {
				    var token = ReadToken(id);
				    if (token.IsVm == 0)
				    {
					    var type = _module.ResolveType(token.MetadataToken);
				        AllMetadataById.Add(id, type);
				        result = type;
				    }
				    else
				    {
					    var vmToken = (VmClassTokenInfo)token.VmToken;
                        if (vmToken.IsOuterClassGeneric)
					    {
						    if (vmToken.OuterClassGenericMethodIdx!= -1)
						    {
                                result = _methodGenericArgs[vmToken.OuterClassGenericMethodIdx];
						    }
						    else
						    {
							    if (vmToken.OuterClassGenericClassIdx== -1)
							    {
								    throw new Exception();
							    }
                                result = _classGenericArgs[vmToken.OuterClassGenericClassIdx];
						    }
                            result = ElementedTypeHelper.PopType(result, ElementedTypeHelper.NestedElementTypes(vmToken.ClassName));
					    }
					    else
					    {
						    var className = vmToken.ClassName.Replace("\u0005 ,", "forms_cil.Trial,"); //TODO: в общем случае это лишнее
                            result = Type.GetType(className);
						    if (result == null)
						    {
							    var num = className.IndexOf(',');
							    var shortClassName = className.Substring(0, num);
							    var asmName = className.Substring(num + 1, className.Length - num - 1).Trim();
							    var assemblies = AppDomain.CurrentDomain.GetAssemblies();
							    foreach (var assembly in assemblies)
							    {
							        string value = null;
							        try
							        {
							            value = assembly.Location;
							        }
							        catch (NotSupportedException)
							        {
							        }
							        if (string.IsNullOrEmpty(value) && assembly.FullName.Equals(asmName, StringComparison.Ordinal))
							        {
                                        result = assembly.GetType(shortClassName);
							            if (result != null)
							            {
							                break;
							            }
							        }
							    }
							    if (result == null && shortClassName.StartsWith(StringDecryptor.GetString(-1550345235) /* <PrivateImplementationDetails>< */, StringComparison.Ordinal) && shortClassName.Contains(StringDecryptor.GetString(-1550345325) /* . */))
							    {
								    try
								    {
								        var types = Assembly.Load(asmName).GetTypes();
								        foreach (var t in types.Where(type3 => type3.FullName == shortClassName))
								        {
								            result = t;
								            break;
								        }
								    }
								        // ReSharper disable once EmptyGeneralCatchClause
								    catch
								    {
								    }
							    }
						    }
						    if (vmToken.IsGeneric)
						    {
							    var array = new Type[vmToken.GenericArguments.Length];
							    for (var j = 0; j < vmToken.GenericArguments.Length; j++)
							    {
								    array[j] = GetTypeById(vmToken.GenericArguments[j].MetadataToken);
							    }
							    var genericTypeDefinition = ElementedTypeHelper.TryGoToElementType(result).GetGenericTypeDefinition();
							    var c = ElementedTypeHelper.NestedElementTypes(result);
                                result = ElementedTypeHelper.PopType(genericTypeDefinition.MakeGenericType(array), c);
							    flag = false;
						    }
						    if (flag)
						    {
							    AllMetadataById.Add(id, result);
						    }
					    }
				    }
			    }
		    }
		    return result;
	    }

	    // Token: 0x060001A6 RID: 422 RVA: 0x00008DAC File Offset: 0x00006FAC
	    public object Invoke(object[] args, Type[] methodGenericArgs, Type[] classGenericArgs, object[] callees) // \u0002
	    {
		    if (args == null)
		    {
                args = EmptyArray<object>.Data;
		    }
		    if (methodGenericArgs == null)
		    {
			    methodGenericArgs = Type.EmptyTypes;
		    }
		    if (classGenericArgs == null)
		    {
			    classGenericArgs = Type.EmptyTypes;
		    }
		    _callees = callees;
		    _methodGenericArgs = methodGenericArgs;
		    _classGenericArgs = classGenericArgs;
		    _variantOutputArgs = ArgsToVariantOutputArgs(args);
            _localVariables = CreateLocalVariables();
            object result;
		    try
		    {
                using (var b = new MyBuffer(_methodBody))
			    {
				    using (_myBufferReader = new MyBufferReader(b))
				    {
					    _retFound = false;
					    _storedPos = null;
					    _evalStack.Clear();
					    InternalInvoke();
				    }
			    }
			    var retType = GetTypeById(_methodHeader.ReturnTypeId);
                if (retType != VoidType && _evalStack.Count > 0)
                {
                    var pop = PopVariant();
                    try
			        {
                        result = VariantFactory.Convert(null, retType).CopyFrom(pop).GetValueAbstract();
                    }
                    catch (Exception)
                    {
                        result = pop.GetValueAbstract(); // example: ckfinite with no numeric
                        //throw;
                    }
			    }
			    else
			    {
				    result = null;
			    }
		    }
		    finally
		    {
			    for (var i = 0; i < _methodHeader.ArgsTypeToOutput.Length; i++)
			    {
				    var argTypeToOutput = _methodHeader.ArgsTypeToOutput[i];
				    if (argTypeToOutput.IsOutput)
				    {
					    var argOutValue = (VariantBaseHolder)_variantOutputArgs[i];
					    var argType = GetTypeById(argTypeToOutput.TypeId);
					    args[i] = VariantFactory.Convert(null, argType.GetElementType()).CopyFrom(argOutValue.GetValue()).GetValueAbstract();
				    }
			    }
			    _callees = null;
			    _variantOutputArgs = null;
			    _localVariables = null;
		    }
		    return result;
	    }

        // Token: 0x06000269 RID: 617 RVA: 0x00010F7C File Offset: 0x0000F17C
        private void Seek(string pos, Stream virtualizedStream) // \u0002
	    {
		    Seek(0L, virtualizedStream, pos);
	    }

        // Token: 0x0600025C RID: 604 RVA: 0x00010B38 File Offset: 0x0000ED38
        private void DoNothing(BinaryReader dummy) // \u0002
        {
        }

	    // Token: 0x06000250 RID: 592 RVA: 0x000106EC File Offset: 0x0000E8EC
	    private static CatchBlock ReadCatchBlock(BinaryReader r) // \u0002
        {
            return new CatchBlock
	        {
	            Kind = r.ReadByte(),
	            ExcTypeId = r.ReadInt32(),
	            Pos = r.ReadUInt32(),
	            PosKind4 = r.ReadUInt32(),
	            Start = r.ReadUInt32(),
	            Len = r.ReadUInt32()
	        };
	    }

	    // Token: 0x060001FC RID: 508 RVA: 0x0000BD50 File Offset: 0x00009F50
	    private static CatchBlock[] ReadCatchBlocks(BinaryReader r) // \u0002
	    {
		    var num = (int)r.ReadInt16();
		    var array = new CatchBlock[num];
		    for (var i = 0; i < num; i++)
		    {
			    array[i] = ReadCatchBlock(r);
		    }
		    return array;
	    }

        // Token: 0x060001BF RID: 447 RVA: 0x00009564 File Offset: 0x00007764
        private static byte[] ReadByteArray(BinaryReader r) // \u0002
	    {
		    var num = r.ReadInt32();
            var array = new byte[num];
		    r.Read(array, 0, num);
		    return array;
	    }

        // Token: 0x060001C1 RID: 449 RVA: 0x000096E4 File Offset: 0x000078E4
        public void Seek(long parsedPos, Stream virtualizedStream, string pos) // \u0002
	    {
		    var input = new VmStreamWrapper(virtualizedStream, VmXorKey());
		    _srcVirtualizedStreamReader = new BinaryReader(input);
		    var baseStream = _srcVirtualizedStreamReader.BaseStream;
		    lock (baseStream)
		    {
			    if (pos != null)
			    {
                    parsedPos = ParsePos(pos);
			    }
			    _srcVirtualizedStreamReader.BaseStream.Seek(parsedPos, SeekOrigin.Begin);
			    DoNothing(_srcVirtualizedStreamReader);
			    _methodHeader = ReadMethodHeader(_srcVirtualizedStreamReader);
			    _catchBlocks = ReadCatchBlocks(_srcVirtualizedStreamReader);
			    SortCatchBlocks();
			    _methodBody = ReadByteArray(_srcVirtualizedStreamReader);
		    }
	    }

	    // Token: 0x06000203 RID: 515 RVA: 0x0000C164 File Offset: 0x0000A364
	    private long ParsePos(string pos) // \u0002
	    {
	        using (var memoryStream = new MemoryStream(VmPosParser.Parse(pos)))
	        {
	            return new BinaryReader(new VmStreamWrapper(memoryStream, PosXorKey())).ReadInt64();
	        }
	    }

	    // Token: 0x060001B5 RID: 437 RVA: 0x000092D8 File Offset: 0x000074D8
	    private int PosXorKey() // \u0002
	    {
		    return -2023764088;
	    }

	    // Token: 0x0600017B RID: 379 RVA: 0x00007DEC File Offset: 0x00005FEC
	    public static int VmXorKey() // \u0003
	    {
		    return 1783652397;
	    }

	    // Token: 0x060001E7 RID: 487 RVA: 0x0000B0F8 File Offset: 0x000092F8
	    private LocalVarType ReadLocalVarType(BinaryReader r) // \u0002
        {
            return new LocalVarType { TypeId = r.ReadInt32() };
	    }

	    // Token: 0x060001AB RID: 427 RVA: 0x00008FF8 File Offset: 0x000071F8
	    private LocalVarType[] ReadLocalVarTypes(BinaryReader r) // \u0002
	    {
		    var array = new LocalVarType[r.ReadInt16()];
		    for (var i = 0; i < array.Length; i++)
		    {
			    array[i] = ReadLocalVarType(r);
		    }
		    return array;
	    }

	    // Token: 0x0600023B RID: 571 RVA: 0x0000F9E0 File Offset: 0x0000DBE0
	    private ArgTypeToOutput ReadArgTypeToOutput(BinaryReader r) // \u0002
	    {
	        var ret = new ArgTypeToOutput
	        {
	            TypeId = r.ReadInt32(),
	            IsOutput = r.ReadBoolean()
	        };
	        return ret;
	    }

	    // Token: 0x06000287 RID: 647 RVA: 0x00012138 File Offset: 0x00010338
	    private ArgTypeToOutput[] ReadArgsTypeToOutput(BinaryReader r) // \u0002
        {
		    var array = new ArgTypeToOutput[r.ReadInt16()];
		    for (var i = 0; i < array.Length; i++)
		    {
			    array[i] = ReadArgTypeToOutput(r);
		    }
		    return array;
	    }

        // Token: 0x06000216 RID: 534 RVA: 0x0000C790 File Offset: 0x0000A990
        private VmMethodHeader ReadMethodHeader(BinaryReader src) // \u0002
        {
            var ret = new VmMethodHeader
            {
                ClassId = src.ReadInt32(),
                ReturnTypeId = src.ReadInt32(),
                LocalVarTypes = ReadLocalVarTypes(src),
                Flags = src.ReadByte(),
                Name = src.ReadString(),
                ArgsTypeToOutput = ReadArgsTypeToOutput(src)
            };
            return ret;
	    }

        // Token: 0x06000266 RID: 614 RVA: 0x00010C54 File Offset: 0x0000EE54
        private void Shr_un_(VariantBase dummy) // \u000F\u2001
	    {
		    PushVariant(Shift(false, false));
	    }

        // Token: 0x06000176 RID: 374 RVA: 0x00007CAC File Offset: 0x00005EAC
        private void Shr_(VariantBase dummy) // \u0005\u2007\u2000
        {
            PushVariant(Shift(false, true));
        }

        private VariantBase Xor(VariantBase org_v1, VariantBase org_v2)
        {
            VariantBase v1, v2;
            var tc = CommonType(org_v1, org_v2, out v1, out v2, true);
            VariantBase ret;
            switch (tc)
            {
                case VariantBase.Vtc.Tc9Uint:
                    uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
                    var uvret = new UintVariant();
                    ret = uvret;
                    uvret.SetValue(uv1 ^ uv2);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
                    var ivret = new IntVariant();
                    ret = ivret;
                    ivret.SetValue(iv1 ^ iv2);
                    break;
                case VariantBase.Vtc.Tc21Double:
                    {
                        /*double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue(); // естественный алгоритм
                        long lv1 = (dv1 < 0) ? (long)dv1 : (long)(ulong)dv1;
                        long lv2 = (dv2 < 0) ? (long)dv2 : (long)(ulong)dv2;
                        var dvret = new DoubleVariant();
                        ret = dvret;
                        var l64 = (ulong) lv1 ^ (ulong) lv2;
                        if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
                        dvret.SetValue(l64);*/
                        var dvret = new DoubleVariant();
                        ret = dvret;
                        dvret.SetValue((4 == IntPtr.Size) ? Double.NaN : (double)0); // иногда у фреймворка бывает мусор, но чаще эти значения...
                    }
                    break;
                case VariantBase.Vtc.Tc8Float:
                    {
                        /*float fv1 = ((FloatVariant) v1).GetValue(), fv2 = ((FloatVariant) v2).GetValue(); // естественный алгоритм
                        long lv1 = (fv1 < 0) ? (long)fv1 : (long)(ulong)fv1;
                        long lv2 = (fv2 < 0) ? (long)fv2 : (long)(ulong)fv2;
                        var fvret = new FloatVariant();
                        ret = fvret;
                        var l64 = (ulong)lv1 ^ (ulong)lv2;
                        if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
                        fvret.SetValue(l64);*/
                        var fvret = new FloatVariant();
                        ret = fvret;
                        fvret.SetValue((4 == IntPtr.Size) ? float.NaN : (float)0.0); // иногда у фреймворка бывает мусор, но чаще эти значения...
                    }
                    break;
                case VariantBase.Vtc.Tc24Long:
                    {
                        long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
                        var lvret = new LongVariant();
                        ret = lvret;
                        lvret.SetValue(lv1 ^ lv2);
                    }
                    break;
                case VariantBase.Vtc.Tc7Ulong:
                    ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
                    var ulvret = new UlongVariant();
                    ret = ulvret;
                    ulvret.SetValue(ulv1 ^ ulv2);
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_1);
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(OpCodes.Xor);
                    gen.Emit(OpCodes.Ret);
                    ret = new IntPtrVariant();
                    ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
                    break;
            }
            return ret;
        }

        // Token: 0x0600026C RID: 620 RVA: 0x00010FC8 File Offset: 0x0000F1C8
        private void Xor_(VariantBase dummy) // \u0008\u2001\u2000
        {
            var v1 = PopVariant();
            var v2 = PopVariant();
            PushVariant(Xor(v2, v1));
        }
        
        // Token: 0x06000189 RID: 393 RVA: 0x00008244 File Offset: 0x00006444
        private void Shl_(VariantBase dummy) // \u0006\u2002\u2001
        {
            PushVariant(Shift(true, true));
        }

        VariantBase.Vtc CommonTypeShift(VariantBase org_val, VariantBase org_shift, out VariantBase val, out VariantBase shift, bool signed)
        {
            val = org_val.Clone();
            shift = org_shift.Clone();
            var tcval = UnderlyingTypeCode(ref val);
            var tcsh = UnderlyingTypeCode(ref shift);
            if (tcval == VariantBase.Vtc.Tc18Object || tcsh == VariantBase.Vtc.Tc18Object)
                return VariantBase.Vtc.Tc18Object;
            shift = new LongVariant();
            long lsh = 0;
            switch (org_shift.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    lsh = VariantBase.SignedLongFromEnum((EnumVariant) org_shift);
                    break;
                case VariantBase.Vtc.Tc13UIntPtr:
                    lsh = (long)((UIntPtrVariant)org_shift).GetValue().ToUInt64();
                    break;
                case VariantBase.Vtc.Tc17IntPtr:
                    lsh = ((IntPtrVariant)org_shift).GetValue().ToInt64();
                    break;
                case VariantBase.Vtc.Tc19Int:
                    lsh = ((IntVariant)org_shift).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    lsh = ((LongVariant)org_shift).GetValue();
                    break;
            }
            shift.SetValueAbstract(lsh);
            VariantBase.Vtc ret = tcval;
            if (!signed)
            {
                val = AsUnsigned(val);
            }
            if (!signed) switch (ret)
                {
                    case VariantBase.Vtc.Tc19Int:
                        return VariantBase.Vtc.Tc9Uint;
                    case VariantBase.Vtc.Tc24Long:
                        return VariantBase.Vtc.Tc7Ulong;
                }
            return ret;
        }

        private VariantBase Shift(bool left, bool signed)
        {
            VariantBase val, shift;

            var org_shift = PopVariant();
            var org_val = PopVariant();
            var tc = CommonTypeShift(org_val, org_shift, out val, out shift, signed);
            var sh = (int)(long)shift.GetValueAbstract();
            VariantBase ret;
            switch (tc)
            {
                case VariantBase.Vtc.Tc9Uint:
                    uint uv1 = ((UintVariant)val).GetValue();
                    var uvret = new UintVariant();
                    ret = uvret;
                    if (left)
                    {
                        uvret.SetValue(uv1 << sh);
                    }
                    else
                    {
                        uvret.SetValue(uv1 >> sh);
                    }
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv1 = ((IntVariant)val).GetValue();
                    var ivret = new IntVariant();
                    ret = ivret;
                    if (left)
                    {
                        ivret.SetValue(iv1 << sh);
                    }
                    else
                    {
                        ivret.SetValue(iv1 >> sh);
                    }
                    break;
                case VariantBase.Vtc.Tc21Double:
                    /*double dv1 = ((DoubleVariant)val).GetValue(), dv2 = ((DoubleVariant)shift).GetValue();
                    var dvret = new DoubleVariant();
                    ret = dvret;
                    var dmul = left ? 2 : 0.5;
                    dvret.SetValue(dv1 * Math.Pow(dmul, dv2));
                    break;*/
                case VariantBase.Vtc.Tc8Float:
                    /*float fv1 = ((FloatVariant)val).GetValue(), fv2 = ((FloatVariant)shift).GetValue();
                    var fvret = new FloatVariant();
                    ret = fvret;
                    var fmul = left ? 2f : 0.5f;
                    fvret.SetValue(fv1 * (float)Math.Pow(fmul, fv2));
                    break;*/
                    throw new InvalidProgramException();
                case VariantBase.Vtc.Tc24Long:
                    long lv1 = ((LongVariant)val).GetValue();
                    var lvret = new LongVariant();
                    ret = lvret;
                    if (left)
                    {
                        lvret.SetValue(lv1 << sh);
                    }
                    else
                    {
                        lvret.SetValue(lv1 >> sh);
                    }
                    break;
                case VariantBase.Vtc.Tc7Ulong:
                    ulong ulv1 = ((UlongVariant)val).GetValue();
                    var ulvret = new UlongVariant();
                    ret = ulvret;
                    if (left)
                    {
                        ulvret.SetValue(ulv1 << sh);
                    }
                    else
                    {
                        ulvret.SetValue(ulv1 >> sh);
                    }
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_1);
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (left ? OpCodes.Shl : OpCodes.Shr) : OpCodes.Shr_Un);
                    gen.Emit(OpCodes.Ret);
                    ret = new IntPtrVariant();
                    ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_val.GetValueAbstract(), org_shift.GetValueAbstract() })));
                    break;
            }
            return ret;
        }

        // Token: 0x06000173 RID: 371 RVA: 0x00007BE0 File Offset: 0x00005DE0
        private void Initblk_(VariantBase dummy) // \u0002\u2002\u2000
        {
            throw new NotSupportedException(StringDecryptor.GetString(-1550345287) /* Initblk not supported. */);
        }

	    // Token: 0x0600020A RID: 522 RVA: 0x0000C508 File Offset: 0x0000A708
	    private void Localloc_(VariantBase dummy) // \u0008\u200A\u2000
	    {
		    throw new NotSupportedException(StringDecryptor.GetString(-1550345866) /* Localloc not supported. */);
	    }

	    // Token: 0x06000212 RID: 530 RVA: 0x0000C73C File Offset: 0x0000A93C
	    private void Refanyval_(VariantBase dummy) // \u0005\u200A\u2000
	    {
		    throw new NotSupportedException(StringDecryptor.GetString(-1550345900) /* Refanyval is not supported. */);
	    }

	    // Token: 0x06000237 RID: 567 RVA: 0x0000F984 File Offset: 0x0000DB84
	    private void Refanytype_(VariantBase dummy) // \u000F\u2005
	    {
		    throw new NotSupportedException(StringDecryptor.GetString(-1550345460) /* Refanytype is not supported. */);
	    }

	    // Token: 0x0600029C RID: 668 RVA: 0x000126CC File Offset: 0x000108CC
	    private void Cpblk_(VariantBase dummy) // \u0002\u2006
	    {
		    throw new NotSupportedException(StringDecryptor.GetString(-1550345423) /* Cpblk not supported. */);
	    }

	    // Token: 0x060001CA RID: 458 RVA: 0x00009E68 File Offset: 0x00008068
	    private void Cpobj_(VariantBase dummy) // \u0008\u2009
	    {
		    throw new NotSupportedException(StringDecryptor.GetString(-1550345317) /* Cpobj is not supported. */);
	    }

	    // Token: 0x060001D2 RID: 466 RVA: 0x0000A338 File Offset: 0x00008538
	    private void Arglist_(VariantBase dummy) // \u000F\u2002\u2001
	    {
		    throw new NotSupportedException(StringDecryptor.GetString(-1550345940) /* Arglist is not supported. */);
	    }

	    // Token: 0x06000187 RID: 391 RVA: 0x00008224 File Offset: 0x00006424
	    private void Mkrefany_(VariantBase dummy) // \u0002\u2007
	    {
		    throw new NotSupportedException(StringDecryptor.GetString(-1550345270) /* Mkrefany is not supported. */);
	    }

        // Token: 0x0600017E RID: 382 RVA: 0x00007ECC File Offset: 0x000060CC
        private static BindingFlags BF(bool isStatic) // \u0002
        {
		    var bindingFlags = BindingFlags.Public | BindingFlags.NonPublic;
		    if (isStatic)
		    {
			    bindingFlags |= BindingFlags.Static;
		    }
		    else
		    {
			    bindingFlags |= BindingFlags.Instance;
		    }
		    return bindingFlags;
	    }

        // Token: 0x06000192 RID: 402 RVA: 0x000084F4 File Offset: 0x000066F4
        private void Ldc_i4_0_(VariantBase dummy) // \u0005\u2001
        {
            var iv = new IntVariant();
            iv.SetValue(0);
            PushVariant(iv);
        }

        // Token: 0x0600028F RID: 655 RVA: 0x0001235C File Offset: 0x0001055C
        private void Ldc_i4_1_(VariantBase dummy) // \u0002\u2005\u2000
        {
            var iv = new IntVariant();
            iv.SetValue(1);
            PushVariant(iv);
        }

        // Token: 0x0600022F RID: 559 RVA: 0x0000F8C8 File Offset: 0x0000DAC8
        private void Ldc_i4_2_(VariantBase dummy) // \u0005
        {
            var iv = new IntVariant();
            iv.SetValue(2);
            PushVariant(iv);
        }

        // Token: 0x06000174 RID: 372 RVA: 0x00007BF4 File Offset: 0x00005DF4
        private void Ldc_i4_3_(VariantBase dummy) // \u0008\u2006\u2000
        {
            var iv = new IntVariant();
            iv.SetValue(3);
            PushVariant(iv);
        }

        // Token: 0x06000262 RID: 610 RVA: 0x00010BEC File Offset: 0x0000EDEC
        private void Ldc_i4_4_(VariantBase dummy) // \u000F\u2009\u2000
        {
            var iv = new IntVariant();
            iv.SetValue(4);
            PushVariant(iv);
        }

        // Token: 0x060001B3 RID: 435 RVA: 0x000092B4 File Offset: 0x000074B4
        private void Ldc_i4_5_(VariantBase dummy) // \u0008\u2004\u2000
        {
            var iv = new IntVariant();
            iv.SetValue(5);
            PushVariant(iv);
        }

        // Token: 0x06000231 RID: 561 RVA: 0x0000F900 File Offset: 0x0000DB00
        private void Ldc_i4_6_(VariantBase dummy) // \u0006\u2009\u2000
        {
            var iv = new IntVariant();
            iv.SetValue(6);
            PushVariant(iv);
        }

        // Token: 0x0600026A RID: 618 RVA: 0x00010F88 File Offset: 0x0000F188
        private void Ldc_i4_7_(VariantBase dummy) // \u0003\u2003\u2000
        {
            var iv = new IntVariant();
            iv.SetValue(7);
            PushVariant(iv);
        }

        // Token: 0x060001A9 RID: 425 RVA: 0x00008FA8 File Offset: 0x000071A8
        private void Ldc_i4_8_(VariantBase dummy) // \u000E\u2001
        {
            var iv = new IntVariant();
            iv.SetValue(8);
            PushVariant(iv);
        }

        // Token: 0x0600016F RID: 367 RVA: 0x00007A58 File Offset: 0x00005C58
        private void Unbox_(VariantBase vTypeId) // \u0005\u2003\u2000
        {
            var type = GetTypeById(((IntVariant)vTypeId).GetValue());
		    var val = VariantFactory.Convert(PopVariant().GetValueAbstract(), type);
		    PushVariant(val);
	    }

        // Token: 0x06000207 RID: 519 RVA: 0x0000C228 File Offset: 0x0000A428
        private VmTokenInfo ReadVmToken(BinaryReader reader) // \u0002
        {
            switch (reader.ReadByte())
            {
                case (byte)VmTokenInfo.Kind.Class0:
                    {
                        var ret = new VmClassTokenInfo
                        {
                            OuterClassGenericMethodIdx = reader.ReadInt32(),
                            OuterClassGenericClassIdx = reader.ReadInt32(),
                            IsOuterClassGeneric = reader.ReadBoolean(),
                            ClassName = reader.ReadString(),
                            IsGeneric = reader.ReadBoolean(),
                            GenericArguments = new UniversalTokenInfo[(int) reader.ReadInt16()]
                        };
                        for (var i = 0; i < ret.GenericArguments.Length; i++)
                        {
                            ret.GenericArguments[i] = new UniversalTokenInfo
                            {
                                IsVm = 1,
                                MetadataToken = reader.ReadInt32()
                            };
                        }
                        return ret;
                    }
                case (byte)VmTokenInfo.Kind.Field1:
                    return new VmFieldTokenInfo
                    {
                        Class = new UniversalTokenInfo
                        {
                            IsVm = 1,
                            MetadataToken = reader.ReadInt32()
                        },
                        Name = reader.ReadString(),
                        IsStatic = reader.ReadBoolean()
                    };
                case (byte)VmTokenInfo.Kind.Method2:
                    {
                        var ret = new VmMethodTokenInfo
                        {
                            Class = new UniversalTokenInfo
                            {
                                IsVm = 1,
                                MetadataToken = reader.ReadInt32()
                            },
                            Flags = reader.ReadByte(),
                            Name = reader.ReadString(),
                            ReturnType = new UniversalTokenInfo
                            {
                                IsVm = 1,
                                MetadataToken = reader.ReadInt32()
                            },
                            Parameters = new UniversalTokenInfo[(int)reader.ReadInt16()]
                        };
                        for (var j = 0; j < ret.Parameters.Length; j++)
                        {
                            ret.Parameters[j] = new UniversalTokenInfo
                            {
                                IsVm = 1,
                                MetadataToken = reader.ReadInt32()
                            };
                        }
                        var gaCnt = (int)reader.ReadInt16();
                        ret.GenericArguments = new UniversalTokenInfo[gaCnt];
                        for (var k = 0; k < gaCnt; k++)
                        {
                            ret.GenericArguments[k] = new UniversalTokenInfo
                            {
                                IsVm = 1,
                                MetadataToken = reader.ReadInt32()
                            };
                        }
                        return ret;
                    }
                case (byte)VmTokenInfo.Kind.String3:
                    return new VmStringTokenInfo { Value = reader.ReadString() };
                case (byte)VmTokenInfo.Kind.MethodRef4:
                    return new VmMethodRefTokenInfo
                    {
                        Flags = reader.ReadInt32(),
                        Pos = reader.ReadInt32()
                    };
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        // Token: 0x06000175 RID: 373 RVA: 0x00007C08 File Offset: 0x00005E08
        private UniversalTokenInfo ReadToken(int pos) // u0002
        {
            if (_srcVirtualizedStreamReader == null)
            {
                throw new InvalidOperationException();
            }
            var baseStream = _srcVirtualizedStreamReader.BaseStream;
            UniversalTokenInfo result;
            lock (baseStream)
            {
                _srcVirtualizedStreamReader.BaseStream.Seek(pos, SeekOrigin.Begin);
                result = new UniversalTokenInfo {IsVm = _srcVirtualizedStreamReader.ReadByte()};
                if (result.IsVm == 0)
                {
                    result.MetadataToken = _srcVirtualizedStreamReader.ReadInt32();
                }
                else
                {
                    result.VmToken = ReadVmToken(_srcVirtualizedStreamReader);
                }
            }
            return result;
        }

        // Token: 0x06000248 RID: 584 RVA: 0x000102AC File Offset: 0x0000E4AC
        private string Ldstr(int strToken) // \u0002
        {
            string result;
            lock (AllMetadataById)
            {
                object stored;
                if (AllMetadataById.TryGetValue(strToken, out stored))
                {
                    result = (string)stored;
                }
                else
                {
                    var tokenInfo = ReadToken(strToken);
                    if (tokenInfo.IsVm == 0)
                    {
                        result = _module.ResolveString(tokenInfo.MetadataToken);
                    }
                    else
                    {
                        var text = ((VmStringTokenInfo)tokenInfo.VmToken).Value;
                        AllMetadataById.Add(strToken, text);
                        result = text;
                    }
                }
            }
            return result;
        }

        // Token: 0x0600019C RID: 412 RVA: 0x00008B34 File Offset: 0x00006D34
        private void Ldstr_(VariantBase strToken) // \u000E\u2000\u2001
        {
            var tok = ((IntVariant)strToken).GetValue();
            var text = Ldstr(tok);
            var val = new StringVariant();
            val.SetValue(text);
            PushVariant(val);
        }

        // Token: 0x06000170 RID: 368 RVA: 0x00007A94 File Offset: 0x00005C94
        private VariantBase ReadOperand(MyBufferReader r, VmOperandType operandType) // \u0002
	    {
		    switch (operandType)
		    {
		    case VmOperandType.Ot0UInt:
		    {
			    var ret = new UintVariant();
			    ret.SetValue(r.ReadUint());
			    return ret;
		    }
		    case VmOperandType.Ot1UShort:
		    case VmOperandType.Ot3UShort:
		    {
			    var ret = new UshortVariant();
			    ret.SetValue(r.ReadUshort());
			    return ret;
		    }
		    case VmOperandType.Ot2Byte:
		    case VmOperandType.Ot8Byte:
		    {
			    var ret = new ByteVariant();
			    ret.SetValue(r.ReadByte());
			    return ret;
		    }
		    case VmOperandType.Ot4Double:
		    {
			    var ret = new DoubleVariant();
			    ret.SetValue(r.ReadDouble());
			    return ret;
		    }
		    case VmOperandType.Ot5Int:
		    case VmOperandType.Ot12Int:
		    {
			    var ret = new IntVariant();
			    ret.SetValue(r.ReadInt32());
			    return ret;
		    }
		    case VmOperandType.Ot6SByte:
		    {
			    var ret = new SbyteVariant();
			    ret.SetValue(r.ReadSbyte());
			    return ret;
		    }
		    case VmOperandType.Ot7Long:
		    {
			    var ret = new LongVariant();
			    ret.SetValue(r.ReadLong());
			    return ret;
		    }
		    case VmOperandType.Ot9IntArr:
		    {
			    var num = r.ReadInt32();
			    var array = new IntVariant[num];
			    for (var i = 0; i < num; i++)
			    {
				    var item = new IntVariant();
				    item.SetValue(r.ReadInt32());
                    array[i] = item;
			    }
			    var ret = new ArrayVariant();
			    ret.SetValue(array);
			    return ret;
		    }
		    case VmOperandType.Ot10Float:
		    {
			    var ret = new FloatVariant();
			    ret.SetValue(r.ReadFloat());
			    return ret;
		    }
		    case VmOperandType.Ot11Nope:
			    return null;
		    default:
			    throw new Exception(StringDecryptor.GetString(-1550347123) /* Unknown operand type. */);
		    }
	    }

        // Token: 0x06000279 RID: 633 RVA: 0x0001184C File Offset: 0x0000FA4C
        enum ComparisonKind { EQ, NEQ, GT, LE, LT, GE }
        private static bool UniCompare(VariantBase v1, VariantBase v2, ComparisonKind ck, bool unsignedNanBranch) // \u0008 - bug fixed (метод переписан)
        {
            // from stack: enum double single long int
            var t1 = v1.GetTypeCode();
            if (t1 == VariantBase.Vtc.Tc5Enum)
            {
                var vv1 = VariantBase.SignedVariantFromEnum((EnumVariant)v1);
                return UniCompare(vv1, v2, ck, unsignedNanBranch);
            }
            var t2 = v2.GetTypeCode();
            if (t2 == VariantBase.Vtc.Tc5Enum)
            {
                var vv2 = VariantBase.SignedVariantFromEnum((EnumVariant)v2);
                return UniCompare(v1, vv2, ck, unsignedNanBranch);
            }
            if (t1 == VariantBase.Vtc.Tc18Object || t2 == VariantBase.Vtc.Tc18Object)
            {
                if (ck == ComparisonKind.EQ) return v1.GetValueAbstract().Equals(v2.GetValueAbstract());
                if (ck == ComparisonKind.NEQ) return !v1.GetValueAbstract().Equals(v2.GetValueAbstract());
                return false;
            }
            if (t1 == VariantBase.Vtc.Tc21Double || t2 == VariantBase.Vtc.Tc21Double)
            {
                var d1 = (t1 == VariantBase.Vtc.Tc21Double) ? ((DoubleVariant)v1).GetValue() : Convert.ToDouble(v1.GetValueAbstract());
                var d2 = (t2 == VariantBase.Vtc.Tc21Double) ? ((DoubleVariant)v2).GetValue() : Convert.ToDouble(v2.GetValueAbstract());
                if (unsignedNanBranch) unsignedNanBranch = (double.IsNaN(d1) || double.IsNaN(d2));
                switch (ck)
                {
                    case ComparisonKind.EQ:
                        // ReSharper disable once CompareOfFloatsByEqualityOperator
                        return (d1 == d2) || unsignedNanBranch;
                    case ComparisonKind.GT:
                        return (d1 > d2) || unsignedNanBranch;
                    case ComparisonKind.NEQ:
                        // ReSharper disable once CompareOfFloatsByEqualityOperator
                        return (d1 != d2) || unsignedNanBranch;
                    case ComparisonKind.LE:
                        return (d1 <= d2) || unsignedNanBranch;
                    case ComparisonKind.LT:
                        return (d1 < d2) || unsignedNanBranch;
                    case ComparisonKind.GE:
                        return (d1 >= d2) || unsignedNanBranch;
                }
            }
            if (t1 == VariantBase.Vtc.Tc8Float || t2 == VariantBase.Vtc.Tc8Float)
            {
                var d1 = (t1 == VariantBase.Vtc.Tc8Float) ? ((FloatVariant)v1).GetValue() : Convert.ToSingle(v1.GetValueAbstract());
                var d2 = (t2 == VariantBase.Vtc.Tc8Float) ? ((FloatVariant)v2).GetValue() : Convert.ToSingle(v2.GetValueAbstract());
                if (unsignedNanBranch) unsignedNanBranch = (float.IsNaN(d1) || float.IsNaN(d2));
                switch (ck)
                {
                    case ComparisonKind.EQ:
                        // ReSharper disable once CompareOfFloatsByEqualityOperator
                        return (d1 == d2) || unsignedNanBranch;
                    case ComparisonKind.GT:
                        return (d1 > d2) || unsignedNanBranch;
                    case ComparisonKind.NEQ:
                        // ReSharper disable once CompareOfFloatsByEqualityOperator
                        return (d1 != d2) || unsignedNanBranch;
                    case ComparisonKind.LE:
                        return (d1 <= d2) || unsignedNanBranch;
                    case ComparisonKind.LT:
                        return (d1 < d2) || unsignedNanBranch;
                    case ComparisonKind.GE:
                        return (d1 >= d2) || unsignedNanBranch;
                }
            }
            if (t1 == VariantBase.Vtc.Tc24Long || t2 == VariantBase.Vtc.Tc24Long)
            {
                var d1 = (t1 == VariantBase.Vtc.Tc24Long) ? ((LongVariant)v1).GetValue() : (unsignedNanBranch ? Convert.ToInt64((uint)(int)v1.GetValueAbstract()) : Convert.ToInt64(v1.GetValueAbstract()));
                var d2 = (t2 == VariantBase.Vtc.Tc24Long) ? ((LongVariant)v2).GetValue() : (unsignedNanBranch ? Convert.ToInt64((uint)(int)v2.GetValueAbstract()) : Convert.ToInt64(v2.GetValueAbstract()));
                switch (ck)
                {
                    case ComparisonKind.EQ:
                        return d1 == d2;
                    case ComparisonKind.GT:
                        if(unsignedNanBranch) return (ulong)d1 > (ulong)d2;
                        return d1 > d2;
                    case ComparisonKind.NEQ:
                        if (unsignedNanBranch) return (ulong)d1 != (ulong)d2;
                        return d1 != d2;
                    case ComparisonKind.LE:
                        if (unsignedNanBranch) return (ulong)d1 <= (ulong)d2;
                        return d1 <= d2;
                    case ComparisonKind.LT:
                        if (unsignedNanBranch) return (ulong)d1 < (ulong)d2;
                        return d1 < d2;
                    case ComparisonKind.GE:
                        if (unsignedNanBranch) return (ulong)d1 >= (ulong)d2;
                        return d1 >= d2;
                }
            }
            if (t1 == VariantBase.Vtc.Tc19Int || t2 == VariantBase.Vtc.Tc19Int)
            {
                switch (ck)
                {
                    case ComparisonKind.EQ:
                        // ReSharper disable once CompareOfFloatsByEqualityOperator
                        return ((IntVariant)v1).GetValue() == ((IntVariant)v2).GetValue();
                    case ComparisonKind.GT:
                        if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() > (uint)((IntVariant)v2).GetValue();
                        return ((IntVariant)v1).GetValue() > ((IntVariant)v2).GetValue();
                    case ComparisonKind.NEQ:
                        if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() != (uint)((IntVariant)v2).GetValue();
                        return ((IntVariant)v1).GetValue() != ((IntVariant)v2).GetValue();
                    case ComparisonKind.LE:
                        if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() <= (uint)((IntVariant)v2).GetValue();
                        return ((IntVariant)v1).GetValue() <= ((IntVariant)v2).GetValue();
                    case ComparisonKind.LT:
                        if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() < (uint)((IntVariant)v2).GetValue();
                        return ((IntVariant)v1).GetValue() < ((IntVariant)v2).GetValue();
                    //case ComparisonKind.GE:
                    default:
                        if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() >= (uint)((IntVariant)v2).GetValue();
                        return ((IntVariant)v1).GetValue() >= ((IntVariant)v2).GetValue();
                }
            }
            return false;
        }

        // Token: 0x0600017F RID: 383 RVA: 0x00007EEC File Offset: 0x000060EC
        private void Ldelema_(VariantBase vTypeId) // \u000F\u2002
        {
            var type = GetTypeById(((IntVariant)vTypeId).GetValue());
            var idx = PopLong();
            var array = (Array)PopVariant().GetValueAbstract();
            var val = new SdArrayValueVariant();
            val.SetArray(array);
            val.SetHeldType(type);
            val.SetIndex(idx);
            PushVariant(val);
        }

        // Token: 0x06000252 RID: 594 RVA: 0x00010780 File Offset: 0x0000E980
        private void Ldelem_ref_(VariantBase dummy) // \u000F\u2003\u2000
        {
            Ldelem(SimpleTypeHelper.ObjectType);
        }

        // Token: 0x06000178 RID: 376 RVA: 0x00007D38 File Offset: 0x00005F38
        private static void SerializeCrossDomain(Exception ex) // \u0002
        {
            if (ex == null)
            {
                return;
            }
            try
            {
                var type = ex.GetType();
                if (type.IsSerializable)
                {
                    var context = new StreamingContext(StreamingContextStates.CrossAppDomain);
                    var om = new ObjectManager(null, context);
                    var info = new SerializationInfo(type, new FormatterConverter());
                    ex.GetObjectData(info, context);
                    om.RegisterObject(ex, 1L, info);
                    om.DoFixups();
                }
            }
            catch
            {
            }
        }

        // Token: 0x060001DF RID: 479 RVA: 0x0000ABCC File Offset: 0x00008DCC
        private static void Throw(object ex) // \u0003
        {
            throw (Exception)ex;
        }

        // Token: 0x0600024D RID: 589 RVA: 0x000105A0 File Offset: 0x0000E7A0
        private static void ThrowStoreCrossDomain(object ex) // \u0002
        {
            SerializeCrossDomain(ex as Exception);
            Throw(ex);
        }

        // Token: 0x06000293 RID: 659 RVA: 0x00012398 File Offset: 0x00010598
        private static VariantBase SubLong(VariantBase v1, VariantBase v2, bool bChecked, bool bUnsigned) // \u0005
        {
            var lvret = new LongVariant();
            if (!bUnsigned)
            {
                var l1 = ((LongVariant)v1).GetValue();
                var l2 = ((LongVariant)v2).GetValue();
                long lret;
                if (bChecked)
                {
                    lret = checked(l1 - l2);
                }
                else
                {
                    lret = l1 - l2;
                }
                lvret.SetValue(lret);
                return lvret;
            }
            var u1 = (ulong)((LongVariant)v1).GetValue();
            var u2 = (ulong)((LongVariant)v2).GetValue();
            ulong uret;
            if (bChecked)
            {
                uret = checked(u1 - u2);
            }
            else
            {
                uret = u1 - u2;
            }
            lvret.SetValue((long)uret);
            return lvret;
        }

        private VariantBase Sub(bool ovf, bool signed)
        {
            VariantBase v1, v2;
            var org_v2 = PopVariant();
            var org_v1 = PopVariant();
            var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
            VariantBase ret;
            switch (tc)
            {
                case VariantBase.Vtc.Tc9Uint:
                    uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
                    var uvret = new UintVariant();
                    ret = uvret;
                    if (ovf)
                    {
                        uint uiv;
                        checked
                        {
                            uiv = uv1 - uv2;
                        }
                        uvret.SetValue(uiv);
                    }
                    else
                    {
                        uvret.SetValue(uv1 - uv2);
                    }
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
                    var ivret = new IntVariant();
                    ret = ivret;
                    if (ovf)
                    {
                        checked
                        {
                            ivret.SetValue(iv1 - iv2);
                        }
                    }
                    else
                    {
                        ivret.SetValue(iv1 - iv2);
                    }
                    break;
                case VariantBase.Vtc.Tc21Double:
                    double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
                    var dvret = new DoubleVariant();
                    ret = dvret;
                    dvret.SetValue(dv1 - dv2);
                    break;
                case VariantBase.Vtc.Tc8Float:
                    float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
                    var fvret = new FloatVariant();
                    ret = fvret;
                    fvret.SetValue(fv1 - fv2);
                    break;
                case VariantBase.Vtc.Tc24Long:
                    long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
                    var lvret = new LongVariant();
                    ret = lvret;
                    if (ovf)
                    {
                        checked
                        {
                            lvret.SetValue(lv1 - lv2);
                        }
                    }
                    else
                    {
                        lvret.SetValue(lv1 - lv2);
                    }
                    break;
                case VariantBase.Vtc.Tc7Ulong:
                    ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
                    var ulvret = new UlongVariant();
                    ret = ulvret;
                    if (ovf)
                    {
                        ulong ulv;
                        checked
                        {
                            ulv = ulv1 - ulv2;
                        }
                        ulvret.SetValue(ulv);
                    }
                    else
                    {
                        ulvret.SetValue(ulv1 - ulv2);
                    }
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_1);
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Sub_Ovf : OpCodes.Sub) : OpCodes.Sub_Ovf_Un);
                    gen.Emit(OpCodes.Ret);
                    ret = new IntPtrVariant();
                    ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
                    break;
            }
            return ret;
        }

        // Token: 0x0600026B RID: 619 RVA: 0x00010F9C File Offset: 0x0000F19C
        private void Sub_ovf_un_(VariantBase dummy) // \u0005\u2006\u2000
        {
            PushVariant(Sub(true, false));
        }

        // Token: 0x060001A8 RID: 424 RVA: 0x00008F7C File Offset: 0x0000717C
        private void Sub_ovf_(VariantBase dummy) // \u0005\u2008
        {
            PushVariant(Sub(true, true));
        }

        // Token: 0x0600021C RID: 540 RVA: 0x0000C84C File Offset: 0x0000AA4C
        private void Sub_(VariantBase dummy) // \u0006\u200A
        {
            PushVariant(Sub(false, true));
        }

        // Token: 0x06000271 RID: 625 RVA: 0x00011144 File Offset: 0x0000F344
        private static VariantBase MulLong(VariantBase v1, VariantBase v2, bool bChecked, bool bUnsigned) // \u0003
        {
            var lvret = new LongVariant();
            if (!bUnsigned)
            {
                var l1 = ((LongVariant)v1).GetValue();
                var l2 = ((LongVariant)v2).GetValue();
                long lret;
                if (bChecked)
                {
                    lret = checked(l1 * l2);
                }
                else
                {
                    lret = l1 * l2;
                }
                lvret.SetValue(lret);
                return lvret;
            }
            var u1 = (ulong)((LongVariant)v1).GetValue();
            var u2 = (ulong)((LongVariant)v2).GetValue();
            ulong uret;
            if (bChecked)
            {
                uret = checked(u1 * u2);
            }
            else
            {
                uret = u1 * u2;
            }
            lvret.SetValue((long)uret);
            return lvret;
        }

        private VariantBase Mul(bool ovf, bool signed)
        {
            VariantBase v1, v2;
            var org_v2 = PopVariant();
            var org_v1 = PopVariant();
            var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
            VariantBase ret;
            switch (tc)
            {
                case VariantBase.Vtc.Tc9Uint:
                    uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
                    var uvret = new UintVariant();
                    ret = uvret;
                    if (ovf)
                    {
                        uint uiv;
                        checked
                        {
                            uiv = uv1 * uv2;
                        }
                        uvret.SetValue(uiv);
                    }
                    else
                    {
                        uvret.SetValue(uv1 * uv2);
                    }
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
                    var ivret = new IntVariant();
                    ret = ivret;
                    if (ovf)
                    {
                        checked
                        {
                            ivret.SetValue(iv1 * iv2);
                        }
                    }
                    else
                    {
                        ivret.SetValue(iv1 * iv2);
                    }
                    break;
                case VariantBase.Vtc.Tc21Double:
                    double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
                    var dvret = new DoubleVariant();
                    ret = dvret;
                    dvret.SetValue(dv1 * dv2);
                    break;
                case VariantBase.Vtc.Tc8Float:
                    float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
                    var fvret = new FloatVariant();
                    ret = fvret;
                    fvret.SetValue(fv1 * fv2);
                    break;
                case VariantBase.Vtc.Tc24Long:
                    long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
                    var lvret = new LongVariant();
                    ret = lvret;
                    if (ovf)
                    {
                        checked
                        {
                            lvret.SetValue(lv1 * lv2);
                        }
                    }
                    else
                    {
                        lvret.SetValue(lv1 * lv2);
                    }
                    break;
                case VariantBase.Vtc.Tc7Ulong:
                    ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
                    var ulvret = new UlongVariant();
                    ret = ulvret;
                    if (ovf)
                    {
                        ulong ulv;
                        checked
                        {
                            ulv = ulv1 * ulv2;
                        }
                        ulvret.SetValue(ulv);
                    }
                    else
                    {
                        ulvret.SetValue(ulv1 * ulv2);
                    }
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_1);
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Mul_Ovf : OpCodes.Mul) : OpCodes.Mul_Ovf_Un);
                    gen.Emit(OpCodes.Ret);
                    ret = new IntPtrVariant();
                    ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
                    break;
            }
            return ret;
        }

        // Token: 0x06000181 RID: 385 RVA: 0x00007F88 File Offset: 0x00006188
        private void Mul_ovf_un_(VariantBase dummy) // \u0005\u2007
        {
            PushVariant(Mul(true, false));
        }

        // Token: 0x060001E1 RID: 481 RVA: 0x0000ABDC File Offset: 0x00008DDC
        private void Mul_(VariantBase dummy) // \u0006\u2001\u2001
        {
            PushVariant(Mul(false, true));
        }

        // Token: 0x060001A0 RID: 416 RVA: 0x00008C98 File Offset: 0x00006E98
        private void Mul_ovf_(VariantBase dummy) // \u0008\u2000\u2000
        {
            PushVariant(Mul(true, true));
        }

        VariantBase.Vtc CommonType(VariantBase org_v1, VariantBase org_v2, out VariantBase v1, out VariantBase v2, bool signed)
        {
            v1 = org_v1.Clone();
            v2 = org_v2.Clone();
            var tc1 = UnderlyingTypeCode(ref v1);
            var tc2 = UnderlyingTypeCode(ref v2);
            if (tc1 == VariantBase.Vtc.Tc18Object || tc2 == VariantBase.Vtc.Tc18Object)
                return VariantBase.Vtc.Tc18Object;
            VariantBase.Vtc ret = tc1;
            if (!signed)
            {
                v1 = AsUnsigned(v1);
                v2 = AsUnsigned(v2);
            }
            if(tc1 != tc2) switch (tc1)
            {
                case VariantBase.Vtc.Tc19Int:
                    switch (tc2)
                    {
                        case VariantBase.Vtc.Tc24Long:
                            {
                                ret = tc2;
                                var new_v1 = signed ? (VariantBase)new LongVariant() : new UlongVariant();
                                new_v1.CopyFrom(v1);
                                v1 = new_v1;
                            }
                            break;
                        case VariantBase.Vtc.Tc21Double:
                            {
                                ret = tc2;
                                var new_v1 = new DoubleVariant();
                                new_v1.CopyFrom(v1);
                                v1 = new_v1;
                            }
                            break;
                        case VariantBase.Vtc.Tc8Float:
                            {
                                ret = tc2;
                                var new_v1 = new FloatVariant();
                                new_v1.CopyFrom(v1);
                                v1 = new_v1;
                            }
                            break;
                    }
                    break;
                case VariantBase.Vtc.Tc24Long:
                    switch (tc2)
                    {
                        case VariantBase.Vtc.Tc19Int:
                            {
                                var new_v2 = signed ? (VariantBase)new LongVariant() : new UlongVariant();
                                new_v2.CopyFrom(v2);
                                v2 = new_v2;
                            }
                            break;
                        case VariantBase.Vtc.Tc21Double:
                            {
                                ret = tc2;
                                var new_v1 = new DoubleVariant();
                                new_v1.CopyFrom(v1);
                                v1 = new_v1;
                            }
                            break;
                        case VariantBase.Vtc.Tc8Float:
                            {
                                ret = tc2;
                                var new_v1 = new FloatVariant();
                                new_v1.CopyFrom(v1);
                                v1 = new_v1;
                            }
                            break;
                    }
                    break;
                case VariantBase.Vtc.Tc21Double:
                    switch (tc2)
                    {
                        case VariantBase.Vtc.Tc19Int:
                        case VariantBase.Vtc.Tc24Long:
                        case VariantBase.Vtc.Tc8Float:
                            {
                                var new_v2 = new DoubleVariant();
                                new_v2.CopyFrom(v2);
                                v2 = new_v2;
                            }
                            break;
                    }
                    break;
                case VariantBase.Vtc.Tc8Float:
                    switch (tc2)
                    {
                        case VariantBase.Vtc.Tc19Int:
                        case VariantBase.Vtc.Tc24Long:
                            {
                                var new_v2 = new FloatVariant();
                                new_v2.CopyFrom(v2);
                                v2 = new_v2;
                            }
                            break;
                        case VariantBase.Vtc.Tc21Double:
                            {
                                ret = tc2;
                                var new_v1 = new DoubleVariant();
                                new_v1.CopyFrom(v1);
                                v1 = new_v1;
                            }
                            break;
                    }
                    break;
            }
            if(!signed) switch (ret)
            {
                case VariantBase.Vtc.Tc19Int:
                    return VariantBase.Vtc.Tc9Uint;
                case VariantBase.Vtc.Tc24Long:
                    return VariantBase.Vtc.Tc7Ulong;
            }
            return ret;
        }

        private VariantBase.Vtc UnderlyingTypeCode(ref VariantBase v)
        {
            var ret = v.GetTypeCode();
            if (ret == VariantBase.Vtc.Tc5Enum)
            {
                v = VariantBase.SignedVariantFromEnum((EnumVariant) v);
                ret = Marshal.SizeOf(v.GetValueAbstract()) == 4 ? VariantBase.Vtc.Tc19Int : VariantBase.Vtc.Tc24Long;
            }
            return ret;
        }

        private VariantBase AsUnsigned(VariantBase v)
        {
            var tc = v.GetTypeCode();
            var ret = v;
            switch (tc)
            {
                case VariantBase.Vtc.Tc19Int:
                    ret = new UintVariant();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    ret = new UlongVariant();
                    break;
            }
            ret.CopyFrom(v);
            return ret;
        }

        private VariantBase Add(bool ovf, bool signed)
        {
            VariantBase v1, v2;
            var org_v2 = PopVariant();
            var org_v1 = PopVariant();
            var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
            VariantBase ret;
            switch (tc)
            {
                case VariantBase.Vtc.Tc9Uint:
                    uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
                    var uvret = new UintVariant();
                    ret = uvret;
                    if (ovf)
                    {
                        uint uiv;
                        checked
                        {
                            uiv = uv1 + uv2;
                        }
                        uvret.SetValue(uiv);
                    }
                    else
                    {
                        uvret.SetValue(uv1 + uv2);
                    }
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
                    var ivret = new IntVariant();
                    ret = ivret;
                    if (ovf)
                    {
                        checked
                        {
                            ivret.SetValue(iv1 + iv2);
                        }
                    }
                    else
                    {
                        ivret.SetValue(iv1 + iv2);
                    }
                    break;
                case VariantBase.Vtc.Tc21Double:
                    double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
                    var dvret = new DoubleVariant();
                    ret = dvret;
                    dvret.SetValue(dv1 + dv2);
                    break;
                case VariantBase.Vtc.Tc8Float:
                    float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
                    var fvret = new FloatVariant();
                    ret = fvret;
                    fvret.SetValue(fv1 + fv2);
                    break;
                case VariantBase.Vtc.Tc24Long:
                    long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
                    var lvret = new LongVariant();
                    ret = lvret;
                    if (ovf)
                    {
                        checked
                        {
                            lvret.SetValue(lv1 + lv2);
                        }
                    }
                    else
                    {
                        lvret.SetValue(lv1 + lv2);
                    }
                    break;
                case VariantBase.Vtc.Tc7Ulong:
                    ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
                    var ulvret = new UlongVariant();
                    ret = ulvret;
                    if (ovf)
                    {
                        ulong ulv;
                        checked
                        {
                            ulv = ulv1 + ulv2;
                        }
                        ulvret.SetValue(ulv);
                    }
                    else
                    {
                        ulvret.SetValue(ulv1 + ulv2);
                    }
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_1);
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Add_Ovf : OpCodes.Add) : OpCodes.Add_Ovf_Un);
                    gen.Emit(OpCodes.Ret);
                    ret = new IntPtrVariant();
                    ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
                    break;
            }
            return ret;
        }

        // Token: 0x0600022D RID: 557 RVA: 0x0000F880 File Offset: 0x0000DA80
        private void Add_ovf_(VariantBase dummy) // \u0008\u2001
        {
            PushVariant(Add(true, true));
        }

        // Token: 0x06000238 RID: 568 RVA: 0x0000F998 File Offset: 0x0000DB98
        private void Add_(VariantBase dummy) // \u0002\u2004
        {
            PushVariant(Add(false, true));
        }

        // Token: 0x0600029B RID: 667 RVA: 0x000126A0 File Offset: 0x000108A0
        private void Add_ovf_un_(VariantBase dummy) // \u0002\u2004\u2000
        {
            PushVariant(Add(true, false));
        }

        private VariantBase Or(VariantBase org_v1, VariantBase org_v2)
        {
            VariantBase v1, v2;
            var tc = CommonType(org_v1, org_v2, out v1, out v2, true);
            VariantBase ret;
            switch (tc)
            {
                case VariantBase.Vtc.Tc9Uint:
                    uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
                    var uvret = new UintVariant();
                    ret = uvret;
                    uvret.SetValue(uv1 | uv2);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
                    var ivret = new IntVariant();
                    ret = ivret;
                    ivret.SetValue(iv1 | iv2);
                    break;
                case VariantBase.Vtc.Tc21Double:
                    {
                        /*double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue(); // естественный алгоритм
                        long lv1 = (dv1 < 0) ? (long)dv1 : (long)(ulong)dv1;
                        long lv2 = (dv2 < 0) ? (long)dv2 : (long)(ulong)dv2;
                        var dvret = new DoubleVariant();
                        ret = dvret;
                        var l64 = (ulong) lv1 | (ulong) lv2;
                        if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
                        dvret.SetValue(l64);*/
                        var dvret = new DoubleVariant();
                        ret = dvret;
                        dvret.SetValue((4 == IntPtr.Size) ? Double.NaN : (double)0); // иногда у фреймворка бывает мусор, но чаще эти значения...
                    }
                    break;
                case VariantBase.Vtc.Tc8Float:
                    {
                        /*float fv1 = ((FloatVariant) v1).GetValue(), fv2 = ((FloatVariant) v2).GetValue(); // естественный алгоритм
                        long lv1 = (fv1 < 0) ? (long)fv1 : (long)(ulong)fv1;
                        long lv2 = (fv2 < 0) ? (long)fv2 : (long)(ulong)fv2;
                        var fvret = new FloatVariant();
                        ret = fvret;
                        var l64 = (ulong)lv1 | (ulong)lv2;
                        if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
                        fvret.SetValue(l64);*/
                        var fvret = new FloatVariant();
                        ret = fvret;
                        fvret.SetValue((4 == IntPtr.Size) ? float.NaN : (float)0.0); // иногда у фреймворка бывает мусор, но чаще эти значения...
                    }
                    break;
                case VariantBase.Vtc.Tc24Long:
                    {
                        long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
                        var lvret = new LongVariant();
                        ret = lvret;
                        lvret.SetValue(lv1 | lv2);
                    }
                    break;
                case VariantBase.Vtc.Tc7Ulong:
                    ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
                    var ulvret = new UlongVariant();
                    ret = ulvret;
                    ulvret.SetValue(ulv1 | ulv2);
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_1);
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(OpCodes.Or);
                    gen.Emit(OpCodes.Ret);
                    ret = new IntPtrVariant();
                    ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
                    break;
            }
            return ret;
        }

        // Token: 0x0600020F RID: 527 RVA: 0x0000C598 File Offset: 0x0000A798
        private void Or_(VariantBase dummy) // \u0006\u2002\u2000
        {
            var v2 = PopVariant();
            var v1 = PopVariant();
            PushVariant(Or(v1, v2));
        }

        // Token: 0x060001D8 RID: 472 RVA: 0x0000A718 File Offset: 0x00008918
        private void Throw_(VariantBase dummy) // \u0006\u2005\u2000
        {
            ThrowStoreCrossDomain(PopVariant().GetValueAbstract());
        }

        private VariantBase Rem(bool signed)
        {
            VariantBase v1, v2;
            var org_v2 = PopVariant();
            var org_v1 = PopVariant();
            VariantBase ret;
            var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
            if (IsFloating(org_v1) && org_v1.GetType() == org_v2.GetType() && !signed)
            {
                if (IntPtr.Size == 8) throw new InvalidProgramException();
                if (tc == VariantBase.Vtc.Tc21Double)
                {
                    ret = new DoubleVariant();
                    ret.SetValueAbstract(double.NaN);
                }
                else /*if (tc == VariantBase.Vtc.Tc8Float)*/
                {
                    ret = new FloatVariant();
                    ret.SetValueAbstract(float.NaN);
                }
            }
            else switch (tc)
                {
                    case VariantBase.Vtc.Tc9Uint:
                        uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
                        var uvret = new UintVariant();
                        ret = uvret;
                        uvret.SetValue(uv1 % uv2);
                        break;
                    case VariantBase.Vtc.Tc19Int:
                        int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
                        var ivret = new IntVariant();
                        ret = ivret;
                        ivret.SetValue(iv1 % iv2);
                        break;
                    case VariantBase.Vtc.Tc21Double:
                        double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
                        var dvret = new DoubleVariant();
                        ret = dvret;
                        if (Math.Abs(dv2) < double.Epsilon && org_v1.GetType() != org_v2.GetType()) throw new DivideByZeroException();
                        dvret.SetValue(dv1 % dv2);
                        break;
                    case VariantBase.Vtc.Tc8Float:
                        float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
                        var fvret = new FloatVariant();
                        ret = fvret;
                        if (Math.Abs(fv2) < float.Epsilon && org_v1.GetType() != org_v2.GetType()) throw new DivideByZeroException();
                        fvret.SetValue(fv1 % fv2);
                        break;
                    case VariantBase.Vtc.Tc24Long:
                        long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
                        var lvret = new LongVariant();
                        ret = lvret;
                        lvret.SetValue(lv1 % lv2);
                        break;
                    case VariantBase.Vtc.Tc7Ulong:
                        ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
                        var ulvret = new UlongVariant();
                        ret = ulvret;
                        ulvret.SetValue(ulv1 % ulv2);
                        break;
                    default:
                        // это нужно будет заменить на соотв. msil-код
                        var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                        var gen = dyn.GetILGenerator();
                        gen.Emit(OpCodes.Ldarg_1);
                        gen.Emit(OpCodes.Ldarg_0);
                        gen.Emit(signed ? OpCodes.Rem : OpCodes.Rem_Un);
                        gen.Emit(OpCodes.Ret);
                        ret = new IntPtrVariant();
                        ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
                        break;
                }
            return ret;
        }
        
        // Token: 0x060001CC RID: 460 RVA: 0x00009EAC File Offset: 0x000080AC
        private void Rem_(VariantBase dummy) // \u0006\u2000\u2001
        {
            PushVariant(Rem(true));
        }

        // Token: 0x060001FA RID: 506 RVA: 0x0000BC3C File Offset: 0x00009E3C
        private void Rem_un_(VariantBase dummy) // \u0006\u200B\u2000
        {
            PushVariant(Rem(false));
        }

        // Token: 0x06000254 RID: 596 RVA: 0x00010824 File Offset: 0x0000EA24
        private static VariantBase Neg(VariantBase v) // \u0002
        {
            if (v.GetTypeCode() == VariantBase.Vtc.Tc19Int)
            {
                var i = ((IntVariant)v).GetValue();
                var ivret = new IntVariant();
                ivret.SetValue(-i);
                return ivret;
            }
            if (v.GetTypeCode() == VariantBase.Vtc.Tc24Long)
            {
                var l = ((LongVariant)v).GetValue();
                var lvret = new LongVariant();
                lvret.SetValue(-l);
                return lvret;
            }
            if (v.GetTypeCode() == VariantBase.Vtc.Tc21Double)
            {
                var dvret = new DoubleVariant();
                dvret.SetValue(-((DoubleVariant)v).GetValue());
                return dvret;
            }
            if (v.GetTypeCode() != VariantBase.Vtc.Tc5Enum)
            {
                throw new InvalidOperationException();
            }
            var underlyingType = Enum.GetUnderlyingType(v.GetValueAbstract().GetType());
            if (underlyingType == typeof(long) || underlyingType == typeof(ulong))
            {
                var lvret = new LongVariant();
                lvret.SetValue(Convert.ToInt64(v.GetValueAbstract()));
                return Neg(lvret);
            }
            var ivret2 = new IntVariant();
            ivret2.SetValue(Convert.ToInt32(v.GetValueAbstract()));
            return Neg(ivret2);
        }

        // Token: 0x060001F8 RID: 504 RVA: 0x0000BA00 File Offset: 0x00009C00
        private void Neg_(VariantBase dummy) // \u0006\u2007
        {
            var v = PopVariant();
            PushVariant(Neg(v));
        }

        // Token: 0x06000242 RID: 578 RVA: 0x0000FE38 File Offset: 0x0000E038
        private static VariantBase DivLong(VariantBase v1, VariantBase v2, bool bUnsigned) // \u0003
        {
            var lvret = new LongVariant();
            if (!bUnsigned)
            {
                var l1 = ((LongVariant)v1).GetValue();
                var l2 = ((LongVariant)v2).GetValue();
                lvret.SetValue(l1 / l2);
                return lvret;
            }
            var u1 = (ulong)((LongVariant)v1).GetValue();
            var u2 = (ulong)((LongVariant)v2).GetValue();
            lvret.SetValue((long)(u1 / u2));
            return lvret;
        }

        private VariantBase Div(bool signed)
        {
            VariantBase v1, v2;
            var org_v2 = PopVariant();
            var org_v1 = PopVariant();
            VariantBase ret;
            var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
            if (IsFloating(org_v1) && org_v1.GetType() == org_v2.GetType() && !signed)
            {
                if (IntPtr.Size == 8) throw new InvalidProgramException();
                if(tc == VariantBase.Vtc.Tc21Double)
                {
                    ret = new DoubleVariant();
                    ret.SetValueAbstract(double.NaN);
                } else /*if (tc == VariantBase.Vtc.Tc8Float)*/
                {
                    ret = new FloatVariant();
                    ret.SetValueAbstract(float.NaN);
                }
            } else switch (tc)
            {
                case VariantBase.Vtc.Tc9Uint:
                    uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
                    var uvret = new UintVariant();
                    ret = uvret;
                    uvret.SetValue(uv1 / uv2);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
                    var ivret = new IntVariant();
                    ret = ivret;
                    ivret.SetValue(iv1 / iv2);
                    break;
                case VariantBase.Vtc.Tc21Double:
                    double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
                    var dvret = new DoubleVariant();
                    ret = dvret;
                    if(Math.Abs(dv2) < double.Epsilon && org_v1.GetType() != org_v2.GetType()) throw new DivideByZeroException();
                    dvret.SetValue(dv1 / dv2);
                    break;
                case VariantBase.Vtc.Tc8Float:
                    float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
                    var fvret = new FloatVariant();
                    ret = fvret;
                    if (Math.Abs(fv2) < float.Epsilon && org_v1.GetType() != org_v2.GetType()) throw new DivideByZeroException();
                    fvret.SetValue(fv1 / fv2);
                    break;
                case VariantBase.Vtc.Tc24Long:
                    long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
                    var lvret = new LongVariant();
                    ret = lvret;
                    lvret.SetValue(lv1 / lv2);
                    break;
                case VariantBase.Vtc.Tc7Ulong:
                    ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
                    var ulvret = new UlongVariant();
                    ret = ulvret;
                    ulvret.SetValue(ulv1 / ulv2);
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_1);
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? OpCodes.Div : OpCodes.Div_Un);
                    gen.Emit(OpCodes.Ret);
                    ret = new IntPtrVariant();
                    ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
                    break;
            }
            return ret;
        }

        // Token: 0x060001F0 RID: 496 RVA: 0x0000B664 File Offset: 0x00009864
        private void Div_(VariantBase dummy) // \u0002\u2009
        {
            PushVariant(Div(true));
        }

        // Token: 0x0600017C RID: 380 RVA: 0x00007DF4 File Offset: 0x00005FF4
        private void Div_un_(VariantBase dummy) // \u000E\u200B
        {
            PushVariant(Div(false));
        }

        // Token: 0x0600026D RID: 621 RVA: 0x00010FF4 File Offset: 0x0000F1F4
        private static void EmitLdc(ILGenerator gen, int val) // \u0002
        {
            switch (val)
            {
                case -1:
                    gen.Emit(OpCodes.Ldc_I4_M1);
                    return;
                case 0:
                    gen.Emit(OpCodes.Ldc_I4_0);
                    return;
                case 1:
                    gen.Emit(OpCodes.Ldc_I4_1);
                    return;
                case 2:
                    gen.Emit(OpCodes.Ldc_I4_2);
                    return;
                case 3:
                    gen.Emit(OpCodes.Ldc_I4_3);
                    return;
                case 4:
                    gen.Emit(OpCodes.Ldc_I4_4);
                    return;
                case 5:
                    gen.Emit(OpCodes.Ldc_I4_5);
                    return;
                case 6:
                    gen.Emit(OpCodes.Ldc_I4_6);
                    return;
                case 7:
                    gen.Emit(OpCodes.Ldc_I4_7);
                    return;
                case 8:
                    gen.Emit(OpCodes.Ldc_I4_8);
                    return;
                default:
                    if (val > -129 && val < 128)
                    {
                        gen.Emit(OpCodes.Ldc_I4_S, (sbyte)val);
                        return;
                    }
                    gen.Emit(OpCodes.Ldc_I4, val);
                    return;
            }
        }

        // Token: 0x06000264 RID: 612 RVA: 0x00010C28 File Offset: 0x0000EE28
        private static void EnsureClass(ILGenerator gen, Type t) // \u0003
        {
            if (t == SimpleTypeHelper.ObjectType)
            {
                return;
            }
            gen.Emit(OpCodes.Castclass, t);
        }

        // Token: 0x06000277 RID: 631 RVA: 0x0001180C File Offset: 0x0000FA0C
        private static void EnsureType(ILGenerator gen, Type t) // \u0005
        {
            if (t.IsValueType || ElementedTypeHelper.TryGoToElementType(t).IsGenericParameter)
            {
                gen.Emit(OpCodes.Unbox_Any, t);
                return;
            }
            EnsureClass(gen, t);
        }

        // Token: 0x06000217 RID: 535 RVA: 0x0000C7EC File Offset: 0x0000A9EC
        private static void EnsureBoxed(ILGenerator gen, Type t) // \u0002
        {
            if (t.IsValueType || ElementedTypeHelper.TryGoToElementType(t).IsGenericParameter)
            {
                gen.Emit(OpCodes.Box, t);
            }
        }

        // Token: 0x0600023E RID: 574 RVA: 0x0000FA54 File Offset: 0x0000DC54
        private DynamicExecutor DynamicFor(MethodBase mb, bool mayVirtual) // \u0002
        {
            DynamicMethod dynamicMethod; /*= null;
            if (_alwaysFalse && (!mb.IsConstructor || !typeof(Delegate).IsAssignableFrom(mb.DeclaringType)))
            {
                dynamicMethod = new DynamicMethod(string.Empty, SimpleTypeHelper.ObjectType, new Type[]
                {
                    SimpleTypeHelper.ObjectType,
                    ObjectArrayType
                }, true);
            }
            if (dynamicMethod == null)*/
            {
                dynamicMethod = new DynamicMethod(string.Empty, SimpleTypeHelper.ObjectType, new[]
                {
                    SimpleTypeHelper.ObjectType,
                    ObjectArrayType
                }, typeof(VmExecutor).Module, true);
            }
            var iLGenerator = dynamicMethod.GetILGenerator();
            var parameters = mb.GetParameters();
            var array = new Type[parameters.Length];
            var flag = false;
            for (var i = 0; i < parameters.Length; i++)
            {
                var type = parameters[i].ParameterType;
                if (type.IsByRef)
                {
                    flag = true;
                    type = type.GetElementType();
                }
                array[i] = type;
            }
            var array2 = new LocalBuilder[array.Length];
            if (array2.Length != 0)
            {
                dynamicMethod.InitLocals = true;
            }
            for (var j = 0; j < array.Length; j++)
            {
                array2[j] = iLGenerator.DeclareLocal(array[j]);
            }
            for (var k = 0; k < array.Length; k++)
            {
                iLGenerator.Emit(OpCodes.Ldarg_1);
                EmitLdc(iLGenerator, k);
                iLGenerator.Emit(OpCodes.Ldelem_Ref);
                EnsureType(iLGenerator, array[k]);
                iLGenerator.Emit(OpCodes.Stloc, array2[k]);
            }
            if (flag)
            {
                iLGenerator.BeginExceptionBlock();
            }
            if (!mb.IsStatic && !mb.IsConstructor)
            {
                iLGenerator.Emit(OpCodes.Ldarg_0);
                var declaringType = mb.DeclaringType;
                if (declaringType.IsValueType)
                {
                    iLGenerator.Emit(OpCodes.Unbox, declaringType);
                    mayVirtual = false;
                }
                else
                {
                    EnsureClass(iLGenerator, declaringType);
                }
            }
            for (var l = 0; l < array.Length; l++)
            {
                iLGenerator.Emit(parameters[l].ParameterType.IsByRef ? OpCodes.Ldloca_S : OpCodes.Ldloc, array2[l]);
            }
            if (mb.IsConstructor)
            {
                iLGenerator.Emit(OpCodes.Newobj, (ConstructorInfo)mb);
                EnsureBoxed(iLGenerator, mb.DeclaringType);
            }
            else
            {
                var methodInfo = (MethodInfo)mb;
                if (!mayVirtual || mb.IsStatic)
                {
                    iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
                }
                else
                {
                    iLGenerator.EmitCall(OpCodes.Callvirt, methodInfo, null);
                }
                if (methodInfo.ReturnType == VoidType)
                {
                    iLGenerator.Emit(OpCodes.Ldnull);
                }
                else
                {
                    EnsureBoxed(iLGenerator, methodInfo.ReturnType);
                }
            }
            if (flag)
            {
                var local = iLGenerator.DeclareLocal(SimpleTypeHelper.ObjectType);
                iLGenerator.Emit(OpCodes.Stloc, local);
                iLGenerator.BeginFinallyBlock();
                for (var m = 0; m < array.Length; m++)
                {
                    if (parameters[m].ParameterType.IsByRef)
                    {
                        iLGenerator.Emit(OpCodes.Ldarg_1);
                        EmitLdc(iLGenerator, m);
                        iLGenerator.Emit(OpCodes.Ldloc, array2[m]);
                        if (array2[m].LocalType.IsValueType || ElementedTypeHelper.TryGoToElementType(array2[m].LocalType).IsGenericParameter)
                        {
                            iLGenerator.Emit(OpCodes.Box, array2[m].LocalType);
                        }
                        iLGenerator.Emit(OpCodes.Stelem_Ref);
                    }
                }
                iLGenerator.EndExceptionBlock();
                iLGenerator.Emit(OpCodes.Ldloc, local);
            }
            iLGenerator.Emit(OpCodes.Ret);
            return (DynamicExecutor)dynamicMethod.CreateDelegate(typeof(DynamicExecutor));
        }

        // Token: 0x06000209 RID: 521 RVA: 0x0000C4D0 File Offset: 0x0000A6D0
        private static bool HasByRefParameter(MethodBase mb) // \u0002
        {
            return mb.GetParameters().Any(t => t.ParameterType.IsByRef);
        }

        // Token: 0x060001D9 RID: 473 RVA: 0x0000A72C File Offset: 0x0000892C
        private object Invoke(MethodBase mb, object obj, object[] args) // \u0002
        {
            if (mb.IsConstructor)
            {
                // ReSharper disable once AssignNullToNotNullAttribute
                return Activator.CreateInstance(mb.DeclaringType, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args, null);
            }
            return mb.Invoke(obj, args);
        }

        // Token: 0x06000286 RID: 646 RVA: 0x00011EFC File Offset: 0x000100FC
        private object InvokeDynamic(MethodBase mb, object obj, object[] args, bool mayVirtual) // \u0002
        {
            /*if (!_alwaysTrue)
            {
                return Invoke(mb, obj, args);
            }*/
            var key = new MethodBaseAndVirtual(mb, mayVirtual);
            DynamicExecutor executor;
            lock (_dynamicExecutors)
            {
                _dynamicExecutors.TryGetValue(key, out executor);
            }
            if (executor == null)
            {
                bool needFaster;
                lock (_mbCallCnt)
                {
                    int num;
                    _mbCallCnt.TryGetValue(mb, out num);
                    needFaster = num >= 50;
                    if (!needFaster)
                    {
                        _mbCallCnt[mb] = num + 1;
                    }
                }
                if (!needFaster && !mayVirtual && obj == null && !mb.IsStatic && !mb.IsConstructor)
                {
                    needFaster = true;
                }
                if (!needFaster && HasByRefParameter(mb))
                {
                    needFaster = true;
                }
                if (!needFaster)
                {
                    return Invoke(mb, obj, args);
                }
                lock (_mbDynamicLock)
                {
                    while (_mbDynamicLock.ContainsKey(mb))
                    {
                        Monitor.Wait(_mbDynamicLock);
                    }
                    _mbDynamicLock[mb] = null;
                }
                try
                {
                    lock (_dynamicExecutors)
                    {
                        _dynamicExecutors.TryGetValue(key, out executor);
                    }
                    if (executor == null)
                    {
                        executor = DynamicFor(mb, mayVirtual);
                        lock (_dynamicExecutors)
                        {
                            _dynamicExecutors[key] = executor;
                        }
                    }
                    lock (_mbCallCnt)
                    {
                        _mbCallCnt.Remove(mb);
                    }
                }
                finally
                {
                    lock (_mbDynamicLock)
                    {
                        _mbDynamicLock.Remove(mb);
                        Monitor.PulseAll(_mbDynamicLock);
                    }
                }
            }
            return executor(obj, args);
        }

        // Token: 0x0600028D RID: 653 RVA: 0x000122A4 File Offset: 0x000104A4
        private VariantBase FetchByAddr(VariantBase addr) // \u0003
        {
            if (!addr.IsAddr())
            {
                throw new ArgumentException();
            }
            var num = addr.GetTypeCode();
            if (num == VariantBase.Vtc.Tc0VariantBaseHolder)
            {
                return ((VariantBaseHolder)addr).GetValue();
            }
            if (num != VariantBase.Vtc.Tc4FieldInfo)
            {
                switch (num)
                {
                    case VariantBase.Vtc.Tc20MdArrayValue:
                    case VariantBase.Vtc.Tc22SdArrayValue:
                        {
                            var avv = (ArrayValueVariantBase)addr;
                            return VariantFactory.Convert(avv.GetValue(), avv.GetHeldType());
                        }
                    case VariantBase.Vtc.Tc23LocalsIdxHolder:
                        return _localVariables[((LocalsIdxHolderVariant)addr).GetValue()];
                }
                throw new ArgumentOutOfRangeException();
            }
            var fiv = (FieldInfoVariant)addr;
            return VariantFactory.Convert(fiv.GetValue().GetValue(fiv.GetObject()), null);
        }

        // Token: 0x06000186 RID: 390 RVA: 0x00008150 File Offset: 0x00006350
        private FieldInfo ResolveField(int id) // \u0002
        {
            FieldInfo result;
            lock (AllMetadataById)
            {
                object md;
                if (AllMetadataById.TryGetValue(id, out md))
                {
                    result = (FieldInfo)md;
                }
                else
                {
                    var U0003U2008 = ReadToken(id);
                    if (U0003U2008.IsVm == 0)
                    {
                        result = _module.ResolveField(U0003U2008.MetadataToken);
                    }
                    else
                    {
                        var u000Fu2006 = (VmFieldTokenInfo)U0003U2008.VmToken;
                        var expr_70 = GetTypeById(u000Fu2006.Class.MetadataToken);
                        var bindingAttr = BF(u000Fu2006.IsStatic);
                        var field = expr_70.GetField(u000Fu2006.Name, bindingAttr);
                        if (!expr_70.IsGenericType)
                        {
                            AllMetadataById.Add(id, field);
                        }
                        result = field;
                    }
                }
            }
            return result;
        }

        // Token: 0x06000177 RID: 375 RVA: 0x00007CD8 File Offset: 0x00005ED8
        private void Ldflda_(VariantBase vFieldId) // \u0003\u2009
        {
            var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
            var reference = PopVariant();
            var obj = reference.IsAddr() ? FetchByAddr(reference).GetValueAbstract() : reference.GetValueAbstract();
            var val = new FieldInfoVariant();
            val.SetValue(fieldInfo);
            val.SetObject(obj);
            PushVariant(val);
        }

        // Token: 0x0600018F RID: 399 RVA: 0x0000840C File Offset: 0x0000660C
        private void Ldsflda_(VariantBase vFieldId) // \u000E\u2002
        {
            var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
            var val = new FieldInfoVariant();
            val.SetValue(fieldInfo);
            PushVariant(val);
        }

        // Token: 0x0600017D RID: 381 RVA: 0x00007E20 File Offset: 0x00006020
        private void Ldtoken_(VariantBase vToken) // \u0005\u2002\u2000
        {
            var t = ReadToken(((IntVariant)vToken).GetValue());
            object obj;
            if (t.IsVm == 0)
            {
                obj = ResolveNativeToken(t.MetadataToken);
            }
            else
            {
                switch (t.VmToken.TokenKind())
                {
                    case VmTokenInfo.Kind.Class0:
                        obj = GetTypeById(((IntVariant)vToken).GetValue()).TypeHandle;
                        break;
                    case VmTokenInfo.Kind.Field1:
                        obj = ResolveField(((IntVariant)vToken).GetValue()).FieldHandle;
                        break;
                    case VmTokenInfo.Kind.Method2:
                        obj = FindMethodById(((IntVariant)vToken).GetValue()).MethodHandle;
                        break;
                    default:
                        throw new InvalidOperationException();
                }
            }
            var push = new ObjectVariant();
            push.SetValue(obj);
            PushVariant(push);
        }

        // Token: 0x06000206 RID: 518 RVA: 0x0000C1C8 File Offset: 0x0000A3C8
        private void Ldfld_(VariantBase vFieldId) // \u0005\u2003\u2001
        {
            var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
            var reference = PopVariant();
            if (reference.IsAddr())
            {
                reference = FetchByAddr(reference);
            }
            var obj = reference.GetValueAbstract();
            if (obj == null)
            {
                throw new NullReferenceException();
            }
            PushVariant(VariantFactory.Convert(fieldInfo.GetValue(obj), fieldInfo.FieldType));
        }

        // Token: 0x06000225 RID: 549 RVA: 0x0000F2CC File Offset: 0x0000D4CC
        private void Ldsfld_(VariantBase vFieldId) // \u000F\u2004\u2000
        {
            var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
            PushVariant(VariantFactory.Convert(fieldInfo.GetValue(null), fieldInfo.FieldType));
        }

        // Token: 0x0600024A RID: 586 RVA: 0x0001034C File Offset: 0x0000E54C
        private void Newobj_(VariantBase vCtrId) // \u0002\u200A
        {
            var num = ((IntVariant)vCtrId).GetValue();
            var methodBase = FindMethodById(num);
            var declaringType = methodBase.DeclaringType;
            var parameters = methodBase.GetParameters();
            var expr_2A = parameters.Length;
            var array = new object[expr_2A];
            var dictionary = new Dictionary<int, VariantBase>();
            for (var i = expr_2A - 1; i >= 0; i--)
            {
                var u000F = PopVariant();
                if (u000F.IsAddr())
                {
                    dictionary.Add(i, u000F);
                    u000F = FetchByAddr(u000F);
                }
                if (u000F.GetVariantType() != null)
                {
                    u000F = VariantFactory.Convert(null, u000F.GetVariantType()).CopyFrom(u000F);
                }
                var u000F2 = VariantFactory.Convert(null, parameters[i].ParameterType).CopyFrom(u000F);
                array[i] = u000F2.GetValueAbstract();
            }
            object obj;
            try
            {
                obj = InvokeDynamic(methodBase, null, array, false);
            }
            catch (TargetInvocationException ex)
            {
                var expr_C2 = ex.InnerException ?? ex;
                SerializeCrossDomain(expr_C2);
                throw expr_C2;
            }
            foreach (var current in dictionary)
            {
                AssignByReference(current.Value, VariantFactory.Convert(array[current.Key], null));
            }
            PushVariant(VariantFactory.Convert(obj, declaringType));
        }

        // Token: 0x06000227 RID: 551 RVA: 0x0000F3B4 File Offset: 0x0000D5B4
        private void AssignByReference(VariantBase refDest, VariantBase val) // \u0002
        {
            switch (refDest.GetTypeCode())
            {
                case VariantBase.Vtc.Tc0VariantBaseHolder:
                    ((VariantBaseHolder)refDest).GetValue().CopyFrom(val);
                    return;
                case VariantBase.Vtc.Tc4FieldInfo:
                    var refFieldInfoDest = (FieldInfoVariant)refDest;
                    var fieldInfo = refFieldInfoDest.GetValue();
                    fieldInfo.SetValue(refFieldInfoDest.GetObject(), VariantFactory.Convert(val.GetValueAbstract(), fieldInfo.FieldType).GetValueAbstract());
                    return;
                case VariantBase.Vtc.Tc20MdArrayValue:
                case VariantBase.Vtc.Tc22SdArrayValue:
                    var refArrayValueDest = (ArrayValueVariantBase)refDest;
                    refArrayValueDest.SetValue(VariantFactory.Convert(val.GetValueAbstract(), refArrayValueDest.GetHeldType()).GetValueAbstract());
                    return;
                case VariantBase.Vtc.Tc23LocalsIdxHolder:
                    _localVariables[((LocalsIdxHolderVariant)refDest).GetValue()].CopyFrom(val);
                    return;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        // Token: 0x060001E5 RID: 485 RVA: 0x0000AD10 File Offset: 0x00008F10
        private void Invoke(MethodBase mb, bool mayVirtual) // \u0002
        {
            if (!mayVirtual && IsCompatible(mb))
            {
                mb = GenerateDynamicCall(mb, false);
            }
            var parameters = mb.GetParameters();
            var num = parameters.Length;
            var poppedArgs = new VariantBase[num];
            var args = new object[num];
            var wasLocked = default(BoolHolder);
            try
            {
                LockIfInterlocked(ref wasLocked, mb, mayVirtual);
                for (var i = num - 1; i >= 0; i--)
                {
                    var u000F = PopVariant();
                    poppedArgs[i] = u000F;
                    if (u000F.IsAddr())
                    {
                        u000F = FetchByAddr(u000F);
                    }
                    if (u000F.GetVariantType() != null)
                    {
                        u000F = VariantFactory.Convert(null, u000F.GetVariantType()).CopyFrom(u000F);
                    }
                    var u000F2 = VariantFactory.Convert(null, parameters[i].ParameterType).CopyFrom(u000F);
                    args[i] = u000F2.GetValueAbstract();
                }
                VariantBase u000F3 = null;
                if (!mb.IsStatic)
                {
                    u000F3 = PopVariant();
                    if (u000F3?.GetVariantType() != null)
                    {
                        u000F3 = VariantFactory.Convert(null, u000F3.GetVariantType()).CopyFrom(u000F3);
                    }
                }
                object obj = null;
                try
                {
                    if (mb.IsConstructor)
                    {
                        obj = Activator.CreateInstance(mb.DeclaringType, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args, null);
                        if (u000F3 != null && !u000F3.IsAddr())
                        {
                            throw new InvalidOperationException();
                        }
                        AssignByReference(u000F3, VariantFactory.Convert(obj, mb.DeclaringType));
                    }
                    else
                    {
                        object poppedThis = null;
                        if (u000F3 != null)
                        {
                            var u000F4 = u000F3;
                            if (u000F3.IsAddr())
                            {
                                u000F4 = FetchByAddr(u000F3);
                            }
                            poppedThis = u000F4.GetValueAbstract();
                        }
                        try
                        {
                            if (!InvokeFilter(mb, poppedThis, ref obj, args))
                            {
                                if (mayVirtual && !mb.IsStatic && poppedThis == null)
                                {
                                    throw new NullReferenceException();
                                }
                                if (!AlwaysFalse(mb, poppedThis, poppedArgs, args, mayVirtual, ref obj))
                                {
                                    obj = InvokeDynamic(mb, poppedThis, args, mayVirtual);
                                }
                            }
                            if (u000F3 != null && u000F3.IsAddr())
                            {
                                AssignByReference(u000F3, VariantFactory.Convert(poppedThis, mb.DeclaringType));
                            }
                        }
                        catch (TargetInvocationException ex)
                        {
                            var cause = ex.InnerException ?? ex;
                            SerializeCrossDomain(cause);
                            throw cause;
                        }
                    }
                }
                finally
                {
                    for (var j = 0; j < poppedArgs.Length; j++)
                    {
                        var u000F5 = poppedArgs[j];
                        if (u000F5.IsAddr())
                        {
                            var obj3 = args[j];
                            AssignByReference(u000F5, VariantFactory.Convert(obj3, null));
                        }
                    }
                }
                var methodInfo = mb as MethodInfo;
                if (methodInfo != null)
                {
                    var returnType = methodInfo.ReturnType;
                    if (returnType != VoidType)
                    {
                        PushVariant(VariantFactory.Convert(obj, returnType));
                    }
                }
            }
            finally
            {
                UnlockInterlockedIfAny(ref wasLocked);
            }
        }

        // Token: 0x060001FD RID: 509 RVA: 0x0000BD88 File Offset: 0x00009F88
        private void DoJmp(int pos, Type[] methodGenericArgs, Type[] classGenericArgs, bool mayVirtual) // \u0002
        {
            _srcVirtualizedStreamReader.BaseStream.Seek(pos, SeekOrigin.Begin);
            DoNothing(_srcVirtualizedStreamReader);
            var u0006 = ReadMethodHeader(_srcVirtualizedStreamReader);
            var num = u0006.ArgsTypeToOutput.Length;
            var array = new object[num];
            var array2 = new VariantBase[num];
            if (_currentClass != null & mayVirtual)
            {
                var num2 = u0006.IsStatic() ? 0 : 1;
                var array3 = new Type[num - num2];
                for (var i = num - 1; i >= num2; i--)
                {
                    array3[i] = GetTypeById(u0006.ArgsTypeToOutput[i].TypeId);
                }
                var method = _currentClass.GetMethod(u0006.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty, null, array3, null);
                _currentClass = null;
                if (method != null)
                {
                    Invoke(method, true);
                    return;
                }
            }
            for (var j = num - 1; j >= 0; j--)
            {
                var u000F = PopVariant();
                array2[j] = u000F;
                if (u000F.IsAddr())
                {
                    u000F = FetchByAddr(u000F);
                }
                if (u000F.GetVariantType() != null)
                {
                    u000F = VariantFactory.Convert(null, u000F.GetVariantType()).CopyFrom(u000F);
                }
                var u000F2 = VariantFactory.Convert(null, GetTypeById(u0006.ArgsTypeToOutput[j].TypeId)).CopyFrom(u000F);
                array[j] = u000F2.GetValueAbstract();
                if (j == 0 & mayVirtual && !u0006.IsStatic() && array[j] == null)
                {
                    throw new NullReferenceException();
                }
            }
            var u0006u2007 = new VmExecutor(_instrCodesDb);
            var callees = new object[]
            {
                _module.Assembly
            };
            object obj;
            try
            {
                obj = u0006u2007.Invoke(_srcVirtualizedStream, pos, array, methodGenericArgs, classGenericArgs, callees);
            }
            finally
            {
                for (var k = 0; k < array2.Length; k++)
                {
                    var u000F3 = array2[k];
                    if (u000F3.IsAddr())
                    {
                        var obj2 = array[k];
                        AssignByReference(u000F3, VariantFactory.Convert(obj2, null));
                    }
                }
            }
            var type = u0006u2007.GetTypeById(u0006u2007._methodHeader.ReturnTypeId);
            if (type != VoidType)
            {
                PushVariant(VariantFactory.Convert(obj, type));
            }
        }

        // Token: 0x0600027A RID: 634 RVA: 0x00011994 File Offset: 0x0000FB94
        private void JmpToRef(VmMethodRefTokenInfo mref) // \u0002
        {
            //var arg_18_0 = (U0008U2007)U0003U2008.Get_u0005();
            var methodBase = FindMethodById(mref.Pos, ReadToken(mref.Pos));
            //methodBase.GetParameters();
            var num = mref.Flags;
            var mayVirtual = (num & 1073741824) != 0;
            num &= -1073741825;
            var methodGenericArgs = _methodGenericArgs;
            var classGenericArgs = _classGenericArgs;
            try
            {
                _methodGenericArgs = methodBase is ConstructorInfo ? Type.EmptyTypes : methodBase.GetGenericArguments();
                _classGenericArgs = methodBase.DeclaringType.GetGenericArguments();
                DoJmp(num, _methodGenericArgs, _classGenericArgs, mayVirtual);
            }
            finally
            {
                _methodGenericArgs = methodGenericArgs;
                _classGenericArgs = classGenericArgs;
            }
        }

        // Token: 0x060001EE RID: 494 RVA: 0x0000B5FC File Offset: 0x000097FC
        private void Jmp_(VariantBase vPos) // \u0008\u200B\u2000
        {
            var pos = ((IntVariant)vPos).GetValue();
            var arg_29_0 = (pos & -2147483648) != 0;
            var mayVirtual = (pos & 1073741824) != 0;
            pos &= 1073741823;
            if (arg_29_0)
            {
                DoJmp(pos, null, null, mayVirtual);
                return;
            }
            JmpToRef((VmMethodRefTokenInfo)ReadToken(pos).VmToken);
        }

        // Token: 0x06000199 RID: 409 RVA: 0x00008660 File Offset: 0x00006860
        private void Calli_(VariantBase dummy) // \u0003\u2002
        {
            var methodBase = ((MethodVariant)PopVariant()).GetValue();
            Invoke(methodBase, false);
        }

        // Token: 0x06000184 RID: 388 RVA: 0x000080F4 File Offset: 0x000062F4
        private void Call_(VariantBase vMethodId) // \u000E\u2003
        {
            var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
            foreach (var arg in _variantOutputArgs)
            {
                PushVariant(arg);
            }
            Invoke(methodBase, false);
        }

        // Token: 0x06000191 RID: 401 RVA: 0x0000845C File Offset: 0x0000665C
        private void Callvirt_(VariantBase vMethodId) // \u000E\u2005
        {
            var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
            if (_currentClass != null)
            {
                var pars = methodBase.GetParameters();
                var types = new Type[pars.Length];
                var num = 0;
                foreach (var parameterInfo in pars)
                {
                    types[num++] = parameterInfo.ParameterType;
                }
                var method = _currentClass.GetMethod(methodBase.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty, null, types, null);
                if (method != null)
                {
                    methodBase = method;
                }
                _currentClass = null;
            }
            Invoke(methodBase, true);
        }

        // Token: 0x060001CE RID: 462 RVA: 0x0000A1A0 File Offset: 0x000083A0
        private void Invoke(VariantBase vMethodId) // \u000E\u200A
        {
            var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
            Invoke(methodBase, false);
        }

        // Token: 0x06000205 RID: 517 RVA: 0x0000C1A8 File Offset: 0x0000A3A8
        [DebuggerNonUserCode]
        private MethodBase FindMethodById(int methodId) // \u0002
        {
            return FindMethodById(methodId, ReadToken(methodId));
        }

        // Token: 0x06000171 RID: 369 RVA: 0x00007BBC File Offset: 0x00005DBC
        private object Invoke(Stream srcVirtualizedStream, int pos, object[] args, Type[] methodGenericArgs, Type[] classGenericArgs, object[] callees) // \u0002
        {
		    _srcVirtualizedStream = srcVirtualizedStream;
		    Seek(pos, srcVirtualizedStream, null);
		    return Invoke(args, methodGenericArgs, classGenericArgs, callees);
	    }

	    // Token: 0x06000172 RID: 370 RVA: 0x00007BDC File Offset: 0x00005DDC
	    private bool AlwaysFalse(MethodBase mb, object poppedThis, VariantBase[] poppedArgs, object[] args, bool mayVirtual, ref object obj) // \u0002
        {
		    return false;
        }

	    // Token: 0x06000179 RID: 377 RVA: 0x00007DA8 File Offset: 0x00005FA8
	    private void Leave_(VariantBase vTarget) // \u0006\u200B
        {
            OnException(null, ((UintVariant)vTarget).GetValue());
	    }

	    // Token: 0x06000180 RID: 384 RVA: 0x00007F48 File Offset: 0x00006148
	    private void Castclass_(VariantBase vTypeId) // \u0005\u2003
        {
            var type = GetTypeById(((IntVariant)vTypeId).GetValue());
		    var obj = PopVariant();
		    if (Isinst(obj, type))
		    {
			    PushVariant(obj);
			    return;
		    }
		    throw new InvalidCastException();
	    }

        // Token: 0x06000185 RID: 389 RVA: 0x00008144 File Offset: 0x00006344
        private void Ldc_i4_s_(VariantBase val) // \u000E\u2003\u2000
        {
		    PushVariant(val);
	    }

	    // Token: 0x0600018B RID: 395 RVA: 0x0000827C File Offset: 0x0000647C
	    private void Stelem_i2_(VariantBase dummy) // \u000E\u200A\u2000
        {
		    var obj = PopVariant().GetValueAbstract();
		    var idx = PopLong();
		    var array = (Array)PopVariant().GetValueAbstract();
		    var elementType = array.GetType().GetElementType();
		    checked
		    {
			    if (elementType == typeof(short))
			    {
                    ((short[])array)[(int)(IntPtr)idx] = (short)VariantFactory.Convert(obj, typeof(short)).GetValueAbstract();
				    return;
			    }
			    if (elementType == typeof(ushort))
			    {
                    ((ushort[])array)[(int)(IntPtr)idx] = (ushort)VariantFactory.Convert(obj, typeof(ushort)).GetValueAbstract();
				    return;
			    }
			    if (elementType == typeof(char))
			    {
                    ((char[])array)[(int)(IntPtr)idx] = (char)VariantFactory.Convert(obj, typeof(char)).GetValueAbstract();
				    return;
			    }
			    if (elementType.IsEnum)
			    {
                    Stelem(elementType, obj, idx, array);
				    return;
			    }
                Stelem(typeof(short), obj, idx, array);
		    }
	    }

	    // Token: 0x0600018E RID: 398 RVA: 0x00008404 File Offset: 0x00006604
	    private void Stind_i_(VariantBase dummy) // \u000F\u2006
        {
		    Stind();
	    }

	    // Token: 0x06000190 RID: 400 RVA: 0x00008440 File Offset: 0x00006640
	    private void Ldloc_0_(VariantBase dummy) // \u0006
        {
		    PushVariant(_localVariables[0].Clone());
	    }

	    // Token: 0x06000193 RID: 403 RVA: 0x00008508 File Offset: 0x00006708
	    private void And_(VariantBase dummy) // \u000F\u200B\u2000
        {
		    PushVariant(And(PopVariant(), PopVariant()));
	    }

	    // Token: 0x06000194 RID: 404 RVA: 0x00008534 File Offset: 0x00006734
	    private void Bge_un_(VariantBase vpos) // \u0006\u2009
	    {
		    var v2 = PopVariant();
            if (UniCompare(PopVariant(), v2, ComparisonKind.GE, true))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
		    }
	    }

        // Token: 0x06000198 RID: 408 RVA: 0x00008628 File Offset: 0x00006828
        private void Blt_un_(VariantBase vpos) // \u0006\u2006\u2000
        {
            var v2 = PopVariant();
            if (UniCompare(PopVariant(), v2, ComparisonKind.LT, true))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x06000234 RID: 564 RVA: 0x0000F934 File Offset: 0x0000DB34
        private void Bge_(VariantBase vpos) // \u0002\u200B
        {
            var v2 = PopVariant();
            if (UniCompare(PopVariant(), v2, ComparisonKind.GE, false))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x060002AB RID: 683 RVA: 0x00012D80 File Offset: 0x00010F80
        private void Blt_(VariantBase vpos) // \u0003\u2001
        {
            var v2 = PopVariant();
            if (UniCompare(PopVariant(), v2, ComparisonKind.LT, false))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x0600023D RID: 573 RVA: 0x0000FA1C File Offset: 0x0000DC1C
        private void Bgt_(VariantBase vpos) // \u000F\u2000\u2001
        {
            var v2 = PopVariant();
            if (UniCompare(PopVariant(), v2, ComparisonKind.GT, false))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x060001A3 RID: 419 RVA: 0x00008D10 File Offset: 0x00006F10
        private void Bgt_un_(VariantBase vpos) // \u0005\u2004
        {
            var v2 = PopVariant();
            if (UniCompare(PopVariant(), v2, ComparisonKind.GT, true))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x06000261 RID: 609 RVA: 0x00010BB4 File Offset: 0x0000EDB4
        private void Bne_un_(VariantBase vpos) // \u000F\u2007
        {
            var v2 = PopVariant();
            if (UniCompare(PopVariant(), v2, ComparisonKind.NEQ, true))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x0600029D RID: 669 RVA: 0x000126E0 File Offset: 0x000108E0
        private void Beq_(VariantBase vpos) // \u0002\u2007\u2000
        {
            var v2 = PopVariant();
            if (UniCompare(PopVariant(), v2, ComparisonKind.EQ, false))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x060001B9 RID: 441 RVA: 0x000093F8 File Offset: 0x000075F8
        private void Ble_un_(VariantBase vpos) // \u0003\u2007\u2000
        {
            var v2 = PopVariant();
            var v1 = PopVariant();
            if (UniCompare(v1, v2, ComparisonKind.LE, true))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        private static bool IsFloating(VariantBase v)
        {
            return v.GetTypeCode() == VariantBase.Vtc.Tc21Double || v.GetTypeCode() == VariantBase.Vtc.Tc8Float;
        }
        // Token: 0x06000297 RID: 663 RVA: 0x0001253C File Offset: 0x0001073C
        private void Ble_(VariantBase vpos) // \u0002\u2003\u2000
        {
            var v2 = PopVariant();
            var v1 = PopVariant();
            if (UniCompare(v1, v2, ComparisonKind.LE, false))
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x06000228 RID: 552 RVA: 0x0000F480 File Offset: 0x0000D680
        private void Brfalse_(VariantBase vpos) // \u0002\u2002
        {
            var val = PopVariant();
            var num = val.GetTypeCode();
            bool flag;
            switch (num)
            {
                case VariantBase.Vtc.Tc5Enum:
                    flag = !Convert.ToBoolean(((EnumVariant)val).GetValue());
                    break;
                case VariantBase.Vtc.Tc13UIntPtr:
                    flag = ((UIntPtrVariant)val).GetValue() == UIntPtr.Zero;
                    break;
                case VariantBase.Vtc.Tc17IntPtr:
                    flag = ((IntPtrVariant)val).GetValue() == IntPtr.Zero;
                    break;
                case VariantBase.Vtc.Tc18Object:
                    flag = ((ObjectVariant)val).GetValue() == null;
                    break;
                case VariantBase.Vtc.Tc19Int:
                    flag = ((IntVariant)val).GetValue() == 0;
                    break;
                case VariantBase.Vtc.Tc24Long:
                    flag = ((LongVariant)val).GetValue() == 0L;
                    break;
                default:
                    flag = val.GetValueAbstract() == null;
                    break;
            }
            if (flag)
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x06000274 RID: 628 RVA: 0x00011488 File Offset: 0x0000F688
        private void ExecuteExceptionHandler() // \u0005
        {
            if (_ehStack.Count == 0)
            {
                if (_wasException)
                {
                    _myBufferPos = _myBufferReader.GetBuffer().GetPos();
                    ThrowStoreCrossDomain(_exception);
                }
                return;
            }
            var ehFrame = _ehStack.PopBack();
            if (ehFrame.Exception != null)
            {
                var toStack = new ObjectVariant();
                toStack.SetValueAbstract(ehFrame.Exception);
                PushVariant(toStack);
            }
            else
            {
                _evalStack.Clear();
            }
            JumpToPos(ehFrame.Pos);
        }

        // Token: 0x060001F2 RID: 498 RVA: 0x0000B6C8 File Offset: 0x000098C8
        private void Switch_(VariantBase vSwitchPosArray) // \u0002\u200A\u2000
        {
            var vidx = PopVariant();
            uint idx;
            switch (vidx.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    idx = (uint)Convert.ToInt64(vidx.GetValueAbstract());
                    break;
                case VariantBase.Vtc.Tc19Int:
                    idx = (uint)((IntVariant)vidx).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    idx = (uint)((LongVariant)vidx).GetValue();
                    break;
                default:
                    throw new InvalidOperationException();
            }
            var switchPosArray = (IntVariant[])((ArrayVariant)vSwitchPosArray).GetValue();
            if (idx >= (ulong)switchPosArray.Length)
            {
                return;
            }
            JumpToPos((uint)switchPosArray[(int)idx].GetValue());
        }

        // Token: 0x060001FB RID: 507 RVA: 0x0000BC68 File Offset: 0x00009E68
        private void Brtrue_(VariantBase vpos) // \u0008\u2007
        {
            var val = PopVariant();
            var num = val.GetTypeCode();
            bool flag;
            switch (num)
            {
                case VariantBase.Vtc.Tc5Enum:
                    flag = Convert.ToBoolean(((EnumVariant)val).GetValue());
                    break;
                case VariantBase.Vtc.Tc13UIntPtr:
                    flag = ((UIntPtrVariant)val).GetValue() != UIntPtr.Zero;
                    break;
                case VariantBase.Vtc.Tc17IntPtr:
                    flag = ((IntPtrVariant)val).GetValue() != IntPtr.Zero;
                    break;
                case VariantBase.Vtc.Tc18Object:
                    flag = ((ObjectVariant)val).GetValue() != null;
                    break;
                case VariantBase.Vtc.Tc19Int:
                    flag = ((IntVariant)val).GetValue() != 0;
                    break;
                case VariantBase.Vtc.Tc24Long:
                    flag = ((LongVariant)val).GetValue() != 0L;
                    break;
                default:
                    flag = val.GetValueAbstract() != null;
                    break;
            }
            if (flag)
            {
                JumpToPos(((UintVariant)vpos).GetValue());
            }
        }

        // Token: 0x06000214 RID: 532 RVA: 0x0000C764 File Offset: 0x0000A964
        private void Br_(VariantBase vpos) // \u0005\u2008\u2000
        {
            JumpToPos(((UintVariant)vpos).GetValue());
        }

        private void Conv_r_un_(VariantBase dummy)
        {
            var pop = PopVariant();
            double val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                    if (Marshal.SizeOf(v) < 8)
                        val = (double)(uint)Convert.ToInt32(v);
                    else
                        val = (double)(ulong)Convert.ToInt64(v);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    val = (double)(uint)((IntVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc21Double:
                    val = ((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    val = (double)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    val = (double)(ulong)((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(double), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(OpCodes.Conv_R_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (double)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new DoubleVariant();
            push.SetValue(val);
            PushVariant(push);
        }

        private void Conv_r(OpCode oc, Func<object, double> F)
        {
            var pop = PopVariant();
            double val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                    val = F(Marshal.SizeOf(v) < 8 ? Convert.ToInt32(v) : Convert.ToInt64(v));
                    break;
                case VariantBase.Vtc.Tc19Int:
                    val = F(((IntVariant)pop).GetValue());
                    break;
                case VariantBase.Vtc.Tc21Double:
                    val = F(((DoubleVariant)pop).GetValue());
                    break;
                case VariantBase.Vtc.Tc8Float:
                    val = F(((FloatVariant)pop).GetValue());
                    break;
                case VariantBase.Vtc.Tc24Long:
                    val = F(((LongVariant)pop).GetValue());
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(double), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(oc);
                    gen.Emit(OpCodes.Ret);
                    val = (double)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new DoubleVariant();
            push.SetValue(val);
            PushVariant(push);
        }
        private void Conv_r4_(VariantBase dummy)
        {
            Conv_r(OpCodes.Conv_R4, o => (double)(float)Convert.ChangeType(o, typeof(float)));
        }
        private void Conv_r8_(VariantBase dummy)
        {
            Conv_r(OpCodes.Conv_R8, o => (double)Convert.ChangeType(o, typeof(double)));
        }

        // Token: 0x06000196 RID: 406 RVA: 0x00008600 File Offset: 0x00006800
        private void Ldind_i4_(VariantBase dummy) // \u0002\u2001\u2000
        {
		    Ldind(typeof(int));
	    }

	    // Token: 0x06000197 RID: 407 RVA: 0x00008614 File Offset: 0x00006814
	    private void Ldind_u1_(VariantBase dummy) // \u000E
        {
		    Ldind(typeof(byte));
	    }

	    // Token: 0x0600019A RID: 410 RVA: 0x00008688 File Offset: 0x00006888
	    private void Isinst_(VariantBase vTypeId) // \u000F\u2007\u2000 
        {
            var type = GetTypeById(((IntVariant)vTypeId).GetValue());
		    var obj = PopVariant();
		    if (Isinst(obj, type))
		    {
			    PushVariant(obj);
			    return;
		    }
		    PushVariant(new ObjectVariant());
	    }

	    // Token: 0x0600019D RID: 413 RVA: 0x00008B68 File Offset: 0x00006D68
	    private void Initobj_(VariantBase vTypeId) // \u0005\u2005\u2000 
        {
            var type = GetTypeById(((IntVariant)vTypeId).GetValue());
		    var dest = PopVariant();
		    if (!type.IsValueType)
		    {
                AssignByReference(dest, new ObjectVariant());
			    return;
		    }
		    var obj = FetchByAddr(dest).GetValueAbstract();
		    if (SimpleTypeHelper.IsNullableGeneric(type))
		    {
			    var val = new ObjectVariant();
			    val.SetVariantType(type);
                AssignByReference(dest, val);
			    return;
		    }
		    var fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
		    foreach (var fieldInfo in fields)
		    {
		        fieldInfo.SetValue(obj, CreateValueTypeInstance(fieldInfo.FieldType));
		    }
	    }

	    // Token: 0x0600019E RID: 414 RVA: 0x00008C08 File Offset: 0x00006E08
	    private void Ldarg_s_(VariantBase vidx) // \u000E\u2000
        {
		    var idx = (ByteVariant)vidx;
		    PushVariant(_variantOutputArgs[idx.GetValue()].Clone());
	    }

        // Token: 0x06000244 RID: 580 RVA: 0x00010160 File Offset: 0x0000E360
        private void Ldarga_s_(VariantBase vidx) // \u0008\u2001\u2001
        {
            var idx = (ByteVariant)vidx;
            var push = new VariantBaseHolder();
            push.SetValue(_variantOutputArgs[idx.GetValue()]);
            PushVariant(push);
        }

        // Token: 0x06000255 RID: 597 RVA: 0x00010910 File Offset: 0x0000EB10
        private void Ldarga_(VariantBase vidx) // \u0006\u2001
        {
            var idx = (UshortVariant)vidx;
            var push = new VariantBaseHolder();
            push.SetValue(_variantOutputArgs[idx.GetValue()]);
            PushVariant(push);
        }

        // Token: 0x0600019F RID: 415 RVA: 0x00008C38 File Offset: 0x00006E38
        private void Endfilter_(VariantBase dummy) // \u000F\u2001\u2000
        {
		    if (((IntVariant)PopVariant()).GetValue() != 0)
		    {
                _ehStack.PushBack(new ExcHandlerFrame
                {
                    Pos = (uint)_myBufferReader.GetBuffer().GetPos(),
                    Exception = _exception
                });
			    _wasException = false;
		    }
		    ExecuteExceptionHandler();
	    }

	    // Token: 0x060001A2 RID: 418 RVA: 0x00008CFC File Offset: 0x00006EFC
	    private void Ldind_r4_(VariantBase dummy) // \u0008\u2009\u2000
        {
		    Ldind(typeof(float));
	    }

	    // Token: 0x060001A4 RID: 420 RVA: 0x00008D48 File Offset: 0x00006F48
	    private void Stsfld_(VariantBase vFieldId) // \u000F\u2008
        {
            var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
		    var val = VariantFactory.Convert(PopVariant().GetValueAbstract(), fieldInfo.FieldType);
		    fieldInfo.SetValue(null, val.GetValueAbstract());
	    }

	    // Token: 0x060001A5 RID: 421 RVA: 0x00008D90 File Offset: 0x00006F90
	    private void Ldloc_3_(VariantBase dummy) // \u0003\u2001\u2001
        {
		    PushVariant(_localVariables[3].Clone());
	    }

	    // Token: 0x060001A7 RID: 423 RVA: 0x00008F68 File Offset: 0x00007168
	    private void Stelem_r8_(VariantBase dummy) // \u000E\u2006\u2000
        {
		    Stelem(typeof(double));
	    }

	    // Token: 0x060001AA RID: 426 RVA: 0x00008FBC File Offset: 0x000071BC
	    private void Ceq_(VariantBase dummy) // \u0006\u2008
        {
		    var iv = new IntVariant();
            iv.SetValue(UniCompare(PopVariant(), PopVariant(), ComparisonKind.EQ, false) ? 1 : 0);
		    PushVariant(iv);
	    }

	    // Token: 0x060001AC RID: 428 RVA: 0x00009030 File Offset: 0x00007230
	    private void Stelem_i4_(VariantBase dummy) // \u000E\u2001\u2000
        {
		    var obj = PopVariant().GetValueAbstract();
		    var idx = PopLong();
		    var array = (Array)PopVariant().GetValueAbstract();
		    var elementType = array.GetType().GetElementType();
		    checked
		    {
			    if (elementType == typeof(int))
			    {
                    ((int[])array)[(int)(IntPtr)idx] = (int)VariantFactory.Convert(obj, typeof(int)).GetValueAbstract();
				    return;
			    }
			    if (elementType == typeof(uint))
			    {
                    ((uint[])array)[(int)(IntPtr)idx] = (uint)VariantFactory.Convert(obj, typeof(uint)).GetValueAbstract();
				    return;
			    }
			    if (elementType.IsEnum)
			    {
                    Stelem(elementType, obj, idx, array);
				    return;
			    }
                Stelem(typeof(int), obj, idx, array);
		    }
	    }

	    // Token: 0x060001AD RID: 429 RVA: 0x00009100 File Offset: 0x00007300
	    private void Stind_i1_(VariantBase dummy) // \u0005\u2000\u2000
        {
		    Stind();
	    }

	    // Token: 0x060001AF RID: 431 RVA: 0x00009114 File Offset: 0x00007314
	    private object ResolveNativeToken(int token) // \u0002
        {
		    var num = HiByte.Extract(token);
		    object result;
		    if (num > 67108864)
		    {
			    if (num <= 167772160)
			    {
				    if (num != 100663296)
				    {
					    if (num != 167772160)
					    {
					        throw new InvalidOperationException();
					    }
                        try
					    {
						    result = _module.ModuleHandle.ResolveFieldHandle(token);
						    return result;
					    }
					    catch
					    {
						    try
						    {
							    result = _module.ModuleHandle.ResolveMethodHandle(token);
						    }
						    catch
						    {
							    throw new InvalidOperationException();
						    }
						    return result;
					    }
				    }
			    }
			    else
			    {
				    if (num == 452984832)
				    {
				        result = _module.ModuleHandle.ResolveTypeHandle(token);
				        return result;
				    }
                    if (num != 721420288)
				    {
				        throw new InvalidOperationException();
				    }
                }
			    result = _module.ModuleHandle.ResolveMethodHandle(token);
			    return result;
		    }
		    if (num != 16777216 && num != 33554432)
		    {
			    if (num != 67108864)
			    {
			        throw new InvalidOperationException();
			    }
                result = _module.ModuleHandle.ResolveFieldHandle(token);
			    return result;
		    }
		    result = _module.ModuleHandle.ResolveTypeHandle(token);
		    return result;
	    }

	    // Token: 0x060001B0 RID: 432 RVA: 0x0000923C File Offset: 0x0000743C
	    private void Ldloc_2_(VariantBase dummy) // \u0008\u2008
        {
		    PushVariant(_localVariables[2].Clone());
	    }

	    // Token: 0x060001B1 RID: 433 RVA: 0x00009258 File Offset: 0x00007458
	    private void Constrained_(VariantBase vTypeId) // \u0002\u2000\u2000
	    {
		    _currentClass = GetTypeById(((IntVariant)vTypeId).GetValue());
	    }

	    // Token: 0x060001B2 RID: 434 RVA: 0x00009280 File Offset: 0x00007480
	    private void Ldftn_(VariantBase vMethodId) // \U0003\U2008
        {
            var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
		    var push = new MethodVariant();
		    push.SetValue(methodBase);
		    PushVariant(push);
	    }

	    // Token: 0x060001B4 RID: 436 RVA: 0x000092C8 File Offset: 0x000074C8
	    private void Ldnull_(VariantBase dummy) // \u0005\u2002\u2001
        {
		    PushVariant(new ObjectVariant());
	    }

	    private void Conv_ovf_u8_un_(VariantBase dummy)
        {
            Conv_u8(true, false);
	    }

	    // Token: 0x060001B8 RID: 440 RVA: 0x000093F0 File Offset: 0x000075F0
	    private void Stind_i2_(VariantBase dummy) // \u0003\u2000\u2000
        {
		    Stind();
	    }

	    private void Conv_ovf_u2_un_(VariantBase dummy)
        {
            Conv_u2(true, false);
	    }

        private void Conv_u2(bool ovf, bool signed)
        {
            var pop = PopVariant();
            ushort val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    if (ovf)
                    {
                        var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                        if (signed)
                            val = Convert.ToUInt16(v);
                        else
                            val = Convert.ToUInt16((ulong)Convert.ToInt64(v));
                        break;
                    }
                    val = (ushort)VariantBase.SignedLongFromEnum((EnumVariant)pop);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    if (ovf && !signed)
                    {
                        val = Convert.ToUInt16((uint)((IntVariant)pop).GetValue());
                        break;
                    }
                    val = ovf ? Convert.ToUInt16(((IntVariant)pop).GetValue()) : (ushort)((IntVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc21Double:
                    if (ovf)
                    {
                        val = checked((ushort) ((DoubleVariant) pop).GetValue());
                        break;
                    }
                    val = (ushort)((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (ovf)
                    {
                        val = checked((ushort)((FloatVariant)pop).GetValue());
                        break;
                    }
                    val = (ushort)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    if (ovf)
                    {
                        if (signed)
                            val = checked((ushort)((LongVariant)pop).GetValue());
                        else
                            val = Convert.ToUInt16((ulong)((LongVariant)pop).GetValue());
                        break;
                    }
                    val = (ushort)((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(ushort), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U2 : OpCodes.Conv_U2) : OpCodes.Conv_Ovf_U2_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (ushort)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new UshortVariant();
            push.SetValue(val);
            PushVariant(push);
        }

        // Token: 0x060001AE RID: 430 RVA: 0x00009108 File Offset: 0x00007308
        private void Conv_ovf_u2_(VariantBase dummy) // \u0008\u2005\u2000
        {
            Conv_u2(true, true);
        }

        // Token: 0x06000292 RID: 658 RVA: 0x0001238C File Offset: 0x0001058C
        private void Conv_u2_(VariantBase dummy) // \u000F\u2002\u2000
        {
            Conv_u2(false, true);
        }

        private void Conv_u1(bool ovf, bool signed)
        {
            var pop = PopVariant();
            byte val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    if (ovf)
                    {
                        var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                        val = signed ? Convert.ToByte(v) : Convert.ToByte((ulong)Convert.ToInt64(v));
                        break;
                    }
                    val = (byte)VariantBase.SignedLongFromEnum((EnumVariant)pop);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    if (ovf && !signed)
                    {
                        val = Convert.ToByte((uint)((IntVariant)pop).GetValue());
                        break;
                    }
                    val = ovf ? Convert.ToByte(((IntVariant)pop).GetValue()) : (byte)((IntVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc21Double:
                    if (ovf)
                    {
                        val = signed ? checked((byte)((DoubleVariant)pop).GetValue()) : Convert.ToByte(((DoubleVariant)pop).GetValue());
                        break;
                    }
                    val = (byte)((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (ovf)
                    {
                        val = checked((byte)((FloatVariant)pop).GetValue());
                        break;
                    }
                    val = (byte)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    if (ovf)
                    {
                        val = checked((byte)((LongVariant)pop).GetValue());
                        break;
                    }
                    val = (byte)((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(byte), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U1 : OpCodes.Conv_U1) : OpCodes.Conv_Ovf_U1_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (byte)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new ByteVariant();
            push.SetValue(val);
            PushVariant(push);
        }

        // Token: 0x06000182 RID: 386 RVA: 0x00007FB4 File Offset: 0x000061B4
        private void Conv_ovf_i1_(VariantBase dummy) // \u0008\u2004
        {
            Conv_i1(true, true);
        }

        // Token: 0x06000188 RID: 392 RVA: 0x00008238 File Offset: 0x00006438
        private void Conv_u4_(VariantBase dummy) // \u0008\u2003\u2001
        {
            Conv_u4(false, true);
        }

        // Token: 0x0600018A RID: 394 RVA: 0x00008270 File Offset: 0x00006470
        private void Conv_ovf_i_(VariantBase dummy) // \u0008\u2003\u2000
        {
            Conv_i(true, true);
        }

        // Token: 0x060001CF RID: 463 RVA: 0x0000A1CC File Offset: 0x000083CC
        private void Conv_i_(VariantBase dummy) // \u0008\u2005
        {
            Conv_i(false, true);
        }

        // Token: 0x060001FF RID: 511 RVA: 0x0000BFC8 File Offset: 0x0000A1C8
        private void Conv_u4(bool ovf, bool signed) // \u0005
        {
            var pop = PopVariant();
            uint val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    if (ovf)
                    {
                        var v = VariantBase.SignedVariantFromEnum((EnumVariant) pop).GetValueAbstract();
                        if (signed || Marshal.SizeOf(v) < 8)
                            val = signed ? Convert.ToUInt32(v) : (uint)Convert.ToInt32(v);
                        else
                            val = Convert.ToUInt32(Convert.ToUInt64(v));
                        break;
                    }
                    val = (uint)VariantBase.SignedLongFromEnum((EnumVariant)pop);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    if (ovf && signed)
                    {
                        val = checked((uint)((IntVariant)pop).GetValue());
                        break;
                    }
                    val = (uint)((IntVariant)pop).GetValue(); // err fixed and unit tested by ursoft (was ushort)
                    break;
                case VariantBase.Vtc.Tc21Double:
                    if (ovf)
                    {
                        val = checked((uint)((DoubleVariant)pop).GetValue());
                        break;
                    }
                    val = (uint)((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (ovf)
                    {
                        val = checked((uint)((FloatVariant)pop).GetValue());
                        break;
                    }
                    val = (uint)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    if (ovf)
                    {
                        val = checked((uint)((LongVariant)pop).GetValue());
                        break;
                    }
                    val = (uint)((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(UInt32), new []{ typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U4 : OpCodes.Conv_U4) : OpCodes.Conv_Ovf_U4_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (uint) dyn.Invoke(null, new[] {pop.GetValueAbstract()});
                    break;
            }
            var push = new IntVariant();
            push.SetValue((int)val);
            PushVariant(push);
        }
        private void Conv_i4(bool ovf, bool signed)
        {
            var pop = PopVariant();
            int val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    if (ovf)
                    {
                        var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                        if (signed)
                            val = Convert.ToInt32(v);
                        else
                            val = Convert.ToInt32((ulong)Convert.ToInt64(v));
                        break;
                    }
                    val = (int)VariantBase.SignedLongFromEnum((EnumVariant)pop);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    if (ovf && !signed)
                    {
                        val = Convert.ToInt32((uint)((IntVariant)pop).GetValue());
                        break;
                    }
                    val = ((IntVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc21Double:
                    if (ovf)
                    {
                        val = checked((int)((DoubleVariant)pop).GetValue());
                        break;
                    }
                    val = (int)((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (ovf)
                    {
                        val = checked((int)((FloatVariant)pop).GetValue());
                        break;
                    }
                    val = (int)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    if (ovf)
                    {
                        if(signed)
                            val = checked((int)((LongVariant)pop).GetValue());
                        else
                            val = Convert.ToInt32((ulong)((LongVariant)pop).GetValue());
                        break;
                    }
                    val = (int)((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(Int32), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I4 : OpCodes.Conv_I4) : OpCodes.Conv_Ovf_I4_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (int)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new IntVariant();
            push.SetValue(val);
            PushVariant(push);
        }

        // Token: 0x06000294 RID: 660 RVA: 0x00012414 File Offset: 0x00010614
        private void Conv_ovf_u4_(VariantBase dummy) // \u000F\u200A
        {
            Conv_u4(true, true);
        }

        // Token: 0x06000200 RID: 512 RVA: 0x0000C0B0 File Offset: 0x0000A2B0
        private void Conv_ovf_u1_(VariantBase dummy) // \u0008\u2007\u2000
        {
            Conv_u1(true, true);
        }

        private void Conv_ovf_i2_un_(VariantBase dummy)
        {
            Conv_i2(true, false);
        }

        private void Conv_i2(bool ovf, bool signed)
        {
            var pop = PopVariant();
            short val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    if (ovf)
                    {
                        var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                        if (signed)
                            val = Convert.ToInt16(v);
                        else
                            val = Convert.ToInt16((ulong)Convert.ToInt64(v));
                        break;
                    }
                    val = (short)VariantBase.SignedLongFromEnum((EnumVariant)pop);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    if (ovf && !signed)
                    {
                        val = Convert.ToInt16((uint)((IntVariant)pop).GetValue());
                        break;
                    }
                    val = ovf ? Convert.ToInt16(((IntVariant)pop).GetValue()) : (short)((IntVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc21Double:
                    if (ovf)
                    {
                        val = signed ? checked((short)((DoubleVariant)pop).GetValue()) :
                            (IntPtr.Size == 4 ? Convert.ToInt16(Convert.ToUInt16((long)((DoubleVariant)pop).GetValue())) :
                                               Convert.ToInt16((long)((DoubleVariant)pop).GetValue()));
                        break;
                    }
                    val = (short)((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (ovf)
                    {
                        val = signed ? checked((short)((FloatVariant)pop).GetValue()) :
                            (IntPtr.Size == 4 ? Convert.ToInt16(Convert.ToUInt16((long)((FloatVariant)pop).GetValue())) :
                                               Convert.ToInt16((long)((FloatVariant)pop).GetValue()));
                        break;
                    }
                    val = (short)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    if (ovf)
                    {
                        if (signed)
                            val = checked((short)((LongVariant)pop).GetValue());
                        else
                            val = Convert.ToInt16((ulong)((LongVariant)pop).GetValue());
                        break;
                    }
                    val = (short)((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(short), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I2 : OpCodes.Conv_I2) : OpCodes.Conv_Ovf_I2_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (short)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new ShortVariant();
            push.SetValue(val);
            PushVariant(push);
        }

        // Token: 0x060001FE RID: 510 RVA: 0x0000BFBC File Offset: 0x0000A1BC
        private void Conv_i2_(VariantBase dummy) // \u0006\u2001\u2000
        {
            Conv_i2(false, true);
        }

        // Token: 0x060002A8 RID: 680 RVA: 0x00012D2C File Offset: 0x00010F2C
        private void Conv_ovf_i4_(VariantBase dummy) // \u000F\u2000\u2000
        {
            Conv_i4(true, true);
        }

        private void Conv_i8(bool ovf, bool signed)
        {
            var pop = PopVariant();
            long val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                    if (!signed && ovf && Marshal.SizeOf(v) > 4)
                        val = checked((long)(ulong)Convert.ToInt64(v));
                    else
                        val = (signed || Marshal.SizeOf(v) > 4) ? Convert.ToInt64(v) :
                          (uint)(ulong)Convert.ToInt64(v);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv = ((IntVariant)pop).GetValue();
                    if (signed)
                        val = iv;
                    else
                        val = (long)(uint)iv;
                    break;
                case VariantBase.Vtc.Tc21Double:
                    if (ovf)
                    {
                        val = checked((long)((DoubleVariant)pop).GetValue());
                        break;
                    }
                    val = (long)((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (ovf)
                    {
                        val = checked((long)((FloatVariant)pop).GetValue());
                        break;
                    }
                    val = (long)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    if (ovf)
                    {
                        if (signed)
                            val = ((LongVariant)pop).GetValue();
                        else
                            val = Convert.ToInt64((ulong)((LongVariant)pop).GetValue());
                        break;
                    }
                    val = ((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(long), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I8 : OpCodes.Conv_I8) : OpCodes.Conv_Ovf_I8_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (long)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new LongVariant();
            push.SetValue(val);
            PushVariant(push);
        }

        // Token: 0x06000219 RID: 537 RVA: 0x0000C824 File Offset: 0x0000AA24
        private void Conv_ovf_i8_(VariantBase dummy) // \u0008\u2002\u2000
        {
            Conv_i8(true, true);
        }

        private void Conv_i1(bool ovf, bool signed)
        {
            var pop = PopVariant();
            sbyte val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    if (ovf)
                    {
                        var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                        val = signed ? Convert.ToSByte(v) : Convert.ToSByte((ulong)Convert.ToInt64(v));
                        break;
                    }
                    val = (sbyte)VariantBase.SignedLongFromEnum((EnumVariant)pop);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    if (ovf && !signed)
                    {
                        val = Convert.ToSByte((uint)((IntVariant)pop).GetValue());
                        break;
                    }
                    val = ovf ? Convert.ToSByte(((IntVariant)pop).GetValue()) : (sbyte)((IntVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc21Double:
                    if (ovf)
                    {
                        val = signed ? checked((sbyte)((DoubleVariant)pop).GetValue()) : 
                            (IntPtr.Size == 4 ? Convert.ToSByte(Convert.ToByte(((DoubleVariant)pop).GetValue())) :
                                               Convert.ToSByte((long)((DoubleVariant)pop).GetValue()));
                        break;
                    }
                    val = (sbyte)((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (ovf)
                    {
                        val = signed ? checked((sbyte)((FloatVariant)pop).GetValue()) :
                            (IntPtr.Size == 4 ? Convert.ToSByte(Convert.ToByte(((FloatVariant)pop).GetValue())) :
                                               Convert.ToSByte((long)((FloatVariant)pop).GetValue()));
                        break;
                    }
                    val = (sbyte)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    if (ovf)
                    {
                        if (signed)
                            val = checked((sbyte)((LongVariant)pop).GetValue());
                        else
                            val = Convert.ToSByte((ulong)((LongVariant)pop).GetValue());
                        break;
                    }
                    val = (sbyte)((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(SByte), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I1 : OpCodes.Conv_I1) : OpCodes.Conv_Ovf_I1_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (sbyte)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new SbyteVariant();
            push.SetValue(val);
            PushVariant(push);
        }

        // Token: 0x060002A6 RID: 678 RVA: 0x00012CD0 File Offset: 0x00010ED0
        private void Conv_i1_(VariantBase dummy) // \u000E\u2006
        {
            Conv_i1(false, true);
        }

        // Token: 0x06000285 RID: 645 RVA: 0x00011EF0 File Offset: 0x000100F0
        private void Conv_ovf_i2_(VariantBase dummy) // \u0002\u2000\u2001
        {
            Conv_i2(true, true);
        }

        // Token: 0x0600018D RID: 397 RVA: 0x000083F8 File Offset: 0x000065F8
        private void Conv_u_(VariantBase dummy) // \u000F\u2003\u2001
        {
            Conv_u(false, true);
        }

        // Token: 0x060001EF RID: 495 RVA: 0x0000B658 File Offset: 0x00009858
        private void Conv_ovf_u_(VariantBase dummy) // \u0002\u2000
        {
            Conv_u(true, true);
        }

        // Token: 0x06000215 RID: 533 RVA: 0x0000C784 File Offset: 0x0000A984
        private void Conv_u1_(VariantBase dummy) // \u0008\u2002
        {
            Conv_u1(false, true);
        }

        // Token: 0x06000211 RID: 529 RVA: 0x0000C690 File Offset: 0x0000A890
        private void Conv_ovf_i_un_(VariantBase dummy) // \u000F
        {
            Conv_i(true, false);
        }

        // Token: 0x06000229 RID: 553 RVA: 0x0000F56C File Offset: 0x0000D76C
        private void Conv_i4_(VariantBase dummy) // \u0003\u2005\u2000
        {
            Conv_i4(false, true);
        }

        private void Conv_ovf_i8_un_(VariantBase dummy)
        {
            Conv_i8(true, false);
        }

        // Token: 0x06000253 RID: 595 RVA: 0x00010790 File Offset: 0x0000E990
        private void Conv_ovf_u4_un_(VariantBase dummy) // \u0002\u2009\u2000
        {
            Conv_u4(true, false);
        }

        // Token: 0x06000284 RID: 644 RVA: 0x00011EE4 File Offset: 0x000100E4
        private void Conv_i8_(VariantBase dummy) // \u0003\u2006\u2000
        {
            Conv_i8(false, true);
        }

        // Token: 0x0600028A RID: 650 RVA: 0x000121B8 File Offset: 0x000103B8
        private void Conv_ovf_u_un_(VariantBase dummy) // \u000F\u200B
        {
            Conv_u(true, false);
        }

        private unsafe void Conv_i(bool ovf, bool signed)
        {
            var pop = PopVariant();
            var push = new IntPtrVariant();
            long val;
            var tc = pop.GetTypeCode();
            if (tc == VariantBase.Vtc.Tc21Double || tc == VariantBase.Vtc.Tc8Float)
                signed = true;
            long maxVal = long.MaxValue, minVal = signed ? long.MinValue : 0;
            if (IntPtr.Size == 4)
            {
                maxVal = signed ? Int32.MaxValue : UInt32.MaxValue;
                minVal = signed ? Int32.MinValue : 0;
            }
            switch (tc)
            {
                case VariantBase.Vtc.Tc5Enum:
                    var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                    if (IntPtr.Size == 4)
                    {
                        if (ovf) val = Convert.ToInt32(v);
                        else val = (int)Convert.ToInt64(v);
                    }
                    else
                    {
                        val = (signed || Marshal.SizeOf(v) > 4 || !ovf) ? Convert.ToInt64(v) : 
                            (uint)(ulong)Convert.ToInt64(v);
                    }
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv = ((IntVariant) pop).GetValue();
                    if (IntPtr.Size == 4 || signed)
                        val = iv;
                    else
                        val = (long)(uint)iv;
                    break;
                case VariantBase.Vtc.Tc21Double:
                    {
                        double dv = ((DoubleVariant)pop).GetValue();
                        if (dv <= maxVal && dv >= minVal)
                            val = (long)dv;
                        else
                        {
                            if (ovf) throw new OverflowException();
                            val = (IntPtr.Size == 4) ? Int32.MinValue : Int64.MinValue; // не мусор ли?
                        }
                    }
                    break;
                case VariantBase.Vtc.Tc8Float:
                    {
                        double dv = (double) ((FloatVariant) pop).GetValue();
                        if (dv <= maxVal && dv >= minVal)
                            val = (long) dv;
                        else
                        {
                            if (ovf) throw new OverflowException();
                            val = (IntPtr.Size == 4) ? Int32.MinValue : Int64.MinValue; // не мусор ли?
                        }
                    }
                    break;
                case VariantBase.Vtc.Tc24Long:
                    val = ((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I : OpCodes.Conv_I) : OpCodes.Conv_Ovf_I_Un);
                    gen.Emit(OpCodes.Ret);
                    push.SetValue(((IntPtr)dyn.Invoke(null, new[] { pop.GetValueAbstract() })));
                    PushVariant(push);
                    return;
            }
            if ((ovf == false) || (val <= maxVal && val >= minVal))
            {
                push.SetValue(new IntPtr((void*)val));
                PushVariant(push);
            } else throw new OverflowException();
        }
        private unsafe void Conv_u(bool ovf, bool signed)
        {
            var pop = PopVariant();
            var push = new UIntPtrVariant();
            ulong val, maxVal = (IntPtr.Size == 4) ? UInt32.MaxValue : UInt64.MaxValue;
            var tc = pop.GetTypeCode();
            switch (tc)
            {
                case VariantBase.Vtc.Tc5Enum:
                    var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                    if (IntPtr.Size == 4)
                    {
                        if (ovf) val = signed ?
                                Convert.ToUInt64(v) :
                                (Marshal.SizeOf(v) > 4) ? (ulong)Convert.ToInt64(v) : (uint)Convert.ToInt32(v);
                        else val = (uint)Convert.ToInt64(v);
                    }
                    else
                    {
                        val = (Marshal.SizeOf(v) > 4) ? 
                            ((ovf && signed) ? Convert.ToUInt64(Convert.ToInt64(v)) : (ulong)Convert.ToInt64(v)) :
                            ((ovf && signed) ? Convert.ToUInt32(Convert.ToInt32(v)) : (uint)Convert.ToInt32(v));
                    }
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv = ((IntVariant)pop).GetValue();
                    if (ovf && signed && iv < 0) throw new OverflowException();
                    val = (uint)iv;
                    break;
                case VariantBase.Vtc.Tc21Double:
                    {
                        double dv = ((DoubleVariant)pop).GetValue();
                        if (ovf && signed && dv < 0) throw new OverflowException();
                        if (dv <= maxVal && (signed || dv >= 0))
                            val = (ulong)dv;
                        else
                        {
                            if (ovf) throw new OverflowException();
                            val = 0; // мусор, индульгируем
                        }
                    }
                    break;
                case VariantBase.Vtc.Tc8Float:
                    {
                        double dv = (double)((FloatVariant)pop).GetValue();
                        if (ovf && signed && dv < 0) throw new OverflowException();
                        if (dv <= maxVal && (signed || dv >= 0))
                            val = (ulong)dv;
                        else
                        {
                            if (ovf) throw new OverflowException();
                            val = 0; // мусор, индульгируем
                        }
                    }
                    break;
                case VariantBase.Vtc.Tc24Long:
                    long lv = ((LongVariant)pop).GetValue();
                    if (ovf && signed && lv < 0) throw new OverflowException();
                    val = (ulong) lv;
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(UIntPtr), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U : OpCodes.Conv_U) : OpCodes.Conv_Ovf_U_Un);
                    gen.Emit(OpCodes.Ret);
                    push.SetValue(((UIntPtr)dyn.Invoke(null, new[] { pop.GetValueAbstract() })));
                    PushVariant(push);
                    return;
            }
            if ((ovf == false) || (val <= maxVal))
            {
                push.SetValue(new UIntPtr((void*)val));
                PushVariant(push);
            }
            else throw new OverflowException();
        }

        private void Conv_u8(bool ovf, bool signed)
        {
            var pop = PopVariant();
            ulong val;
            switch (pop.GetTypeCode())
            {
                case VariantBase.Vtc.Tc5Enum:
                    var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
                    if(ovf && signed)
                        val = Convert.ToUInt64(v);
                    else
                        if (Marshal.SizeOf(v) > 4)
                            val = (ulong)Convert.ToInt64(v);
                        else
                            val = (uint)(ulong)Convert.ToInt64(v);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv = ((IntVariant)pop).GetValue();
                    val = ovf ? (signed ? checked((uint)iv) : (uint)iv) : (uint)iv;
                    break;
                case VariantBase.Vtc.Tc21Double:
                    if (ovf)
                    {
                        val = checked((ulong)((DoubleVariant)pop).GetValue());
                        break;
                    }
                    val = (ulong)((DoubleVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (ovf)
                    {
                        val = checked((ulong)((FloatVariant)pop).GetValue());
                        break;
                    }
                    val = (ulong)((FloatVariant)pop).GetValue();
                    break;
                case VariantBase.Vtc.Tc24Long:
                    if (ovf && signed)
                        val = Convert.ToUInt64(((LongVariant)pop).GetValue());
                    else
                        val = (ulong)((LongVariant)pop).GetValue();
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(ulong), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U8 : OpCodes.Conv_U8) : OpCodes.Conv_Ovf_U8_Un);
                    gen.Emit(OpCodes.Ret);
                    val = (ulong)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
                    break;
            }
            var push = new UlongVariant();
            push.SetValue(val);
            PushVariant(push);
        }

        // Token: 0x06000204 RID: 516 RVA: 0x0000C19C File Offset: 0x0000A39C
        private void Conv_u8_(VariantBase dummy) // \u0003\u2005
        {
            Conv_u8(false, true);
        }

        // Token: 0x0600020E RID: 526 RVA: 0x0000C58C File Offset: 0x0000A78C
        private void Conv_ovf_u8_(VariantBase dummy) // \u0008\u2008\u2000
        {
            Conv_u8(true, true);
        }

        // Token: 0x06000208 RID: 520 RVA: 0x0000C43C File Offset: 0x0000A63C
        private void Conv_ovf_i1_un_(VariantBase dummy) // \u0008
        {
            Conv_i1(true, false);
        }

        private void Conv_ovf_u1_un_(VariantBase dummy)
        {
            Conv_u1(true, false);
        }

        // Token: 0x060001BB RID: 443 RVA: 0x000094E0 File Offset: 0x000076E0
        private void _u0006u2003u2001(VariantBase dummy) // \u0006\u2003\u2001
        {
	    }

	    // Token: 0x060001BC RID: 444 RVA: 0x000094E4 File Offset: 0x000076E4
	    private VariantBase[] CreateLocalVariables() // u0002
	    {
		    var array = _methodHeader.LocalVarTypes;
		    var num = array.Length;
		    var ret = new VariantBase[num];
		    for (var i = 0; i < num; i++)
		    {
			    ret[i] = VariantFactory.Convert(null, GetTypeById(array[i].TypeId));
		    }
		    return ret;
	    }

	    // Token: 0x060001C0 RID: 448 RVA: 0x0000958C File Offset: 0x0000778C
	    private MethodBase FindGenericMethod(VmMethodTokenInfo what) // \u0002
        {
		    var type = GetTypeById(what.Class.MetadataToken);
		    var bindingAttr = BF(what.IsStatic());
		    var arg_32_0 = type.GetMember(what.Name, bindingAttr);
	        var array = arg_32_0;
	        var methodInfo = (from MethodInfo methodInfo2 in array
	            where methodInfo2.IsGenericMethodDefinition
	            let parameters = methodInfo2.GetParameters()
	            where
	                parameters.Length == what.Parameters.Length &&
	                methodInfo2.GetGenericArguments().Length == what.GenericArguments.Length &&
	                AreCompatible(methodInfo2.ReturnType, what.ReturnType)
	            where !parameters.Where((t1, j) => !AreCompatible(t1.ParameterType, what.Parameters[j])).Any()
	            select methodInfo2).FirstOrDefault();
	        if (methodInfo == null)
		    {
			    throw new Exception(string.Format(StringDecryptor.GetString(-1550347247) /* Cannot bind method: {0}.{1} */, type.Name, what.Name));
		    }
		    var array2 = new Type[what.GenericArguments.Length];
		    for (var k = 0; k < array2.Length; k++)
		    {
			    array2[k] = GetTypeById(what.GenericArguments[k].MetadataToken);
		    }
		    return methodInfo.MakeGenericMethod(array2);
	    }

	    // Token: 0x060001C2 RID: 450 RVA: 0x000097A0 File Offset: 0x000079A0
	    private bool InvokeFilter(MethodBase mb, object obj, ref object result, object[] args) // \u0002
        {
		    var declaringType = mb.DeclaringType;
		    if (declaringType == null)
		    {
			    return false;
		    }
		    if (SimpleTypeHelper.IsNullableGeneric(declaringType))
		    {
			    if (string.Equals(mb.Name, StringDecryptor.GetString(-1550345611) /* get_HasValue */, StringComparison.Ordinal))
			    {
				    result = obj != null;
			    }
			    else if (string.Equals(mb.Name, StringDecryptor.GetString(-1550345722) /* get_Value */, StringComparison.Ordinal))
			    {
				    if (obj == null)
				    {
					    //return ((bool?)null).Value;
                        throw new InvalidOperationException();
				    }
				    result = obj;
			    }
			    else if (mb.Name.Equals(StringDecryptor.GetString(-1550345706) /* GetValueOrDefault */, StringComparison.Ordinal))
			    {
				    if (obj == null)
				    {
					    /*u0005 =*/ Activator.CreateInstance(Nullable.GetUnderlyingType(mb.DeclaringType));
				    }
				    result = obj;
			    }
			    else
			    {
				    if (obj != null || mb.IsStatic)
				    {
					    return false;
				    }
				    result = null;
			    }
			    return true;
		    }
		    if (declaringType == SimpleTypeHelper.TypedReferenceType)
		    {
			    var name = mb.Name;
			    var i = args.Length;
			    if (i != 1)
			    {
				    if (i == 2)
				    {
					    if (name == StringDecryptor.GetString(-1550345495) /* SetTypedReference */)
					    {
						    TypedReference.SetTypedReference((TypedReference)args[0], args[1]);
						    return true;
					    }
				    }
			    }
			    else
			    {
				    if (name == StringDecryptor.GetString(-1550345682) /* GetTargetType */)
				    {
					    result = TypedReference.GetTargetType((TypedReference)args[0]);
					    return true;
				    }
				    if (name == StringDecryptor.GetString(-1550345534) /* TargetTypeToken */)
				    {
					    result = TypedReference.TargetTypeToken((TypedReference)args[0]);
					    return true;
				    }
				    if (name == StringDecryptor.GetString(-1550345512) /* ToObject */)
				    {
					    result = TypedReference.ToObject((TypedReference)args[0]);
					    return true;
				    }
			    }
		    }
		    else if (declaringType == AssemblyType)
		    {
			    if (_callees != null && mb.Name == StringDecryptor.GetString(-1550345599) /* GetCallingAssembly */)
			    {
			        var array = _callees;
			        foreach (var t in array)
			        {
			            var assembly = t as Assembly;
			            if (assembly != null)
			            {
			                result = assembly;
			                return true;
			            }
			        }
			    }
		    }
		    else if (declaringType == MethodBaseType)
		    {
			    if (mb.Name == StringDecryptor.GetString(-1550345576) /* GetCurrentMethod */)
			    {
				    if (_callees != null)
				    {
				        var array = _callees;
				        foreach (var t in array)
				        {
				            var methodBase = t as MethodBase;
				            if (methodBase != null)
				            {
				                result = methodBase;
				                return true;
				            }
				        }
				    }
				    result = MethodBase.GetCurrentMethod();
				    return true;
			    }
		    }
		    else if (declaringType.IsArray && declaringType.GetArrayRank() >= 2)
		    {
			    return RefToMdArrayItem(mb, obj, ref result, args);
		    }
		    return false;
	    }

	    // Token: 0x060001C3 RID: 451 RVA: 0x000099F8 File Offset: 0x00007BF8
	    private void Ldloca_s_(VariantBase vLocIdx) // \u0005\u2001\u2001
        {
            var push = new LocalsIdxHolderVariant();
		    push.SetValue(((ByteVariant)vLocIdx).GetValue());
		    PushVariant(push);
	    }

	    // Token: 0x060001C4 RID: 452 RVA: 0x00009A24 File Offset: 0x00007C24
	    private void Ldind_i_(VariantBase dummy) // \u000E\u2004\u2000
        {
		    Ldind(IntPtrType);
	    }

	    // Token: 0x060001C6 RID: 454 RVA: 0x00009D14 File Offset: 0x00007F14
	    private void Stloc_(VariantBase vidx) // \u0008\u2006
        {
		    var idx = (UshortVariant)vidx;
            PopToLocal(idx.GetValue());
	    }

	    // Token: 0x060001C7 RID: 455 RVA: 0x00009D34 File Offset: 0x00007F34
	    private void Stfld_(VariantBase vFieldId) // \u0005\u200B
        {
            var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
		    var val = PopVariant();
		    var objRef = PopVariant();
            var obj = objRef.IsAddr() ? FetchByAddr(objRef).GetValueAbstract() : objRef.GetValueAbstract();
		    if (obj == null)
		    {
			    throw new NullReferenceException();
		    }
            fieldInfo.SetValue(obj, VariantFactory.Convert(val.GetValueAbstract(), fieldInfo.FieldType).GetValueAbstract());
		    if (objRef.IsAddr() && /*obj != null && */ obj.GetType().IsValueType)
		    {
                AssignByReference(objRef, VariantFactory.Convert(obj, null));
		    }
	    }

	    // Token: 0x060001C8 RID: 456 RVA: 0x00009DD0 File Offset: 0x00007FD0
	    /*private void u000Fu2004(VariantBase dummy) // \u000F\u2004
        {
	    }*/

	    // Token: 0x060001CB RID: 459 RVA: 0x00009E7C File Offset: 0x0000807C
	    private void Ldloc_s_(VariantBase vidx) // \u0002
        {
		    var idx = (ByteVariant)vidx;
		    PushVariant(_localVariables[idx.GetValue()].Clone());
	    }

	    // Token: 0x060001D1 RID: 465 RVA: 0x0000A328 File Offset: 0x00008528
	    private void Stelem_ref_(VariantBase dummy) // \u0008\u200A
        {
		    Stelem(SimpleTypeHelper.ObjectType);
	    }

	    // Token: 0x060001D3 RID: 467 RVA: 0x0000A34C File Offset: 0x0000854C
	    private void Ldelem_u2_(VariantBase dummy) // \u000E\u2003\u2001
        {
		    Ldelem(typeof(ushort));
	    }

	    // Token: 0x060001D5 RID: 469 RVA: 0x0000A620 File Offset: 0x00008820
	    private void Stind_i4_(VariantBase dummy) // \u0006\u2003\u2000
        {
		    Stind();
	    }

	    // Token: 0x060001D6 RID: 470 RVA: 0x0000A628 File Offset: 0x00008828
	    private void Stind_i8_(VariantBase dummy) // \u0003\u2002\u2000
        {
		    Stind();
	    }

	    // Token: 0x060001DC RID: 476 RVA: 0x0000AAD8 File Offset: 0x00008CD8
	    private void Stelem_i8_(VariantBase dummy) // \u0002\u200B\u2000
        {
		    var obj = PopVariant().GetValueAbstract();
		    var idx = PopLong();
		    var array = (Array)PopVariant().GetValueAbstract();
		    var elementType = array.GetType().GetElementType();
		    checked
		    {
			    if (elementType == typeof(long))
			    {
                    ((long[])array)[(int)(IntPtr)idx] = (long)VariantFactory.Convert(obj, typeof(long)).GetValueAbstract();
				    return;
			    }
			    if (elementType == typeof(ulong))
			    {
                    ((ulong[])array)[(int)(IntPtr)idx] = (ulong)VariantFactory.Convert(obj, typeof(ulong)).GetValueAbstract();
				    return;
			    }
			    if (elementType.IsEnum)
			    {
                    Stelem(elementType, obj, idx, array);
				    return;
			    }
                Stelem(typeof(long), obj, idx, array);
		    }
	    }

	    // Token: 0x060001DD RID: 477 RVA: 0x0000ABA8 File Offset: 0x00008DA8
	    private void Stelem_i_(VariantBase dummy) // \u000F\u2006\u2000
        {
		    Stelem(IntPtrType);
	    }

	    // Token: 0x060001DE RID: 478 RVA: 0x0000ABB8 File Offset: 0x00008DB8
	    private void Ldelem_i8_(VariantBase dummy) // \u0006\u2000
        {
		    Ldelem(typeof(long));
	    }

	    // Token: 0x060001E0 RID: 480 RVA: 0x0000ABD0 File Offset: 0x00008DD0
	    private void Ldc_i4_(VariantBase val) // \u0006\u2000\u2000
	    {
		    PushVariant(val);
	    }

	    // Token: 0x060001E2 RID: 482 RVA: 0x0000AC08 File Offset: 0x00008E08
	    private void Ldarg_1_(VariantBase dummy) // \u0002\u2003\u2001
	    {
		    PushVariant(_variantOutputArgs[1].Clone());
	    }

	    // Token: 0x060001E3 RID: 483 RVA: 0x0000AC24 File Offset: 0x00008E24
	    private void Ret_(VariantBase dummy) // \u000E\u2005\u2000
        {
		    Ret();
	    }

	    // Token: 0x060001E8 RID: 488 RVA: 0x0000B10C File Offset: 0x0000930C
	    private void Stelem(Type arrType, object val, long idx, Array array) // \u0002
        {
		    array.SetValue(VariantFactory.Convert(val, arrType).GetValueAbstract(), idx);
	    }

	    // Token: 0x060001E9 RID: 489 RVA: 0x0000B130 File Offset: 0x00009330
	    [DebuggerNonUserCode]
	    private MethodBase FindMethodById(int methodId, UniversalTokenInfo methodToken) // \u0002
        {
            MethodBase result = null;
		    lock (AllMetadataById)
		    {
			    //var flag = true;
			    object obj;
			    if (/*flag &&*/ AllMetadataById.TryGetValue(methodId, out obj))
			    {
				    result = (MethodBase)obj;
			    }
			    else if (methodToken.IsVm == 0)
			    {
				    var methodBase = _module.ResolveMethod(methodToken.MetadataToken);
				    //if (flag)
				    {
					    AllMetadataById.Add(methodId, methodBase);
				    }
				    result = methodBase;
			    }
			    else
			    {
				    var mti = (VmMethodTokenInfo)methodToken.VmToken;
				    if (mti.IsGeneric())
				    {
					    result = FindGenericMethod(mti);
				    }
				    else
				    {
					    var clsType = GetTypeById(mti.Class.MetadataToken);
					    var retType = GetTypeById(mti.ReturnType.MetadataToken);
					    var paramArray = new Type[mti.Parameters.Length];
					    for (var i = 0; i < paramArray.Length; i++)
					    {
						    paramArray[i] = GetTypeById(mti.Parameters[i].MetadataToken);
					    }
					    /*if (type.IsGenericType)
					    {
						    flag = false;
					    }*/
					    if (mti.Name == StringDecryptor.GetString(-1550347259) /* .ctor */)
					    {
						    var constructor = clsType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, paramArray, null);
						    if (constructor == null)
						    {
							    throw new Exception();
						    }
						    if (!clsType.IsGenericType)
						    {
							    AllMetadataById.Add(methodId, constructor);
						    }
						    result = constructor;
					    }
					    else
					    {
						    var bindingAttr = BF(mti.IsStatic());
						    try
						    {
							    result = clsType.GetMethod(mti.Name, bindingAttr, null, CallingConventions.Any, paramArray, null);
						    }
						    catch (AmbiguousMatchException)
						    {
						        var methods = clsType.GetMethods(bindingAttr);
						        foreach (var methodInfo in methods)
						        {
						            if (methodInfo.Name == mti.Name && methodInfo.ReturnType == retType)
						            {
						                var parameters = methodInfo.GetParameters();
						                if (parameters.Length == paramArray.Length)
						                {
                                            if (!(bool)paramArray.Where((t, k) => parameters[k].ParameterType != t).Any())
						                    {
						                        result = methodInfo;
						                        break;
						                    }
						                }
						            }
						        }
						    }
						    if (result == null)
						    {
							    throw new Exception(string.Format(StringDecryptor.GetString(-1550347247) /* Cannot bind method: {0}.{1} */, clsType.Name, mti.Name));
						    }
						    if (!clsType.IsGenericType)
						    {
							    AllMetadataById.Add(methodId, result);
						    }
					    }
				    }
			    }
		    }
		    return result;
	    }

	    // Token: 0x060001EA RID: 490 RVA: 0x0000B3B8 File Offset: 0x000095B8
	    private void Stloc_s_(VariantBase vidx) // \u000E\u2004
	    {
		    var idx = (ByteVariant)vidx;
            PopToLocal(idx.GetValue());
	    }

	    // Token: 0x060001EB RID: 491 RVA: 0x0000B3D8 File Offset: 0x000095D8
	    private void LockIfInterlocked(ref BoolHolder wasLocked, MethodBase mb, bool dummy) // \u0002
        {
		    if (mb.DeclaringType == typeof(Interlocked) && mb.IsStatic)
		    {
			    var name = mb.Name;
			    if (name == StringDecryptor.GetString(-1550347213) /* Add */ || name == StringDecryptor.GetString(-1550347203) /* CompareExchange */ || name == StringDecryptor.GetString(-1550347053) /* Decrement */ || name == StringDecryptor.GetString(-1550347037) /* Exchange */ || name == StringDecryptor.GetString(-1550347024) /* Increment */ || name == StringDecryptor.GetString(-1550347136) /* Read*/)
			    {
			        Monitor.Enter(InterlockedLock);
			        wasLocked.Val = true;
			    }
            }
	    }

	    // Token: 0x060001EC RID: 492 RVA: 0x0000B4A0 File Offset: 0x000096A0
	    private void Box_(VariantBase vTypeId) // \u0003\u2009\u2000
	    {
            var type = GetTypeById(((IntVariant)vTypeId).GetValue());
		    var push = VariantFactory.Convert(PopVariant().GetValueAbstract(), type);
		    push.SetVariantType(type);
		    PushVariant(push);
	    }

	    // Token: 0x060001F1 RID: 497 RVA: 0x0000B690 File Offset: 0x00009890
	    private void Sizeof_(VariantBase vTypeId) // \u000E\u2001\u2001
	    {
		    var t = GetTypeById(((IntVariant)vTypeId).GetValue());
		    var iv = new IntVariant();
		    iv.SetValue(Marshal.SizeOf(t));
		    PushVariant(iv);
	    }

	    // Token: 0x060001F3 RID: 499 RVA: 0x0000B758 File Offset: 0x00009958
	    private void Ldelem_i_(VariantBase dummy) // \u000F\u2000
	    {
		    Ldelem(IntPtrType);
	    }

	    // Token: 0x060001F4 RID: 500 RVA: 0x0000B768 File Offset: 0x00009968
	    private void InternalInvoke() // \u0002
        {
		    try
		    {
			    LoopUntilRet();
		    }
		    catch (Exception ex)
		    {
			    OnException(ex, 0u);
			    LoopUntilRet();
		    }
	    }

	    // Token: 0x060001F5 RID: 501 RVA: 0x0000B7A0 File Offset: 0x000099A0
	    private MethodBase GenerateDynamicCall(MethodBase mb, bool mayVirtual) // \u0002
        {
		    MethodBase result;
		    lock (DynamicMethods)
		    {
			    DynamicMethod dynamicMethod;
			    if (DynamicMethods.TryGetValue(mb, out dynamicMethod))
			    {
				    result = dynamicMethod;
			    }
			    else
			    {
                    var methodInfo = mb as MethodInfo;
			        var returnType = methodInfo?.ReturnType ?? VoidType;
				    var parameters = mb.GetParameters();
				    Type[] array;
				    if (mb.IsStatic)
				    {
					    array = new Type[parameters.Length];
					    for (var i = 0; i < parameters.Length; i++)
					    {
						    array[i] = parameters[i].ParameterType;
					    }
				    }
				    else
				    {
					    array = new Type[parameters.Length + 1];
					    var type = mb.DeclaringType;
					    if (type.IsValueType)
					    {
						    type = type.MakeByRefType();
						    mayVirtual = false;
					    }
					    array[0] = type;
					    for (var j = 0; j < parameters.Length; j++)
					    {
						    array[j + 1] = parameters[j].ParameterType;
					    }
				    }
				    /*if (_alwaysFalse)
				    {
					    dynamicMethod = new DynamicMethod(string.Empty, returnType, array, true);
				    }
				    if (dynamicMethod == null)*/
				    {
					    dynamicMethod = new DynamicMethod(string.Empty, returnType, array, GetTypeById(_methodHeader.ClassId), true);
				    }
				    var iLGenerator = dynamicMethod.GetILGenerator();
				    for (var k = 0; k < array.Length; k++)
				    {
					    iLGenerator.Emit(OpCodes.Ldarg, k);
				    }
				    var constructorInfo = mb as ConstructorInfo;
				    if (constructorInfo != null)
				    {
					    iLGenerator.Emit(mayVirtual ? OpCodes.Callvirt : OpCodes.Call, constructorInfo);
				    }
				    else
				    {
					    iLGenerator.Emit(mayVirtual ? OpCodes.Callvirt : OpCodes.Call, (MethodInfo)mb);
				    }
				    iLGenerator.Emit(OpCodes.Ret);
				    DynamicMethods.Add(mb, dynamicMethod);
				    result = dynamicMethod;
			    }
		    }
		    return result;
	    }

	    // Token: 0x060001F7 RID: 503 RVA: 0x0000B9EC File Offset: 0x00009BEC
	    private void Ldelem_i4_(VariantBase dummy) // \u000E\u2007
	    {
		    Ldelem(typeof(int));
	    }

	    // Token: 0x060001FD RID: 509 RVA: 0x0000BD88 File Offset: 0x00009F88
	    private void Invoke(int pos, Type[] methodGenericArgs, Type[] classGenericArgs, bool mayVirtual) // \u0002
        {
		    _srcVirtualizedStreamReader.BaseStream.Seek(pos, SeekOrigin.Begin);
		    DoNothing(_srcVirtualizedStreamReader);
		    var u0006 = ReadMethodHeader(_srcVirtualizedStreamReader);
		    var num = u0006.ArgsTypeToOutput.Length;
		    var array = new object[num];
		    var array2 = new VariantBase[num];
		    if (_currentClass != null & mayVirtual)
		    {
			    var num2 = u0006.IsStatic() ? 0 : 1;
			    var array3 = new Type[num - num2];
			    for (var i = num - 1; i >= num2; i--)
			    {
				    array3[i] = GetTypeById(u0006.ArgsTypeToOutput[i].TypeId);
			    }
			    var method = _currentClass.GetMethod(u0006.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty, null, array3, null);
			    _currentClass = null;
			    if (method != null)
			    {
                    GenerateDynamicCall(method, true);
				    return;
			    }
		    }
		    for (var j = num - 1; j >= 0; j--)
		    {
			    var u000F = PopVariant();
			    array2[j] = u000F;
			    if (u000F.IsAddr())
			    {
				    u000F = FetchByAddr(u000F);
			    }
			    if (u000F.GetVariantType() != null)
			    {
				    u000F = VariantFactory.Convert(null, u000F.GetVariantType()).CopyFrom(u000F);
			    }
			    var u000F2 = VariantFactory.Convert(null, GetTypeById(u0006.ArgsTypeToOutput[j].TypeId)).CopyFrom(u000F);
			    array[j] = u000F2.GetValueAbstract();
			    if (j == 0 & mayVirtual && !u0006.IsStatic() && array[j] == null)
			    {
				    throw new NullReferenceException();
			    }
		    }
		    var executor = new VmExecutor(_instrCodesDb);
		    var callees = new object[]
		    {
			    _module.Assembly
		    };
		    object obj;
		    try
		    {
			    obj = executor.Invoke(_srcVirtualizedStream, pos, array, methodGenericArgs, classGenericArgs, callees);
		    }
		    finally
		    {
			    for (var k = 0; k < array2.Length; k++)
			    {
				    var u000F3 = array2[k];
				    if (u000F3.IsAddr())
				    {
					    var obj2 = array[k];
				        AssignByReference(u000F3, VariantFactory.Convert(obj2, null));
				    }
			    }
		    }
		    var type = executor.GetTypeById(executor._methodHeader.ReturnTypeId);
		    if (type != VoidType)
		    {
			    PushVariant(VariantFactory.Convert(obj, type));
		    }
	    }

	    // Token: 0x06000202 RID: 514 RVA: 0x0000C150 File Offset: 0x0000A350
	    public static object CreateValueTypeInstance(Type t) // \u0002
        {
		    if (t.IsValueType)
		    {
			    return Activator.CreateInstance(t);
		    }
		    return null;
	    }

	    // Token: 0x0600020B RID: 523 RVA: 0x0000C51C File Offset: 0x0000A71C
	    private void Ldc_r4_(VariantBase val) // \u0003\u200B\u2000
	    {
		    PushVariant(val);
	    }

	    // Token: 0x0600020D RID: 525 RVA: 0x0000C550 File Offset: 0x0000A750
	    private void Stelem(Type t) // \u0003
        {
		    var obj = PopVariant().GetValueAbstract();
		    var idx = PopLong();
		    var array = (Array)PopVariant().GetValueAbstract();
            Stelem(t, obj, idx, array);
	    }

	    // Token: 0x06000210 RID: 528 RVA: 0x0000C5C4 File Offset: 0x0000A7C4
	    private void Ldvirtftn_(VariantBase vMethodId) // \u0003\u200A
	    {
            var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
		    var declaringType = methodBase.DeclaringType;
		    var type = PopVariant().GetValueAbstract().GetType();
		    var parameters = methodBase.GetParameters();
		    var paramTypes = new Type[parameters.Length];
		    for (var i = 0; i < parameters.Length; i++)
		    {
			    paramTypes[i] = parameters[i].ParameterType;
		    }
		    while (type != null && type != declaringType)
		    {
			    var method = type.GetMethod(methodBase.Name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.ExactBinding, null, CallingConventions.Any, paramTypes, null);
			    if (method != null && method.GetBaseDefinition() == methodBase)
			    {
				    methodBase = method;
				    break;
			    }
			    type = type.BaseType;
		    }
		    var push = new MethodVariant();
		    push.SetValue(methodBase);
		    PushVariant(push);
	    }

	    // Token: 0x06000213 RID: 531 RVA: 0x0000C750 File Offset: 0x0000A950
	    private void Ldind_u4_(VariantBase dummy) // \u000E\u2002\u2001
	    {
		    Ldind(typeof(uint));
	    }

        // Token: 0x06000218 RID: 536 RVA: 0x0000C810 File Offset: 0x0000AA10
        private void Ldind_i2_(VariantBase dummy) // \u0003\u2002\u2001
	    {
		    Ldind(typeof(short));
	    }

	    // Token: 0x0600021A RID: 538 RVA: 0x0000C830 File Offset: 0x0000AA30
	    private void Ldind_u2_(VariantBase dummy) // \u000F\u2001\u2001
	    {
		    Ldind(typeof(ushort));
	    }

	    // Token: 0x0600021B RID: 539 RVA: 0x0000C844 File Offset: 0x0000AA44
	    private void Break_(VariantBase dummy) // \u0005\u2002
	    {
		    Debugger.Break();
	    }

	    // Token: 0x0600021D RID: 541 RVA: 0x0000C878 File Offset: 0x0000AA78
	    private void Ldc_i4_m1_(VariantBase dummy) // \u0002\u2005
	    {
		    var iv = new IntVariant();
		    iv.SetValue(-1);
		    PushVariant(iv);
	    }

	    // Token: 0x0600021E RID: 542 RVA: 0x0000C88C File Offset: 0x0000AA8C
	    private void ExecuteNextInstruction() // \u0002\u2000
        {
		    try
		    {
			    TryExecuteNextInstruction();
		    }
		    catch (Exception ex)
		    {
			    OnException(ex, 0u);
		    }
	    }
	    
        // Token: 0x06000220 RID: 544 RVA: 0x0000F07C File Offset: 0x0000D27C
	    private void OnException(object ex, uint pos) // \u0002
        {
		    _wasException = ex != null;
		    _exception = ex;
		    if (_wasException)
		    {
			    _ehStack.Clear();
		    }
		    if (!_wasException)
		    {
                _ehStack.PushBack(new ExcHandlerFrame { Pos = pos });
		    }
		    foreach (var catchBlock in _catchBlocks)
		    {
		        if (PosInRange(_myBufferPos, catchBlock.Start, catchBlock.Len))
		        {
		            switch (catchBlock.Kind)
		            {
		                case 0:
		                    if (_wasException)
		                    {
		                        var type = ex.GetType();
		                        var type2 = GetTypeById(catchBlock.ExcTypeId);
		                        if (type == type2 || type.IsSubclassOf(type2))
		                        {
                                    _ehStack.PushBack(new ExcHandlerFrame
                                    {
                                        Pos = catchBlock.Pos,
                                        Exception = ex
                                    });
		                            _wasException = false;
		                        }
		                    }
		                    break;
		                case 1:
		                    if (_wasException)
		                    {
                                _ehStack.PushBack(new ExcHandlerFrame { Pos = catchBlock.Pos });
		                    }
		                    break;
		                case 2:
		                    if (_wasException || !PosInRange((long)(ulong)pos, catchBlock.Start, catchBlock.Len))
		                    {
                                _ehStack.PushBack(new ExcHandlerFrame { Pos = catchBlock.Pos });
		                    }
		                    break;
		                case 4:
		                    if (_wasException)
		                    {
                                _ehStack.PushBack(new ExcHandlerFrame
                                {
                                    Pos = catchBlock.PosKind4,
                                    Exception = ex
                                });
		                    }
		                    break;
		            }
		        }
		    }
		    ExecuteExceptionHandler();
	    }

	    // Token: 0x06000221 RID: 545 RVA: 0x0000F210 File Offset: 0x0000D410
	    private void Stloc_0_(VariantBase dummy) // \u0008\u2003
	    {
            PopToLocal(0);
	    }

	    // Token: 0x06000222 RID: 546 RVA: 0x0000F21C File Offset: 0x0000D41C
	    private void Ldind_ref_(VariantBase dummy) // \u0003\u2003\u2001
	    {
		    Ldind(SimpleTypeHelper.ObjectType);
	    }

	    // Token: 0x06000223 RID: 547 RVA: 0x0000F22C File Offset: 0x0000D42C
	    private void Stind_r4_(VariantBase dummy) // \u0006\u2006
	    {
		    Stind();
	    }

	    // Token: 0x06000224 RID: 548 RVA: 0x0000F234 File Offset: 0x0000D434
	    private void Newarr_(VariantBase vTypeId) // \u0002\u2001\u2001
	    {
            var vLength = PopVariant();
		    var ivLength = vLength as IntVariant;
		    int length;
		    if (ivLength != null)
		    {
			    length = ivLength.GetValue();
		    }
		    else
		    {
			    var ipvLength = vLength as IntPtrVariant;
			    if (ipvLength != null)
			    {
				    length = ipvLength.GetValue().ToInt32();
			    }
			    else
			    {
				    var uipvLength = vLength as UIntPtrVariant;
				    if (uipvLength == null)
				    {
					    throw new Exception();
				    }
				    length = (int)uipvLength.GetValue().ToUInt32();
			    }
		    }
		    var array = Array.CreateInstance(GetTypeById(((IntVariant)vTypeId).GetValue()), length);
		    var push = new ArrayVariant();
		    push.SetValue(array);
		    PushVariant(push);
	    }

	    // Token: 0x06000226 RID: 550 RVA: 0x0000F308 File Offset: 0x0000D508
	    private bool RefToMdArrayItem(MethodBase mb, object array, ref object result, object[] oidxs) // \u0003
        {
		    if (!mb.IsStatic && mb.Name == StringDecryptor.GetString(-1550345964) /* Address */)
		    {
			    var methodInfo = mb as MethodInfo;
			    if (methodInfo != null)
			    {
				    var type = methodInfo.ReturnType;
				    if (type.IsByRef)
				    {
					    type = type.GetElementType();
					    var num = oidxs.Length;
					    if (num >= 1 && oidxs[0] is int)
					    {
						    var idxs = new int[num];
						    for (var i = 0; i < num; i++)
						    {
							    idxs[i] = (int)oidxs[i];
						    }
						    var val = new MdArrayValueVariant();
						    val.SetArray((Array)array);
						    val.SetIndexes(idxs);
						    val.SetHeldType(type);
						    result = val;
						    return true;
					    }
				    }
			    }
		    }
		    return false;
	    }

	    // Token: 0x0600022C RID: 556 RVA: 0x0000F86C File Offset: 0x0000DA6C
	    private void Stelem_r4_(VariantBase dummy) // \u0005\u200A
	    {
		    Stelem(typeof(float));
	    }

	    // Token: 0x0600022E RID: 558 RVA: 0x0000F8AC File Offset: 0x0000DAAC
	    private void Ldarg_2_(VariantBase dummy) // \u0006\u2003
	    {
		    PushVariant(_variantOutputArgs[2].Clone());
	    }

	    // Token: 0x06000230 RID: 560 RVA: 0x0000F8DC File Offset: 0x0000DADC
	    private void Not_(VariantBase dummy) // \u0008\u2002\u2001
	    {
            PushVariant(Not(PopVariant()));
	    }

	    // Token: 0x06000232 RID: 562 RVA: 0x0000F914 File Offset: 0x0000DB14
	    private void Ldind_i1_(VariantBase dummy) // \u000F\u2005\u2000
	    {
		    Ldind(typeof(sbyte));
	    }

	    // Token: 0x06000233 RID: 563 RVA: 0x0000F928 File Offset: 0x0000DB28
	    private void Stloc_2_(VariantBase dummy) // \u000F\u2009
	    {
            PopToLocal(2);
	    }

	    // Token: 0x06000235 RID: 565 RVA: 0x0000F96C File Offset: 0x0000DB6C
	    private void Stloc_1_(VariantBase dummy) // \u000E\u2009\u2000
	    {
            PopToLocal(1);
	    }

	    // Token: 0x06000236 RID: 566 RVA: 0x0000F978 File Offset: 0x0000DB78
	    private void Pop_(VariantBase dummy) // \u0003
        {
		    PopVariant();
	    }

	    // Token: 0x0600023A RID: 570 RVA: 0x0000F9D4 File Offset: 0x0000DBD4
	    private void Ldc_r8_(VariantBase val) // \u0005\u200B\u2000
	    {
		    PushVariant(val);
	    }

	    // Token: 0x0600023F RID: 575 RVA: 0x0000FDF4 File Offset: 0x0000DFF4
	    private void Ldelem_r4_(VariantBase dummy) // \u0008\u200B
	    {
		    Ldelem(typeof(float));
	    }

	    // Token: 0x06000240 RID: 576 RVA: 0x0000FE08 File Offset: 0x0000E008
	    private void UnlockInterlockedIfAny(ref BoolHolder wasLocked) // \u0002
        {
		    if (wasLocked.Val)
		    {
			    Monitor.Exit(InterlockedLock);
		    }
	    }

	    // Token: 0x06000241 RID: 577 RVA: 0x0000FE1C File Offset: 0x0000E01C
	    private void Ldarg_0_(VariantBase dummy) // \u0003\u2007
	    {
		    PushVariant(_variantOutputArgs[0].Clone());
	    }

	    // Token: 0x06000245 RID: 581 RVA: 0x00010198 File Offset: 0x0000E398
	    private VariantBase Not(VariantBase val) // \u0005
        {
            switch (val.GetTypeCode())
            {
                case VariantBase.Vtc.Tc19Int:
                    var iv = new IntVariant();
			        iv.SetValue(~((IntVariant)val).GetValue());
			        return iv;
                case VariantBase.Vtc.Tc24Long:
                    var lv = new LongVariant();
			        lv.SetValue(~((LongVariant)val).GetValue());
			        return lv;
                case VariantBase.Vtc.Tc5Enum:
		            var underlyingType = Enum.GetUnderlyingType(val.GetValueAbstract().GetType());
		            if (underlyingType == typeof(ulong))
		            {
                        var ret = new UlongVariant();
			            ret.SetValue(~Convert.ToUInt64(val.GetValueAbstract()));
			            return ret;
		            }
                    if (underlyingType == typeof(long))
                    {
                        var ret = new LongVariant();
                        ret.SetValue(~Convert.ToInt64(val.GetValueAbstract()));
                        return ret;
                    }
                    if (underlyingType == typeof(uint))
                    {
                        var ret = new UintVariant();
                        ret.SetValue(~Convert.ToUInt32(val.GetValueAbstract()));
                        return ret;
                    }
                    var result = new IntVariant();
		            result.SetValue(~Convert.ToInt32(val.GetValueAbstract()));
		            return result;
                case VariantBase.Vtc.Tc21Double:
                    if (IntPtr.Size == 4)
                    {
                        var ret = new DoubleVariant();
                        ret.SetValue(double.NaN);
                        return ret;
                    }
                    break;
                case VariantBase.Vtc.Tc8Float:
                    if (IntPtr.Size == 4)
                    {
                        var ret = new FloatVariant();
                        ret.SetValue(float.NaN);
                        return ret;
                    }
                    break;
                case VariantBase.Vtc.Tc18Object:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(OpCodes.Not);
                    gen.Emit(OpCodes.Ret);
                    var oret = new IntPtrVariant();
                    ((IntPtrVariant)oret).SetValue(((IntPtr)dyn.Invoke(null, new[] { val.GetValueAbstract() })));
                    return oret;
            }
            throw new InvalidProgramException();
	    }

	    // Token: 0x06000246 RID: 582 RVA: 0x0001025C File Offset: 0x0000E45C
	    private void Ldind_i8_(VariantBase dummy) // \u0005\u2006
	    {
		    Ldind(typeof(long));
	    }

	    // Token: 0x06000247 RID: 583 RVA: 0x00010270 File Offset: 0x0000E470
	    private void Clt_(VariantBase dummy) // \u0002\u2004\u2001
        {
		    var v2 = PopVariant();
		    var v1 = PopVariant();
		    var push = new IntVariant();
            push.SetValue(UniCompare(v1, v2, ComparisonKind.LT, false) ? 1 : 0);
		    PushVariant(push);
	    }

	    // Token: 0x06000249 RID: 585 RVA: 0x00010348 File Offset: 0x0000E548
	    private void Nop_(VariantBase dummy) // \u0005\u2005
	    {
	    }

	    // Token: 0x0600024B RID: 587 RVA: 0x00010498 File Offset: 0x0000E698
	    private void TryExecuteNextInstruction() // \u000E
        {
		    var key = _myBufferReader.ReadInt32();
		    VmInstr instr;
		    if (!_vmInstrDb.TryGetValue(key, out instr))
		    {
			    throw new InvalidOperationException(StringDecryptor.GetString(-1550345644) /* Unsupported instruction. */);
		    }
            instr.Func(ReadOperand(_myBufferReader, instr.Id.OperandType));
		    _myBufferPos = _myBufferReader.GetBuffer().GetPos();
	    }

	    // Token: 0x0600024E RID: 590 RVA: 0x000105B4 File Offset: 0x0000E7B4
	    private void Stelem_i1_(VariantBase dummy) // \u0002\u2003
	    {
		    var obj = PopVariant().GetValueAbstract();
		    var idx = PopLong();
		    var array = (Array)PopVariant().GetValueAbstract();
		    var elementType = array.GetType().GetElementType();
		    checked
		    {
			    if (elementType == typeof(sbyte))
			    {
                    ((sbyte[])array)[(int)(IntPtr)idx] = (sbyte)VariantFactory.Convert(obj, typeof(sbyte)).GetValueAbstract();
				    return;
			    }
			    if (elementType == typeof(byte))
			    {
                    ((byte[])array)[(int)(IntPtr)idx] = (byte)VariantFactory.Convert(obj, typeof(byte)).GetValueAbstract();
				    return;
			    }
			    if (elementType == typeof(bool))
			    {
                    ((bool[])array)[(int)(IntPtr)idx] = (bool)VariantFactory.Convert(obj, typeof(bool)).GetValueAbstract();
				    return;
			    }
			    if (elementType.IsEnum)
			    {
                    Stelem(elementType, obj, idx, array);
				    return;
			    }
                Stelem(typeof(sbyte), obj, idx, array);
		    }
	    }

	    // Token: 0x0600024F RID: 591 RVA: 0x000106B8 File Offset: 0x0000E8B8
	    private void Starg_s_(VariantBase vidx) // \u000E\u2007\u2000
	    {
		    var idx = (ByteVariant)vidx;
		    _variantOutputArgs[idx.GetValue()].CopyFrom(PopVariant());
	    }

	    // Token: 0x06000251 RID: 593 RVA: 0x00010748 File Offset: 0x0000E948
	    private void Ldlen_(VariantBase dummy) // \u000E\u200B\u2000
	    {
		    var array = (Array)PopVariant().GetValueAbstract();
		    var len = new IntVariant();
		    len.SetValue(array.Length);
		    PushVariant(len);
	    }

	    // Token: 0x06000256 RID: 598 RVA: 0x00010948 File Offset: 0x0000EB48
	    private void Ldelem_i2_(VariantBase dummy) // \u0008\u2000
	    {
		    Ldelem(typeof(short));
	    }

	    // Token: 0x06000257 RID: 599 RVA: 0x0001095C File Offset: 0x0000EB5C
	    private void Ldarg_(VariantBase vidx) // \u000E\u2000\u2000
        {
		    var idx = (UshortVariant)vidx;
		    PushVariant(_variantOutputArgs[idx.GetValue()].Clone());
	    }

	    // Token: 0x06000258 RID: 600 RVA: 0x0001098C File Offset: 0x0000EB8C
	    private void Clt_un_(VariantBase dummy) // \u0003\u2000\u2001
	    {
		    var v2 = PopVariant();
		    var v1 = PopVariant();
		    var push = new IntVariant();
            push.SetValue(UniCompare(v1, v2, ComparisonKind.LT, true) ? 1 : 0);
		    PushVariant(push);
	    }

	    // Token: 0x06000259 RID: 601 RVA: 0x000109C8 File Offset: 0x0000EBC8
	    private void Dup_(VariantBase dummy) // \u0002\u2006\u2000
	    {
		    var v = PopVariant();
		    PushVariant(v);
		    PushVariant(v.Clone());
	    }

	    // Token: 0x0600025A RID: 602 RVA: 0x000109F4 File Offset: 0x0000EBF4
	    [Conditional("DEBUG")]
	    private void DoNothing(object dummy) // \u0002
        {
	    }

	    // Token: 0x0600025B RID: 603 RVA: 0x000109F8 File Offset: 0x0000EBF8
	    private VariantBase[] ArgsToVariantOutputArgs(object[] args) // u0002
	    {
		    var methodHeaderArgsTypeToOutput = _methodHeader.ArgsTypeToOutput;
		    var num = methodHeaderArgsTypeToOutput.Length;
		    var retArgs = new VariantBase[num];
		    for (var i = 0; i < num; i++)
		    {
			    var obj = args[i];
			    var type = GetTypeById(methodHeaderArgsTypeToOutput[i].TypeId);
			    var type2 = ElementedTypeHelper.TryGoToPointerOrReferenceElementType(type);
			    Type type3;
			    if (type2 == SimpleTypeHelper.ObjectType || SimpleTypeHelper.IsNullableGeneric(type2))
			    {
				    type3 = type;
			    }
			    else
			    {
				    type3 = obj?.GetType() ?? type;
			    }
			    if (obj != null && !type.IsAssignableFrom(type3) && type.IsByRef && !type.GetElementType().IsAssignableFrom(type3))
			    {
				    throw new ArgumentException(string.Format(StringDecryptor.GetString(-1550345390) /* Object of type {0} cannot be converted to type {1}. */, type3, type));
			    }
			    retArgs[i] = VariantFactory.Convert(obj, type3);
		    }
		    if (!_methodHeader.IsStatic() && GetTypeById(_methodHeader.ClassId).IsValueType)
		    {
			    var expr_EB = new VariantBaseHolder();
			    expr_EB.SetValue(retArgs[0]);
		        retArgs[0] = expr_EB;
		    }
		    for (var j = 0; j < num; j++)
		    {
			    if (methodHeaderArgsTypeToOutput[j].IsOutput)
			    {
				    var expr_116 = new VariantBaseHolder();
				    expr_116.SetValue(retArgs[j]);
			        retArgs[j] = expr_116;
			    }
		    }
		    return retArgs;
	    }

	    // Token: 0x0600025D RID: 605 RVA: 0x00010B3C File Offset: 0x0000ED3C
	    private void Stind() // \u0003
        {
		    var v2 = PopVariant();
		    var v1 = PopVariant();
            AssignByReference(v1, v2);
	    }

	    // Token: 0x0600025E RID: 606 RVA: 0x00010B60 File Offset: 0x0000ED60
	    private void Endfinally_(VariantBase dummy) // \u0005\u2000\u2001
	    {
		    ExecuteExceptionHandler();
	    }

	    // Token: 0x0600025F RID: 607 RVA: 0x00010B68 File Offset: 0x0000ED68
	    private bool PosInRange(long pos, uint start, uint len) // \u0002
        {
		    return pos >= (long)(ulong)start && pos <= (long)(ulong)(start + len);
	    }

	    // Token: 0x06000260 RID: 608 RVA: 0x00010B7C File Offset: 0x0000ED7C
	    private bool IsCompatible(MethodBase mb) // \u0002
        {
		    return mb.IsVirtual && GetTypeById(_methodHeader.ClassId).IsSubclassOf(mb.DeclaringType);
	    }

	    // Token: 0x06000263 RID: 611 RVA: 0x00010C00 File Offset: 0x0000EE00
	    private void Stelem_(VariantBase vTypeId) // \u0006\u2004\u2000
	    {
		    Stelem(GetTypeById(((IntVariant)vTypeId).GetValue()));
	    }

	    // Token: 0x06000265 RID: 613 RVA: 0x00010C40 File Offset: 0x0000EE40
	    private void Ldelem_u1_(VariantBase dummy) // \u0006\u2004
	    {
		    Ldelem(typeof(byte));
	    }

	    // Token: 0x06000267 RID: 615 RVA: 0x00010C80 File Offset: 0x0000EE80
	    private void Cgt_(VariantBase dummy) // \u0005\u2001\u2000
	    {
		    var v2 = PopVariant();
		    var v1 = PopVariant();
		    var push = new IntVariant();
            push.SetValue(UniCompare(v1, v2, ComparisonKind.GT, false) ? 1 : 0);
		    PushVariant(push);
	    }

	    private VariantBase And(VariantBase org_v1, VariantBase org_v2)
	    {
	        VariantBase v1, v2;
            var tc = CommonType(org_v1, org_v2, out v1, out v2, true);
            VariantBase ret;
            switch (tc)
            {
                case VariantBase.Vtc.Tc9Uint:
                    uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
                    var uvret = new UintVariant();
                    ret = uvret;
                    uvret.SetValue(uv1 & uv2);
                    break;
                case VariantBase.Vtc.Tc19Int:
                    int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
                    var ivret = new IntVariant();
                    ret = ivret;
                    ivret.SetValue(iv1 & iv2);
                    break;
                case VariantBase.Vtc.Tc21Double:
                    {
                        /*double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue(); // естественный алгоритм
                        long lv1 = (dv1 < 0) ? (long)dv1 : (long)(ulong)dv1;
                        long lv2 = (dv2 < 0) ? (long)dv2 : (long)(ulong)dv2;
                        var dvret = new DoubleVariant();
                        ret = dvret;
                        var l64 = (ulong) lv1 & (ulong) lv2;
                        if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
                        dvret.SetValue(l64);*/
                        var dvret = new DoubleVariant();
                        ret = dvret;
                        dvret.SetValue((4 == IntPtr.Size) ? Double.NaN : (double)0); // иногда у фреймворка бывает мусор, но чаще эти значения...
                    }
                    break;
                case VariantBase.Vtc.Tc8Float:
                    {
                        /*float fv1 = ((FloatVariant) v1).GetValue(), fv2 = ((FloatVariant) v2).GetValue(); // естественный алгоритм
                        long lv1 = (fv1 < 0) ? (long)fv1 : (long)(ulong)fv1;
                        long lv2 = (fv2 < 0) ? (long)fv2 : (long)(ulong)fv2;
                        var fvret = new FloatVariant();
                        ret = fvret;
                        var l64 = (ulong)lv1 & (ulong)lv2;
                        if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
                        fvret.SetValue(l64);*/
                        var fvret = new FloatVariant();
                        ret = fvret;
                        fvret.SetValue((4 == IntPtr.Size) ? float.NaN : (float)0.0); // иногда у фреймворка бывает мусор, но чаще эти значения...
                    }
                    break;
                case VariantBase.Vtc.Tc24Long:
                    {
                        long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
                        var lvret = new LongVariant();
                        ret = lvret;
                        lvret.SetValue(lv1 & lv2);
                    }
                    break;
                case VariantBase.Vtc.Tc7Ulong:
                    ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
                    var ulvret = new UlongVariant();
                    ret = ulvret;
                    ulvret.SetValue(ulv1 & ulv2);
                    break;
                default:
                    // это нужно будет заменить на соотв. msil-код
                    var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
                    var gen = dyn.GetILGenerator();
                    gen.Emit(OpCodes.Ldarg_1);
                    gen.Emit(OpCodes.Ldarg_0);
                    gen.Emit(OpCodes.And);
                    gen.Emit(OpCodes.Ret);
                    ret = new IntPtrVariant();
                    ((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
                    break;
            }
            return ret;
        }

        // Token: 0x0600026E RID: 622 RVA: 0x000110D8 File Offset: 0x0000F2D8
        private void Ldind(Type t) // \u0005
        {
            PushVariant(VariantFactory.Convert(FetchByAddr(PopVariant()).GetValueAbstract(), t));
	    }

	    // Token: 0x0600026F RID: 623 RVA: 0x00011104 File Offset: 0x0000F304
	    private void Starg_(VariantBase vidx) // \u000F\u2008\u2000
	    {
		    var idx = (UshortVariant)vidx;
		    _variantOutputArgs[idx.GetValue()].CopyFrom(PopVariant());
	    }

	    // Token: 0x06000270 RID: 624 RVA: 0x00011138 File Offset: 0x0000F338
	    private void Ret() // \u0008
        {
		    _retFound = true;
	    }

	    // Token: 0x06000273 RID: 627 RVA: 0x00011480 File Offset: 0x0000F680
	    private void Stind_r8_(VariantBase dummy) // \u0005\u2004\u2000
	    {
		    Stind();
	    }

	    // Token: 0x06000275 RID: 629 RVA: 0x00011510 File Offset: 0x0000F710
	    private void Rethrow_(VariantBase dummy) // \u0003\u200A\u2000
        {
		    if (_exception == null)
		    {
			    throw new InvalidOperationException();
		    }
		    _myBufferPos = _myBufferReader.GetBuffer().GetPos();
		    ThrowStoreCrossDomain(_exception);
	    }

	    // Token: 0x06000278 RID: 632 RVA: 0x00011838 File Offset: 0x0000FA38
	    private void Ldelem_u4_(VariantBase dummy) // \u0003\u2003
	    {
		    Ldelem(typeof(uint));
	    }

	    // Token: 0x0600027A RID: 634 RVA: 0x00011994 File Offset: 0x0000FB94
	    private void Invoke(VmMethodRefTokenInfo mref) // \u0002
        {
            //var arg_18_0 = (U0008U2007)U0003U2008.Get_u0005();
            var methodBase = FindMethodById(mref.Pos, ReadToken(mref.Pos));
		    //methodBase.GetParameters();
		    var pos = mref.Flags;
		    var mayVirtual = (pos & 1073741824) != 0;
		    pos &= -1073741825;
		    var methodGenericArgs = _methodGenericArgs;
		    var classGenericArgs = _classGenericArgs;
		    try
		    {
			    _methodGenericArgs = methodBase is ConstructorInfo ? Type.EmptyTypes : methodBase.GetGenericArguments();
			    _classGenericArgs = methodBase.DeclaringType.GetGenericArguments();
                Invoke(pos, _methodGenericArgs, _classGenericArgs, mayVirtual);
		    }
		    finally
		    {
			    _methodGenericArgs = methodGenericArgs;
			    _classGenericArgs = classGenericArgs;
		    }
	    }

	    // Token: 0x0600027B RID: 635 RVA: 0x00011A5C File Offset: 0x0000FC5C
	    private void Ldc_i8_(VariantBase val) // \u0006\u2007\u2000
	    {
		    PushVariant(val);
	    }

	    // Token: 0x0600027E RID: 638 RVA: 0x00011CB8 File Offset: 0x0000FEB8
	    private void Ldelem_r8_(VariantBase dummy) // \u000E\u2002\u2000
	    {
		    Ldelem(typeof(double));
	    }

	    // Token: 0x06000280 RID: 640 RVA: 0x00011DB4 File Offset: 0x0000FFB4
	    private void Stloc_3_(VariantBase dummy) // \u0003\u2004\u2000
	    {
            PopToLocal(3);
	    }

	    // Token: 0x06000281 RID: 641 RVA: 0x00011DC0 File Offset: 0x0000FFC0
	    private void Ckfinite_(VariantBase dummy) // \u000F\u2003
	    {
	        var v = PopVariant();
            if (v.GetTypeCode() == VariantBase.Vtc.Tc5Enum)
            {
                v = VariantBase.SignedVariantFromEnum((EnumVariant)v);
            }
	        double val = double.NaN;
	        bool con = v.GetValueAbstract() is IConvertible;
	        if (con)
	        {
	            val = Convert.ToDouble(v.GetValueAbstract());
                if (double.IsNaN(val) || double.IsInfinity(val))
                {
                    throw new OverflowException(StringDecryptor.GetString(-1550347095) /* The value is not finite real number. */);
                }
            }
            if (IsFloating(v))
	        {
                PushVariant(v);
            } else
	        {
	            var push = new DoubleVariant();
                push.SetValue(val);
                PushVariant(push);
	        }
	    }

	    // Token: 0x06000288 RID: 648 RVA: 0x00012170 File Offset: 0x00010370
	    private void Stind_ref_(VariantBase dummy) // \u0002\u2008
	    {
		    Stind();
	    }

	    // Token: 0x06000289 RID: 649 RVA: 0x00012178 File Offset: 0x00010378
	    private void PopToLocal(int idx) // \u0002
        {
		    var pop = PopVariant();
		    if (pop is ReferenceVariantBase)
		    {
			    _localVariables[idx] = pop;
			    return;
		    }
		    _localVariables[idx].CopyFrom(pop);
	    }

	    // Token: 0x0600028B RID: 651 RVA: 0x00012260 File Offset: 0x00010460
	    private void Ldobj_(VariantBase vTypeId) // \u000E\u2008
	    {
            var type = GetTypeById(((IntVariant)vTypeId).GetValue());
		    Ldind(type);
	    }

	    // Token: 0x0600028C RID: 652 RVA: 0x00012288 File Offset: 0x00010488
	    private void Ldloc_1_(VariantBase dummy) // \u0003\u2008\u2000
	    {
		    PushVariant(_localVariables[1].Clone());
	    }

	    // Token: 0x0600028E RID: 654 RVA: 0x00012348 File Offset: 0x00010548
	    private void Ldelem_i1_(VariantBase dummy) // \u0005\u2009\u2000
	    {
		    Ldelem(typeof(sbyte));
	    }

	    // Token: 0x06000290 RID: 656 RVA: 0x00012370 File Offset: 0x00010570
	    private void JumpToPos(uint val) // \u0002
        {
		    _storedPos = val;
	    }

	    // Token: 0x06000291 RID: 657 RVA: 0x00012380 File Offset: 0x00010580
	    public void VoidInvoke(Stream virtualizedStream, string pos, object[] args) // \u0002
        {
		    Invoke(virtualizedStream, pos, args);
	    }

	    // Token: 0x06000295 RID: 661 RVA: 0x00012420 File Offset: 0x00010620
	    private void _u0002u2002u2001(VariantBase dummy) // \u0002\u2002\u2001
	    {
	    }

	    // Token: 0x06000298 RID: 664 RVA: 0x00012590 File Offset: 0x00010790
	    private void LoopUntilRet() // \u0005\u2000
        {
		    var usedSize = _myBufferReader.GetBuffer().UsedSize();
		    while (!_retFound)
		    {
			    if (_storedPos.HasValue)
			    {
				    _myBufferReader.GetBuffer().SetPos((long)(ulong)_storedPos.Value);
				    _storedPos = null;
			    }
			    ExecuteNextInstruction();
			    if (_myBufferReader.GetBuffer().GetPos() >= usedSize && !_storedPos.HasValue)
			    {
				    break;
			    }
		    }
	    }

	    // Token: 0x06000299 RID: 665 RVA: 0x00012614 File Offset: 0x00010814
	    private VmInstrInfo GetInstrById(int id) // \u0002
	    {
	        return _instrCodesDb.MyFieldsEnumerator().FirstOrDefault(current => current.Id == id);
	    }

	    // Token: 0x0600029A RID: 666 RVA: 0x00012670 File Offset: 0x00010870
	    private void Ldloc_(VariantBase val) // \u000F\u200A\u2000
	    {
		    PushVariant(_localVariables[((UshortVariant)val).GetValue()].Clone());
	    }

	    // Token: 0x0600029E RID: 670 RVA: 0x00012718 File Offset: 0x00010918
	    private bool Isinst(VariantBase obj, Type t) // \u0002
        {
		    if (obj.GetValueAbstract() == null)
		    {
			    return true;
		    }
		    var type = obj.GetVariantType() ?? obj.GetValueAbstract().GetType();
		    if (type == t || t.IsAssignableFrom(type))
		    {
			    return true;
		    }
		    if (!type.IsValueType && !t.IsValueType && Marshal.IsComObject(obj.GetValueAbstract()))
		    {
			    IntPtr intPtr;
			    try
			    {
				    intPtr = Marshal.GetComInterfaceForObject(obj.GetValueAbstract(), t);
			    }
			    catch (InvalidCastException)
			    {
				    intPtr = IntPtr.Zero;
			    }
			    if (intPtr != IntPtr.Zero)
			    {
				    try
				    {
					    Marshal.Release(intPtr);
				    }
				    catch
				    {
				    }
				    return true;
			    }
		    }
		    return false;
	    }

	    // Token: 0x0600029F RID: 671 RVA: 0x000127C4 File Offset: 0x000109C4
	    private void Ldind_r8_(VariantBase dummy) // \u000E\u2008\u2000
	    {
		    Ldind(typeof(double));
	    }

	    // Token: 0x060002A1 RID: 673 RVA: 0x00012870 File Offset: 0x00010A70
	    private void Stobj_(VariantBase dummy) // \u0005\u2009
	    {
		    Stind();
	    }

        // Token: 0x060002A4 RID: 676 RVA: 0x00012A44 File Offset: 0x00010C44
        private void Cgt_un_(VariantBase dummy) // \u0006\u2002
	    {
		    var v2 = PopVariant();
		    var v1 = PopVariant();
		    var push = new IntVariant();
            push.SetValue(UniCompare(v1, v2, ComparisonKind.GT, true) ? 1 : 0);
		    PushVariant(push);
	    }

	    // Token: 0x060002A7 RID: 679 RVA: 0x00012CDC File Offset: 0x00010EDC
	    private bool AreCompatible(Type t1, UniversalTokenInfo ut2) // \u0002
        {
		    var t2 = (VmClassTokenInfo)ut2.VmToken;
		    if (ElementedTypeHelper.TryGoToElementType(t1).IsGenericParameter)
		    {
			    return t2 == null || t2.IsOuterClassGeneric;
		    }
            return TypeCompatibility.Check(t1, GetTypeById(ut2.MetadataToken));
	    }

	    // Token: 0x060002A9 RID: 681 RVA: 0x00012D38 File Offset: 0x00010F38
	    private void Ldloca_(VariantBase vLocIdx) // \u0006\u2005
	    {
            var push = new LocalsIdxHolderVariant();
		    push.SetValue(((UshortVariant)vLocIdx).GetValue());
		    PushVariant(push);
	    }

	    // Token: 0x060002AA RID: 682 RVA: 0x00012D64 File Offset: 0x00010F64
	    private void Ldarg_3_(VariantBase dummy) // \u000E\u2009
	    {
		    PushVariant(_variantOutputArgs[3].Clone());
	    }

	    // Token: 0x060002AC RID: 684 RVA: 0x00012DB8 File Offset: 0x00010FB8
	    /*[Conditional("DEBUG")]
	    public static void DoNothing(string dummy) // \u0002
        {
	    }*/

        // Token: 0x0600021F RID: 543 RVA: 0x0000C8BC File Offset: 0x0000AABC
        private Dictionary<int, VmInstr> CreateVmInstrDb() // \u0002
        {
            return new Dictionary<int, VmInstr>(256)
            {
                {
                    _instrCodesDb.Conv_ovf_i4_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i4_un_, Conv_ovf_i4_un_)
                },
                {
                    _instrCodesDb.Shr_un_.Id,
                    new VmInstr(_instrCodesDb.Shr_un_, Shr_un_)
                },
                {
                    _instrCodesDb.Conv_i_.Id,
                    new VmInstr(_instrCodesDb.Conv_i_, Conv_i_)
                },
                {
                    _instrCodesDb.Conv_ovf_i_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i_un_, Conv_ovf_i_un_)
                },
                {
                    _instrCodesDb.Stelem_i_.Id,
                    new VmInstr(_instrCodesDb.Stelem_i_, Stelem_i_)
                },
                {
                    _instrCodesDb.Starg_s_.Id,
                    new VmInstr(_instrCodesDb.Starg_s_, Starg_s_)
                },
                {
                    _instrCodesDb.Sizeof_.Id,
                    new VmInstr(_instrCodesDb.Sizeof_, Sizeof_)
                },
                {
                    _instrCodesDb.Ldarg_s_.Id,
                    new VmInstr(_instrCodesDb.Ldarg_s_, Ldarg_s_)
                },
                {
                    _instrCodesDb.Stelem_i4_.Id,
                    new VmInstr(_instrCodesDb.Stelem_i4_, Stelem_i4_)
                },
                {
                    _instrCodesDb.Calli_.Id,
                    new VmInstr(_instrCodesDb.Calli_, Calli_)
                },
                {
                    _instrCodesDb.Ldc_i4_7_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_7_, Ldc_i4_7_)
                },
                {
                    _instrCodesDb.Newobj_.Id,
                    new VmInstr(_instrCodesDb.Newobj_, Newobj_)
                },
                {
                    _instrCodesDb.Ldind_u4_.Id,
                    new VmInstr(_instrCodesDb.Ldind_u4_, Ldind_u4_)
                },
                {
                    _instrCodesDb.Cgt_un_.Id,
                    new VmInstr(_instrCodesDb.Cgt_un_, Cgt_un_)
                },
                {
                    _instrCodesDb.Conv_u1_.Id,
                    new VmInstr(_instrCodesDb.Conv_u1_, Conv_u1_)
                },
                {
                    _instrCodesDb.Ldelem_ref_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_ref_, Ldelem_ref_)
                },
                {
                    _instrCodesDb.U0006U2008U2000.Id,
                    new VmInstr(_instrCodesDb.U0006U2008U2000, _u0002u2002u2001)
                },
                {
                    _instrCodesDb.Newarr_.Id,
                    new VmInstr(_instrCodesDb.Newarr_, Newarr_)
                },
                {
                    _instrCodesDb.Ldarga_s_.Id,
                    new VmInstr(_instrCodesDb.Ldarga_s_, Ldarga_s_)
                },
                {
                    _instrCodesDb.Bgt_.Id,
                    new VmInstr(_instrCodesDb.Bgt_, Bgt_)
                },
                {
                    _instrCodesDb.Ldflda_.Id,
                    new VmInstr(_instrCodesDb.Ldflda_, Ldflda_)
                },
                {
                    _instrCodesDb.Sub_.Id,
                    new VmInstr(_instrCodesDb.Sub_, Sub_)
                },
                {
                    _instrCodesDb.Endfilter_.Id,
                    new VmInstr(_instrCodesDb.Endfilter_, Endfilter_)
                },
                {
                    _instrCodesDb.Conv_ovf_u_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u_un_, Conv_ovf_u_un_)
                },
                {
                    _instrCodesDb.Ldc_i4_1_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_1_, Ldc_i4_1_)
                },
                {
                    _instrCodesDb.Conv_ovf_i_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i_, Conv_ovf_i_)
                },
                {
                    _instrCodesDb.Add_ovf_.Id,
                    new VmInstr(_instrCodesDb.Add_ovf_, Add_ovf_)
                },
                {
                    _instrCodesDb.Ldftn_.Id,
                    new VmInstr(_instrCodesDb.Ldftn_, Ldftn_)
                },
                {
                    _instrCodesDb.Stfld_.Id,
                    new VmInstr(_instrCodesDb.Stfld_, Stfld_)
                },
                {
                    _instrCodesDb.Ldc_i4_5_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_5_, Ldc_i4_5_)
                },
                {
                    _instrCodesDb.Xor_.Id,
                    new VmInstr(_instrCodesDb.Xor_, Xor_)
                },
                {
                    _instrCodesDb.Conv_u2_.Id,
                    new VmInstr(_instrCodesDb.Conv_u2_, Conv_u2_)
                },
                {
                    _instrCodesDb.Div_un_.Id,
                    new VmInstr(_instrCodesDb.Div_un_, Div_un_)
                },
                {
                    _instrCodesDb.Stloc_3_.Id,
                    new VmInstr(_instrCodesDb.Stloc_3_, Stloc_3_)
                },
                {
                    _instrCodesDb.Ret_.Id,
                    new VmInstr(_instrCodesDb.Ret_, Ret_)
                },
                {
                    _instrCodesDb.Ldc_i4_m1_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_m1_, Ldc_i4_m1_)
                },
                {
                    _instrCodesDb.Ldarg_1_.Id,
                    new VmInstr(_instrCodesDb.Ldarg_1_, Ldarg_1_)
                },
                {
                    _instrCodesDb.Div_.Id,
                    new VmInstr(_instrCodesDb.Div_, Div_)
                },
                {
                    _instrCodesDb.Ldnull_.Id,
                    new VmInstr(_instrCodesDb.Ldnull_, Ldnull_)
                },
                {
                    _instrCodesDb.Break_.Id,
                    new VmInstr(_instrCodesDb.Break_, Break_)
                },
                {
                    _instrCodesDb.Cgt_.Id,
                    new VmInstr(_instrCodesDb.Cgt_, Cgt_)
                },
                {
                    _instrCodesDb.Arglist_.Id,
                    new VmInstr(_instrCodesDb.Arglist_, Arglist_)
                },
                {
                    _instrCodesDb.Ldloc_.Id,
                    new VmInstr(_instrCodesDb.Ldloc_, Ldloc_)
                },
                {
                    _instrCodesDb.Conv_u_.Id,
                    new VmInstr(_instrCodesDb.Conv_u_, Conv_u_)
                },
                {
                    _instrCodesDb.Ldelem_i_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_i_, Ldelem_i_)
                },
                {
                    _instrCodesDb.Conv_ovf_i1_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i1_un_, Conv_ovf_i1_un_)
                },
                {
                    _instrCodesDb.Cpblk_.Id,
                    new VmInstr(_instrCodesDb.Cpblk_, Cpblk_)
                },
                {
                    _instrCodesDb.Add_.Id,
                    new VmInstr(_instrCodesDb.Add_, Add_)
                },
                {
                    _instrCodesDb.Initblk_.Id,
                    new VmInstr(_instrCodesDb.Initblk_, Initblk_)
                },
                {
                    _instrCodesDb.Ldind_i_.Id,
                    new VmInstr(_instrCodesDb.Ldind_i_, Ldind_i_)
                },
                {
                    _instrCodesDb.Ldelem_u4_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_u4_, Ldelem_u4_)
                },
                {
                    _instrCodesDb.Stind_ref_.Id,
                    new VmInstr(_instrCodesDb.Stind_ref_, Stind_ref_)
                },
                {
                    _instrCodesDb.Ldelem_i1_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_i1_, Ldelem_i1_)
                },
                {
                    _instrCodesDb.Ldloc_3_.Id,
                    new VmInstr(_instrCodesDb.Ldloc_3_, Ldloc_3_)
                },
                {
                    _instrCodesDb.Stind_i8_.Id,
                    new VmInstr(_instrCodesDb.Stind_i8_, Stind_i8_)
                },
                {
                    _instrCodesDb.Conv_i1_.Id,
                    new VmInstr(_instrCodesDb.Conv_i1_, Conv_i1_)
                },
                {
                    _instrCodesDb.Ldelem_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_, Ldelem_)
                },
                {
                    _instrCodesDb.Clt_un_.Id,
                    new VmInstr(_instrCodesDb.Clt_un_, Clt_un_)
                },
                {
                    _instrCodesDb.Ldelem_i4_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_i4_, Ldelem_i4_)
                },
                {
                    _instrCodesDb.Mkrefany_.Id,
                    new VmInstr(_instrCodesDb.Mkrefany_, Mkrefany_)
                },
                {
                    _instrCodesDb.Neg_.Id,
                    new VmInstr(_instrCodesDb.Neg_, Neg_)
                },
                {
                    _instrCodesDb.Leave_.Id,
                    new VmInstr(_instrCodesDb.Leave_, Leave_)
                },
                {
                    _instrCodesDb.Ldc_i4_2_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_2_, Ldc_i4_2_)
                },
                {
                    _instrCodesDb.Conv_ovf_i2_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i2_, Conv_ovf_i2_)
                },
                {
                    _instrCodesDb.Ldloc_2_.Id,
                    new VmInstr(_instrCodesDb.Ldloc_2_, Ldloc_2_)
                },
                {
                    _instrCodesDb.Bgt_un_.Id,
                    new VmInstr(_instrCodesDb.Bgt_un_, Bgt_un_)
                },
                {
                    _instrCodesDb.Stsfld_.Id,
                    new VmInstr(_instrCodesDb.Stsfld_, Stsfld_)
                },
                /*{
                    _instrCodesDb.Nop_.Id,
                    new VmInstr(_instrCodesDb.Nop_, u000Fu2004)
                },*/
                {
                    _instrCodesDb.Shr_.Id,
                    new VmInstr(_instrCodesDb.Shr_, Shr_)
                },
                {
                    _instrCodesDb.Ldind_ref_.Id,
                    new VmInstr(_instrCodesDb.Ldind_ref_, Ldind_ref_)
                },
                {
                    _instrCodesDb.Ldfld_.Id,
                    new VmInstr(_instrCodesDb.Ldfld_, Ldfld_)
                },
                {
                    _instrCodesDb.Ldlen_.Id,
                    new VmInstr(_instrCodesDb.Ldlen_, Ldlen_)
                },
                {
                    _instrCodesDb.Stelem_ref_.Id,
                    new VmInstr(_instrCodesDb.Stelem_ref_, Stelem_ref_)
                },
                {
                    _instrCodesDb.Ceq_.Id,
                    new VmInstr(_instrCodesDb.Ceq_, Ceq_)
                },
                {
                    _instrCodesDb.Conv_ovf_u2_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u2_, Conv_ovf_u2_)
                },
                {
                    _instrCodesDb.Add_ovf_un_.Id,
                    new VmInstr(_instrCodesDb.Add_ovf_un_, Add_ovf_un_)
                },
                {
                    _instrCodesDb.Conv_ovf_i8_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i8_, Conv_ovf_i8_)
                },
                {
                    _instrCodesDb.Stind_i2_.Id,
                    new VmInstr(_instrCodesDb.Stind_i2_, Stind_i2_)
                },
                {
                    _instrCodesDb.Stelem_i1_.Id,
                    new VmInstr(_instrCodesDb.Stelem_i1_, Stelem_i1_)
                },
                {
                    _instrCodesDb.Ldloca_.Id,
                    new VmInstr(_instrCodesDb.Ldloca_, Ldloca_)
                },
                {
                    _instrCodesDb.Stind_r4_.Id,
                    new VmInstr(_instrCodesDb.Stind_r4_, Stind_r4_)
                },
                {
                    _instrCodesDb.Stloc_s_.Id,
                    new VmInstr(_instrCodesDb.Stloc_s_, Stloc_s_)
                },
                {
                    _instrCodesDb.Refanyval_.Id,
                    new VmInstr(_instrCodesDb.Refanyval_, Refanyval_)
                },
                {
                    _instrCodesDb.Clt_.Id,
                    new VmInstr(_instrCodesDb.Clt_, Clt_)
                },
                {
                    _instrCodesDb.Stelem_r4_.Id,
                    new VmInstr(_instrCodesDb.Stelem_r4_, Stelem_r4_)
                },
                {
                    _instrCodesDb.Stelem_r8_.Id,
                    new VmInstr(_instrCodesDb.Stelem_r8_, Stelem_r8_)
                },
                {
                    _instrCodesDb.Conv_u4_.Id,
                    new VmInstr(_instrCodesDb.Conv_u4_, Conv_u4_)
                },
                {
                    _instrCodesDb.Ldc_i8_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i8_, Ldc_i8_)
                },
                {
                    _instrCodesDb.Ldind_r4_.Id,
                    new VmInstr(_instrCodesDb.Ldind_r4_, Ldind_r4_)
                },
                {
                    _instrCodesDb.Conv_r_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_r_un_, Conv_r_un_)
                },
                {
                    _instrCodesDb.Ldtoken_.Id,
                    new VmInstr(_instrCodesDb.Ldtoken_, Ldtoken_)
                },
                {
                    _instrCodesDb.Blt_un_.Id,
                    new VmInstr(_instrCodesDb.Blt_un_, Blt_un_)
                },
                {
                    _instrCodesDb.Brtrue_.Id,
                    new VmInstr(_instrCodesDb.Brtrue_, Brtrue_)
                },
                {
                    _instrCodesDb.Switch_.Id,
                    new VmInstr(_instrCodesDb.Switch_, Switch_)
                },
                {
                    _instrCodesDb.Refanytype_.Id,
                    new VmInstr(_instrCodesDb.Refanytype_, Refanytype_)
                },
                {
                    _instrCodesDb.Stobj_.Id,
                    new VmInstr(_instrCodesDb.Stobj_, Stobj_)
                },
                {
                    _instrCodesDb.Ble_un_.Id,
                    new VmInstr(_instrCodesDb.Ble_un_, Ble_un_)
                },
                {
                    _instrCodesDb.Conv_ovf_i8_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i8_un_, Conv_ovf_i8_un_)
                },
                {
                    _instrCodesDb.Conv_ovf_u4_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u4_un_, Conv_ovf_u4_un_)
                },
                {
                    _instrCodesDb.Ldind_i8_.Id,
                    new VmInstr(_instrCodesDb.Ldind_i8_, Ldind_i8_)
                },
                {
                    _instrCodesDb.U000EU2006U2000.Id,
                    new VmInstr(_instrCodesDb.U000EU2006U2000, Invoke)
                },
                {
                    _instrCodesDb.Endfinally_.Id,
                    new VmInstr(_instrCodesDb.Endfinally_, Endfinally_)
                },
                {
                    _instrCodesDb.Conv_ovf_u8_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u8_un_, Conv_ovf_u8_un_)
                },
                {
                    _instrCodesDb.Ldelem_i2_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_i2_, Ldelem_i2_)
                },
                {
                    _instrCodesDb.Ldc_i4_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_, Ldc_i4_)
                },
                {
                    _instrCodesDb.U000FU2001.Id,
                    new VmInstr(_instrCodesDb.U000FU2001, _u0006u2003u2001)
                },
                {
                    _instrCodesDb.Conv_i4_.Id,
                    new VmInstr(_instrCodesDb.Conv_i4_, Conv_i4_)
                },
                {
                    _instrCodesDb.Ldind_u1_.Id,
                    new VmInstr(_instrCodesDb.Ldind_u1_, Ldind_u1_)
                },
                {
                    _instrCodesDb.Rethrow_.Id,
                    new VmInstr(_instrCodesDb.Rethrow_, Rethrow_)
                },
                {
                    _instrCodesDb.Conv_ovf_i1_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i1_, Conv_ovf_i1_)
                },
                {
                    _instrCodesDb.Box_.Id,
                    new VmInstr(_instrCodesDb.Box_, Box_)
                },
                {
                    _instrCodesDb.Localloc_.Id,
                    new VmInstr(_instrCodesDb.Localloc_, Localloc_)
                },
                {
                    _instrCodesDb.Ldelem_r8_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_r8_, Ldelem_r8_)
                },
                {
                    _instrCodesDb.Throw_.Id,
                    new VmInstr(_instrCodesDb.Throw_, Throw_)
                },
                {
                    _instrCodesDb.Ldvirtftn_.Id,
                    new VmInstr(_instrCodesDb.Ldvirtftn_, Ldvirtftn_)
                },
                {
                    _instrCodesDb.Mul_ovf_un_.Id,
                    new VmInstr(_instrCodesDb.Mul_ovf_un_, Mul_ovf_un_)
                },
                {
                    _instrCodesDb.Conv_ovf_i4_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i4_, Conv_ovf_i4_)
                },
                {
                    _instrCodesDb.Ldloc_0_.Id,
                    new VmInstr(_instrCodesDb.Ldloc_0_, Ldloc_0_)
                },
                {
                    _instrCodesDb.Starg_.Id,
                    new VmInstr(_instrCodesDb.Starg_, Starg_)
                },
                {
                    _instrCodesDb.Stind_i1_.Id,
                    new VmInstr(_instrCodesDb.Stind_i1_, Stind_i1_)
                },
                {
                    _instrCodesDb.Ldind_i2_.Id,
                    new VmInstr(_instrCodesDb.Ldind_i2_, Ldind_i2_)
                },
                {
                    _instrCodesDb.And_.Id,
                    new VmInstr(_instrCodesDb.And_, And_)
                },
                {
                    _instrCodesDb.Ldc_i4_6_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_6_, Ldc_i4_6_)
                },
                {
                    _instrCodesDb.Nop_.Id,
                    new VmInstr(_instrCodesDb.Nop_, Nop_)
                },
                {
                    _instrCodesDb.Ldind_i4_.Id,
                    new VmInstr(_instrCodesDb.Ldind_i4_, Ldind_i4_)
                },
                {
                    _instrCodesDb.Dup_.Id,
                    new VmInstr(_instrCodesDb.Dup_, Dup_)
                },
                {
                    _instrCodesDb.Mul_.Id,
                    new VmInstr(_instrCodesDb.Mul_, Mul_)
                },
                {
                    _instrCodesDb.Stloc_2_.Id,
                    new VmInstr(_instrCodesDb.Stloc_2_, Stloc_2_)
                },
                {
                    _instrCodesDb.Or_.Id,
                    new VmInstr(_instrCodesDb.Or_, Or_)
                },
                {
                    _instrCodesDb.Conv_u8_.Id,
                    new VmInstr(_instrCodesDb.Conv_u8_, Conv_u8_)
                },
                {
                    _instrCodesDb.Conv_ovf_u1_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u1_, Conv_ovf_u1_)
                },
                {
                    _instrCodesDb.Sub_ovf_.Id,
                    new VmInstr(_instrCodesDb.Sub_ovf_, Sub_ovf_)
                },
                {
                    _instrCodesDb.Conv_ovf_u1_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u1_un_, Conv_ovf_u1_un_)
                },
                {
                    _instrCodesDb.Ldelem_r4_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_r4_, Ldelem_r4_)
                },
                {
                    _instrCodesDb.Conv_r8_.Id,
                    new VmInstr(_instrCodesDb.Conv_r8_, Conv_r8_)
                },
                {
                    _instrCodesDb.Stloc_0_.Id,
                    new VmInstr(_instrCodesDb.Stloc_0_, Stloc_0_)
                },
                {
                    _instrCodesDb.Conv_ovf_u8_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u8_, Conv_ovf_u8_)
                },
                {
                    _instrCodesDb.Brfalse_.Id,
                    new VmInstr(_instrCodesDb.Brfalse_, Brfalse_)
                },
                {
                    _instrCodesDb.Ldarg_3_.Id,
                    new VmInstr(_instrCodesDb.Ldarg_3_, Ldarg_3_)
                },
                {
                    _instrCodesDb.Ldarg_.Id,
                    new VmInstr(_instrCodesDb.Ldarg_, Ldarg_)
                },
                {
                    _instrCodesDb.Ldc_r4_.Id,
                    new VmInstr(_instrCodesDb.Ldc_r4_, Ldc_r4_)
                },
                {
                    _instrCodesDb.Initobj_.Id,
                    new VmInstr(_instrCodesDb.Initobj_, Initobj_)
                },
                {
                    _instrCodesDb.Stloc_.Id,
                    new VmInstr(_instrCodesDb.Stloc_, Stloc_)
                },
                {
                    _instrCodesDb.Stind_i4_.Id,
                    new VmInstr(_instrCodesDb.Stind_i4_, Stind_i4_)
                },
                {
                    _instrCodesDb.Callvirt_.Id,
                    new VmInstr(_instrCodesDb.Callvirt_, Callvirt_)
                },
                {
                    _instrCodesDb.Stelem_i2_.Id,
                    new VmInstr(_instrCodesDb.Stelem_i2_, Stelem_i2_)
                },
                {
                    _instrCodesDb.Conv_ovf_u_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u_, Conv_ovf_u_)
                },
                {
                    _instrCodesDb.Cpobj_.Id,
                    new VmInstr(_instrCodesDb.Cpobj_, Cpobj_)
                },
                {
                    _instrCodesDb.Rem_.Id,
                    new VmInstr(_instrCodesDb.Rem_, Rem_)
                },
                {
                    _instrCodesDb.Stind_r8_.Id,
                    new VmInstr(_instrCodesDb.Stind_r8_, Stind_r8_)
                },
                {
                    _instrCodesDb.Stloc_1_.Id,
                    new VmInstr(_instrCodesDb.Stloc_1_, Stloc_1_)
                },
                {
                    _instrCodesDb.Conv_ovf_u4_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u4_, Conv_ovf_u4_)
                },
                {
                    _instrCodesDb.Ldc_i4_0_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_0_, Ldc_i4_0_)
                },
                {
                    _instrCodesDb.Stind_i_.Id,
                    new VmInstr(_instrCodesDb.Stind_i_, Stind_i_)
                },
                {
                    _instrCodesDb.Stelem_i8_.Id,
                    new VmInstr(_instrCodesDb.Stelem_i8_, Stelem_i8_)
                },
                {
                    _instrCodesDb.Ldelema_.Id,
                    new VmInstr(_instrCodesDb.Ldelema_, Ldelema_)
                },
                {
                    _instrCodesDb.Ldsflda_.Id,
                    new VmInstr(_instrCodesDb.Ldsflda_, Ldsflda_)
                },
                {
                    _instrCodesDb.Ldsfld_.Id,
                    new VmInstr(_instrCodesDb.Ldsfld_, Ldsfld_)
                },
                {
                    _instrCodesDb.Isinst_.Id,
                    new VmInstr(_instrCodesDb.Isinst_, Isinst_)
                },
                {
                    _instrCodesDb.Conv_i2_.Id,
                    new VmInstr(_instrCodesDb.Conv_i2_, Conv_i2_)
                },
                {
                    _instrCodesDb.Stelem_.Id,
                    new VmInstr(_instrCodesDb.Stelem_, Stelem_)
                },
                {
                    _instrCodesDb.Ldind_r8_.Id,
                    new VmInstr(_instrCodesDb.Ldind_r8_, Ldind_r8_)
                },
                {
                    _instrCodesDb.Ldc_r8_.Id,
                    new VmInstr(_instrCodesDb.Ldc_r8_, Ldc_r8_)
                },
                {
                    _instrCodesDb.Bge_.Id,
                    new VmInstr(_instrCodesDb.Bge_, Bge_)
                },
                {
                    _instrCodesDb.Ldind_i1_.Id,
                    new VmInstr(_instrCodesDb.Ldind_i1_, Ldind_i1_)
                },
                {
                    _instrCodesDb.Ldelem_u1_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_u1_, Ldelem_u1_)
                },
                {
                    _instrCodesDb.Ldstr_.Id,
                    new VmInstr(_instrCodesDb.Ldstr_, Ldstr_)
                },
                {
                    _instrCodesDb.Ldloca_s_.Id,
                    new VmInstr(_instrCodesDb.Ldloca_s_, Ldloca_s_)
                },
                {
                    _instrCodesDb.Ldelem_i8_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_i8_, Ldelem_i8_)
                },
                {
                    _instrCodesDb.Ldc_i4_8_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_8_, Ldc_i4_8_)
                },
                {
                    _instrCodesDb.Blt_.Id,
                    new VmInstr(_instrCodesDb.Blt_, Blt_)
                },
                {
                    _instrCodesDb.Unbox_.Id,
                    new VmInstr(_instrCodesDb.Unbox_, Unbox_)
                },
                {
                    _instrCodesDb.Bge_un_.Id,
                    new VmInstr(_instrCodesDb.Bge_un_, Bge_un_)
                },
                {
                    _instrCodesDb.Ldelem_u2_.Id,
                    new VmInstr(_instrCodesDb.Ldelem_u2_, Ldelem_u2_)
                },
                {
                    _instrCodesDb.Ldind_u2_.Id,
                    new VmInstr(_instrCodesDb.Ldind_u2_, Ldind_u2_)
                },
                {
                    _instrCodesDb.Sub_ovf_un_.Id,
                    new VmInstr(_instrCodesDb.Sub_ovf_un_, Sub_ovf_un_)
                },
                {
                    _instrCodesDb.Ldc_i4_4_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_4_, Ldc_i4_4_)
                },
                {
                    _instrCodesDb.Ldarg_0_.Id,
                    new VmInstr(_instrCodesDb.Ldarg_0_, Ldarg_0_)
                },
                {
                    _instrCodesDb.Rem_un_.Id,
                    new VmInstr(_instrCodesDb.Rem_un_, Rem_un_)
                },
                {
                    _instrCodesDb.Ldloc_1_.Id,
                    new VmInstr(_instrCodesDb.Ldloc_1_, Ldloc_1_)
                },
                {
                    _instrCodesDb.Bne_un_.Id,
                    new VmInstr(_instrCodesDb.Bne_un_, Bne_un_)
                },
                {
                    _instrCodesDb.Conv_ovf_i2_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_i2_un_, Conv_ovf_i2_un_)
                },
                {
                    _instrCodesDb.Ckfinite_.Id,
                    new VmInstr(_instrCodesDb.Ckfinite_, Ckfinite_)
                },
                {
                    _instrCodesDb.Ldobj_.Id,
                    new VmInstr(_instrCodesDb.Ldobj_, Ldobj_)
                },
                {
                    _instrCodesDb.Pop_.Id,
                    new VmInstr(_instrCodesDb.Pop_, Pop_)
                },
                {
                    _instrCodesDb.Constrained_.Id,
                    new VmInstr(_instrCodesDb.Constrained_, Constrained_)
                },
                {
                    _instrCodesDb.Ldc_i4_s_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_s_, Ldc_i4_s_)
                },
                {
                    _instrCodesDb.Ldloc_s_.Id,
                    new VmInstr(_instrCodesDb.Ldloc_s_, Ldloc_s_)
                },
                {
                    _instrCodesDb.Ldarg_2_.Id,
                    new VmInstr(_instrCodesDb.Ldarg_2_, Ldarg_2_)
                },
                {
                    _instrCodesDb.Ldarga_.Id,
                    new VmInstr(_instrCodesDb.Ldarga_, Ldarga_)
                },
                {
                    _instrCodesDb.Conv_i8_.Id,
                    new VmInstr(_instrCodesDb.Conv_i8_, Conv_i8_)
                },
                {
                    _instrCodesDb.Br_.Id,
                    new VmInstr(_instrCodesDb.Br_, Br_)
                },
                {
                    _instrCodesDb.Ldc_i4_3_.Id,
                    new VmInstr(_instrCodesDb.Ldc_i4_3_, Ldc_i4_3_)
                },
                {
                    _instrCodesDb.Mul_ovf_.Id,
                    new VmInstr(_instrCodesDb.Mul_ovf_, Mul_ovf_)
                },
                {
                    _instrCodesDb.Shl_.Id,
                    new VmInstr(_instrCodesDb.Shl_, Shl_)
                },
                {
                    _instrCodesDb.Castclass_.Id,
                    new VmInstr(_instrCodesDb.Castclass_, Castclass_)
                },
                {
                    _instrCodesDb.Jmp_.Id,
                    new VmInstr(_instrCodesDb.Jmp_, Jmp_)
                },
                {
                    _instrCodesDb.Beq_.Id,
                    new VmInstr(_instrCodesDb.Beq_, Beq_)
                },
                {
                    _instrCodesDb.Conv_r4_.Id,
                    new VmInstr(_instrCodesDb.Conv_r4_, Conv_r4_)
                },
                {
                    _instrCodesDb.Ble_.Id,
                    new VmInstr(_instrCodesDb.Ble_, Ble_)
                },
                {
                    _instrCodesDb.Conv_ovf_u2_un_.Id,
                    new VmInstr(_instrCodesDb.Conv_ovf_u2_un_, Conv_ovf_u2_un_)
                },
                {
                    _instrCodesDb.Call_.Id,
                    new VmInstr(_instrCodesDb.Call_, Call_)
                },
                {
                    _instrCodesDb.Not_.Id,
                    new VmInstr(_instrCodesDb.Not_, Not_)
                }
            };
        }
    }

    // Token: 0x02000042 RID: 66
    public sealed class LocalVarType // \u0008
    {
        // Token: 0x060002E4 RID: 740 RVA: 0x00013F08 File Offset: 0x00012108
        // Token: 0x060002E5 RID: 741 RVA: 0x00013F10 File Offset: 0x00012110
        // Token: 0x04000171 RID: 369
        public int TypeId /* \u0002 */ { get; set; }
    }

    // Token: 0x0200004D RID: 77
    public sealed class ArgTypeToOutput // \u000E
    {
        // Token: 0x06000321 RID: 801 RVA: 0x00014C74 File Offset: 0x00012E74
        // Token: 0x06000322 RID: 802 RVA: 0x00014C7C File Offset: 0x00012E7C
        // Token: 0x0400017C RID: 380
        public int TypeId /* \u0002 */ { get; set; }

        // Token: 0x06000323 RID: 803 RVA: 0x00014C88 File Offset: 0x00012E88
        // Token: 0x06000324 RID: 804 RVA: 0x00014C90 File Offset: 0x00012E90
        // Token: 0x0400017D RID: 381
        public bool IsOutput /* \u0003 */ { get; set; }
    }

    // Token: 0x0200005E RID: 94
    internal sealed class CatchBlock
    {
        // Token: 0x0600036B RID: 875 RVA: 0x00015AFC File Offset: 0x00013CFC
        // Token: 0x0600036C RID: 876 RVA: 0x00015B04 File Offset: 0x00013D04
        // Token: 0x04000189 RID: 393
        public byte Kind { get; set; }

        // Token: 0x0600036D RID: 877 RVA: 0x00015B10 File Offset: 0x00013D10
        // Token: 0x0600036E RID: 878 RVA: 0x00015B18 File Offset: 0x00013D18
        // Token: 0x0400018A RID: 394
        public int ExcTypeId { get; set; }

        // Token: 0x0600036F RID: 879 RVA: 0x00015B24 File Offset: 0x00013D24
        // Token: 0x06000370 RID: 880 RVA: 0x00015B2C File Offset: 0x00013D2C
        // Token: 0x0400018B RID: 395
        public uint PosKind4 { get; set; }

        // Token: 0x06000371 RID: 881 RVA: 0x00015B38 File Offset: 0x00013D38
        // Token: 0x06000372 RID: 882 RVA: 0x00015B40 File Offset: 0x00013D40
        // Token: 0x0400018C RID: 396
        public uint Start { get; set; }

        // Token: 0x06000373 RID: 883 RVA: 0x00015B4C File Offset: 0x00013D4C
        // Token: 0x06000374 RID: 884 RVA: 0x00015B54 File Offset: 0x00013D54
        // Token: 0x0400018D RID: 397
        public uint Pos { get; set; } // \u0005

        // Token: 0x06000375 RID: 885 RVA: 0x00015B60 File Offset: 0x00013D60
        // Token: 0x06000376 RID: 886 RVA: 0x00015B68 File Offset: 0x00013D68
        // Token: 0x0400018E RID: 398
        public uint Len { get; set; }
    }

    // Token: 0x02000049 RID: 73
    internal abstract class VmTokenInfo // \u0008\u2006
    {
        internal enum Kind : byte
        {
            Class0, Field1, Method2, String3, MethodRef4
        }

        // Token: 0x0600030D RID: 781
	    public abstract Kind TokenKind(); // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
    }

    // Token: 0x02000017 RID: 23
    internal sealed class UniversalTokenInfo // \u0003\u2008
    {
        // Token: 0x06000097 RID: 151 RVA: 0x00003E9C File Offset: 0x0000209C
        // Token: 0x06000098 RID: 152 RVA: 0x00003EA4 File Offset: 0x000020A4
        // Token: 0x04000020 RID: 32
        public byte IsVm { get; set; }

        // Token: 0x06000099 RID: 153 RVA: 0x00003EB0 File Offset: 0x000020B0
        // Token: 0x0600009A RID: 154 RVA: 0x00003EB8 File Offset: 0x000020B8
        // Token: 0x04000021 RID: 33
        public int MetadataToken { get; set; }

	    // Token: 0x0600009B RID: 155 RVA: 0x00003EC4 File Offset: 0x000020C4
	    // Token: 0x0600009C RID: 156 RVA: 0x00003ECC File Offset: 0x000020CC
	    // Token: 0x04000022 RID: 34
	    public VmTokenInfo VmToken { get; set; }
    }
    
    // Token: 0x02000016 RID: 22
    internal sealed class VmMethodRefTokenInfo : VmTokenInfo // \u0003\u2007
    {
        // Token: 0x06000091 RID: 145 RVA: 0x00003E68 File Offset: 0x00002068
        // Token: 0x06000092 RID: 146 RVA: 0x00003E70 File Offset: 0x00002070
        // Token: 0x0400001E RID: 30
        public int Flags { get; set; }

        // Token: 0x06000093 RID: 147 RVA: 0x00003E7C File Offset: 0x0000207C
        // Token: 0x06000094 RID: 148 RVA: 0x00003E84 File Offset: 0x00002084
        // Token: 0x0400001F RID: 31
        public int Pos { get; set; }

	    // Token: 0x06000095 RID: 149 RVA: 0x00003E90 File Offset: 0x00002090
	    public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
	    {
		    return Kind.MethodRef4;
	    }
    }

    // Token: 0x0200004A RID: 74
    internal sealed class VmMethodTokenInfo : VmTokenInfo // \u0008\u2007
    {
        // Token: 0x0600030F RID: 783 RVA: 0x00014BB0 File Offset: 0x00012DB0
        // Token: 0x06000310 RID: 784 RVA: 0x00014BB8 File Offset: 0x00012DB8
        // Token: 0x04000176 RID: 374
        public byte Flags { get; set; }

        // Token: 0x06000311 RID: 785 RVA: 0x00014BC4 File Offset: 0x00012DC4
        public bool IsStatic() // \u0002
        {
		    return (Flags & 2) > 0;
	    }

	    // Token: 0x06000312 RID: 786 RVA: 0x00014BD4 File Offset: 0x00012DD4
	    public bool IsGeneric() // \u0003
        {
		    return (Flags & 1) > 0;
	    }

        // Token: 0x06000313 RID: 787 RVA: 0x00014BE4 File Offset: 0x00012DE4
        // Token: 0x06000314 RID: 788 RVA: 0x00014BEC File Offset: 0x00012DEC
        // Token: 0x04000177 RID: 375
        public UniversalTokenInfo Class { get; set; }

        // Token: 0x06000315 RID: 789 RVA: 0x00014BF8 File Offset: 0x00012DF8
        // Token: 0x06000316 RID: 790 RVA: 0x00014C00 File Offset: 0x00012E00
        // Token: 0x04000178 RID: 376
        public string Name { get; set; }

        // Token: 0x06000317 RID: 791 RVA: 0x00014C0C File Offset: 0x00012E0C
        // Token: 0x06000318 RID: 792 RVA: 0x00014C14 File Offset: 0x00012E14
        // Token: 0x04000179 RID: 377
        public UniversalTokenInfo[] Parameters { get; set; }

        // Token: 0x06000319 RID: 793 RVA: 0x00014C20 File Offset: 0x00012E20
        // Token: 0x0600031A RID: 794 RVA: 0x00014C28 File Offset: 0x00012E28
        // Token: 0x0400017A RID: 378
        public UniversalTokenInfo[] GenericArguments { get; set; }

        // Token: 0x0600031B RID: 795 RVA: 0x00014C34 File Offset: 0x00012E34
        // Token: 0x0600031C RID: 796 RVA: 0x00014C3C File Offset: 0x00012E3C
        // Token: 0x0400017B RID: 379
        public UniversalTokenInfo ReturnType { get; set; }

        // Token: 0x0600031D RID: 797 RVA: 0x00014C48 File Offset: 0x00012E48
        public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
	    {
		    return Kind.Method2;
	    }
    }

    // Token: 0x02000056 RID: 86
    internal sealed class VmStringTokenInfo : VmTokenInfo // \u000E\u2007
    {
	    // Token: 0x06000343 RID: 835 RVA: 0x000153CC File Offset: 0x000135CC
	    // Token: 0x06000344 RID: 836 RVA: 0x000153D4 File Offset: 0x000135D4
	    // Token: 0x04000185 RID: 389
	    public string Value { get; set; }

	    // Token: 0x06000345 RID: 837 RVA: 0x000153E0 File Offset: 0x000135E0
	    public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
	    {
		    return Kind.String3;
	    }
    }

    // Token: 0x02000060 RID: 96
    internal sealed class VmFieldTokenInfo : VmTokenInfo // \u000F\u2006
    {
        // Token: 0x06000382 RID: 898 RVA: 0x00015C38 File Offset: 0x00013E38
        // Token: 0x06000383 RID: 899 RVA: 0x00015C40 File Offset: 0x00013E40
        // Token: 0x04000191 RID: 401
        public UniversalTokenInfo Class { get; set; }

        // Token: 0x06000384 RID: 900 RVA: 0x00015C4C File Offset: 0x00013E4C
        // Token: 0x06000385 RID: 901 RVA: 0x00015C54 File Offset: 0x00013E54
        // Token: 0x04000192 RID: 402
        public string Name { get; set; }

	    // Token: 0x06000386 RID: 902 RVA: 0x00015C60 File Offset: 0x00013E60
	    // Token: 0x06000387 RID: 903 RVA: 0x00015C68 File Offset: 0x00013E68
	    // Token: 0x04000193 RID: 403
	    public bool IsStatic { get; set; } 

	    // Token: 0x06000388 RID: 904 RVA: 0x00015C74 File Offset: 0x00013E74
	    public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
	    {
		    return Kind.Field1;
	    }
    }

    // Token: 0x02000061 RID: 97
    internal sealed class VmClassTokenInfo : VmTokenInfo // \u000F\u2007
    {
        // Token: 0x04000194 RID: 404
        // Token: 0x0600038A RID: 906 RVA: 0x00015C90 File Offset: 0x00013E90
        // Token: 0x0600038B RID: 907 RVA: 0x00015C98 File Offset: 0x00013E98
        public string ClassName { get; set; }

        // Token: 0x0600038C RID: 908 RVA: 0x00015CA4 File Offset: 0x00013EA4
        // Token: 0x04000195 RID: 405
        // Token: 0x0600038D RID: 909 RVA: 0x00015CAC File Offset: 0x00013EAC
        public bool IsOuterClassGeneric { get; set; }

        // Token: 0x0600038E RID: 910 RVA: 0x00015CB8 File Offset: 0x00013EB8
        // Token: 0x04000196 RID: 406
        // Token: 0x0600038F RID: 911 RVA: 0x00015CC0 File Offset: 0x00013EC0
        public bool IsGeneric { get; set; }

        // Token: 0x06000390 RID: 912 RVA: 0x00015CCC File Offset: 0x00013ECC
        // Token: 0x04000197 RID: 407
        // Token: 0x06000391 RID: 913 RVA: 0x00015CD4 File Offset: 0x00013ED4
        public UniversalTokenInfo[] GenericArguments { get; set; }

        // Token: 0x06000392 RID: 914 RVA: 0x00015CE0 File Offset: 0x00013EE0
        // Token: 0x04000198 RID: 408
        // Token: 0x06000393 RID: 915 RVA: 0x00015CE8 File Offset: 0x00013EE8
        public int OuterClassGenericClassIdx { get; set; } = -1;

        // Token: 0x06000394 RID: 916 RVA: 0x00015CF4 File Offset: 0x00013EF4
        // Token: 0x04000199 RID: 409
        // Token: 0x06000395 RID: 917 RVA: 0x00015CFC File Offset: 0x00013EFC
        public int OuterClassGenericMethodIdx { get; set; } = -1;

        // Token: 0x06000396 RID: 918 RVA: 0x00015D08 File Offset: 0x00013F08
        public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
	    {
		    return Kind.Class0;
	    }
    }
}