using System;
using System.Linq;
using System.Reflection;

namespace UnitTestProject.RefVm
{
    // Token: 0x02000059 RID: 89
    internal abstract class VariantBase // \u000F
    {
	    // Token: 0x0600034A RID: 842
	    public abstract object GetValueAbstract(); // \u000F\u2008\u2000\u2002\u200A\u0002

	    // Token: 0x0600034B RID: 843
	    public abstract void SetValueAbstract(object o); // \u000F\u2008\u2000\u2002\u200A\u0002

        // Token: 0x0600034C RID: 844
        public enum Vtc
        {
            Tc0VariantBaseHolder,
            Tc1Bool,
            Tc2Array,
            Tc3Method,
            Tc4FieldInfo,
            Tc5Enum,
            Tc6Char,
            Tc7Ulong,
            Tc8Float,
            Tc9Uint,
            Tc10Ushort,
            Tc11ValueType,
            Tc12Sbyte,
            Tc13UIntPtr,
            Tc14Byte,
            Tc15Short,
            Tc16String,
            Tc17IntPtr,
            Tc18Object,
            Tc19Int,
            Tc20MdArrayValue,
            Tc21Double,
            Tc22SdArrayValue,
            Tc23LocalsIdxHolder,
            Tc24Long
        }

        public abstract Vtc GetTypeCode(); // \u000F\u2008\u2000\u2002\u200A\u0002

	    // Token: 0x0600034D RID: 845
	    public abstract VariantBase CopyFrom(VariantBase t); // \u000F\u2008\u2000\u2002\u200A\u0002

        // Token: 0x0600034E RID: 846
        public abstract VariantBase Clone(); // \u000F\u2008\u2000\u2002\u200A\u0002

	    // Token: 0x0600034F RID: 847 RVA: 0x000153EC File Offset: 0x000135EC
	    public virtual bool IsAddr() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return false;
	    }

	    // Token: 0x06000350 RID: 848 RVA: 0x000153F0 File Offset: 0x000135F0
	    public Type GetVariantType() // \u0002
        {
		    return _type;
	    }

	    // Token: 0x06000351 RID: 849 RVA: 0x000153F8 File Offset: 0x000135F8
	    public void SetVariantType(Type val) // \u0002
        {
		    _type = val;
	    }

	    // Token: 0x04000186 RID: 390
        private Type _type; // \u0002

        // bug was fixed and unit tested (было превращение Enum в число без учета переполнения)
        public static long SignedLongFromEnum(EnumVariant src)
        {
            var val = src.GetValue();
            switch (Convert.GetTypeCode(val))
            {
                /*case TypeCode.SByte:
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:*/
                default:
                    return Convert.ToInt64(val);
                case TypeCode.Byte:
                case TypeCode.UInt16:
                case TypeCode.UInt32:
                case TypeCode.UInt64:
                    return (long)Convert.ToUInt64(val);
            }
        }

        public static VariantBase SignedVariantFromEnum(EnumVariant src)
        {
            var val = src.GetValue();
            switch (Convert.GetTypeCode(val))
            {
                case TypeCode.SByte:
                case TypeCode.Int16:
                case TypeCode.Int32:
                    var i = Convert.ToInt32(val);
                    var reti = new IntVariant();
                    reti.SetValue(i);
                    return reti;
                case TypeCode.Int64:
                    var l = Convert.ToInt64(val);
                    var retl = new LongVariant();
                    retl.SetValue(l);
                    return retl;
                case TypeCode.Byte:
                case TypeCode.UInt16:
                case TypeCode.UInt32:
                    var u = Convert.ToUInt32(val);
                    var retu = new IntVariant();
                    retu.SetValue((int)u);
                    return retu;
                //case TypeCode.UInt64:
                default:
                    var ul = Convert.ToUInt64(val);
                    var retul = new LongVariant();
                    retul.SetValue((long)ul);
                    return retul;
            }
        }
    }
    // Token: 0x02000003 RID: 3
    internal sealed class ArrayVariant : VariantBase // \u0002\u2000
    {
	    // Token: 0x06000009 RID: 9 RVA: 0x000021A8 File Offset: 0x000003A8
	    public Array GetValue() // \u0002
        {
		    return _value;
	    }

	    // Token: 0x0600000A RID: 10 RVA: 0x000021B0 File Offset: 0x000003B0
	    public void SetValue(Array val) // \u0002
        {
            _value = val;
	    }

	    // Token: 0x0600000B RID: 11 RVA: 0x000021BC File Offset: 0x000003BC
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    return GetValue();
	    }

	    // Token: 0x0600000C RID: 12 RVA: 0x000021C4 File Offset: 0x000003C4
	    public override void SetValueAbstract(object o) // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    SetValue((Array)o);
	    }

	    // Token: 0x0600000D RID: 13 RVA: 0x000021D4 File Offset: 0x000003D4
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    var ret = new ArrayVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetType());
		    return ret;
	    }

	    // Token: 0x0600000E RID: 14 RVA: 0x000021F4 File Offset: 0x000003F4
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    return Vtc.Tc2Array;
	    }

	    // Token: 0x0600000F RID: 15 RVA: 0x000021F8 File Offset: 0x000003F8
	    public override VariantBase CopyFrom(VariantBase src) // \u000F\u2008\u2000\u2002\u200A\u0002
        {
            SetVariantType(src.GetVariantType());
		    var num = src.GetTypeCode();
		    if (num != Vtc.Tc2Array)
		    {
			    if (num != Vtc.Tc18Object)
			    {
				    throw new ArgumentOutOfRangeException();
			    }
                SetValue((Array)((ObjectVariant)src).GetValue());
		    }
		    else
		    {
			    SetValue(((ArrayVariant)src).GetValue());
		    }
		    return this;
	    }

	    // Token: 0x04000001 RID: 1
	    private Array _value; // \u0002
    }

    // Token: 0x0200002B RID: 43
    internal sealed class ObjectVariant : VariantBase // \u0006\u2002
    {
	    // Token: 0x0600013E RID: 318 RVA: 0x00006458 File Offset: 0x00004658
	    public object GetValue() // \u0002
        {
		    return _value;
	    }

	    // Token: 0x0600013F RID: 319 RVA: 0x00006460 File Offset: 0x00004660
	    public void SetValue(object val) // \u0002
        {
		    _value = val;
	    }

	    // Token: 0x06000140 RID: 320 RVA: 0x0000646C File Offset: 0x0000466C
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x06000141 RID: 321 RVA: 0x00006474 File Offset: 0x00004674
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
            SetValue(val);
	    }

	    // Token: 0x06000142 RID: 322 RVA: 0x00006480 File Offset: 0x00004680
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    return Vtc.Tc18Object;
	    }

	    // Token: 0x06000143 RID: 323 RVA: 0x00006484 File Offset: 0x00004684
	    public override VariantBase CopyFrom(VariantBase src) // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    SetVariantType(src.GetVariantType());
		    SetValue(src.GetValueAbstract());
		    return this;
	    }

	    // Token: 0x06000144 RID: 324 RVA: 0x000064AC File Offset: 0x000046AC
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    var ret = new ObjectVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x0400004E RID: 78
	    private object _value;
    }

    // Token: 0x02000004 RID: 4
    internal sealed class ShortVariant : VariantBase
    {
	    // Token: 0x06000011 RID: 17 RVA: 0x00002260 File Offset: 0x00000460
	    public short GetValue() // \u0002
        {
		    return _value;
	    }

	    // Token: 0x06000012 RID: 18 RVA: 0x00002268 File Offset: 0x00000468
	    public void SetValue(short val) // \u0002
        {
		    _value = val;
	    }

	    // Token: 0x06000013 RID: 19 RVA: 0x00002274 File Offset: 0x00000474
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    return GetValue();
	    }

	    // Token: 0x06000014 RID: 20 RVA: 0x00002284 File Offset: 0x00000484
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    if (val is int)
		    {
			    SetValue((short)(int)val);
			    return;
		    }
		    if (val is long)
		    {
			    SetValue((short)(long)val);
			    return;
		    }
		    if (val is ushort)
		    {
			    SetValue((short)(ushort)val);
			    return;
		    }
		    if (val is uint)
		    {
			    SetValue((short)(uint)val);
			    return;
		    }
		    if (val is ulong)
		    {
			    SetValue((short)(ulong)val);
			    return;
		    }
		    if (val is float)
		    {
			    SetValue((short)(float)val);
			    return;
		    }
		    if (val is double)
		    {
			    SetValue((short)(double)val);
			    return;
		    }
		    SetValue(Convert.ToInt16(val));
	    }

	    // Token: 0x06000015 RID: 21 RVA: 0x00002338 File Offset: 0x00000538
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    var ret = new ShortVariant();
            ret.SetValue(_value);
            ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x06000016 RID: 22 RVA: 0x00002358 File Offset: 0x00000558
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    return Vtc.Tc15Short;
	    }

	    // Token: 0x06000017 RID: 23 RVA: 0x0000235C File Offset: 0x0000055C
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
        {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToByte(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToInt16(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((short)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((short)((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((short)((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue((short)((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue(((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue(((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((short)(int)((IntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToInt16(((ObjectVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((short)((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((short)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((short)((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x04000002 RID: 2
        private short _value; // \u0002
    }

    // Token: 0x02000005 RID: 5
    internal sealed class MethodVariant : VariantBase // \u0002\u2002
    {
	    // Token: 0x06000019 RID: 25 RVA: 0x00002538 File Offset: 0x00000738
	    public MethodBase GetValue() //\u0002
        {
		    return _value;
	    }

	    // Token: 0x0600001A RID: 26 RVA: 0x00002540 File Offset: 0x00000740
	    public void SetValue(MethodBase val) //\u0002
	    {
		    _value = val;
	    }

	    // Token: 0x0600001B RID: 27 RVA: 0x0000254C File Offset: 0x0000074C
	    public IntPtr GetFunctionPointer() // \u0002
	    {
		    return GetValue().MethodHandle.GetFunctionPointer();
	    }

	    // Token: 0x0600001C RID: 28 RVA: 0x0000256C File Offset: 0x0000076C
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x0600001D RID: 29 RVA: 0x00002574 File Offset: 0x00000774
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue((MethodBase)val);
	    }

	    // Token: 0x0600001E RID: 30 RVA: 0x00002584 File Offset: 0x00000784
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc3Method;
	    }

	    // Token: 0x0600001F RID: 31 RVA: 0x00002588 File Offset: 0x00000788
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    var num = val.GetTypeCode();
		    if (num == Vtc.Tc3Method)
		    {
			    SetValue(((MethodVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x06000020 RID: 32 RVA: 0x000025C8 File Offset: 0x000007C8
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new MethodVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x04000003 RID: 3
	    private MethodBase _value;
    }

    // Token: 0x02000008 RID: 8
    internal sealed class StringVariant : VariantBase // \u0002\u2005
    {
	    // Token: 0x0600002B RID: 43 RVA: 0x000026BC File Offset: 0x000008BC
	    public string GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x0600002C RID: 44 RVA: 0x000026C4 File Offset: 0x000008C4
	    public void SetValue(string val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x0600002D RID: 45 RVA: 0x000026D0 File Offset: 0x000008D0
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x0600002E RID: 46 RVA: 0x000026D8 File Offset: 0x000008D8
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue((string)val);
	    }

	    // Token: 0x0600002F RID: 47 RVA: 0x000026E8 File Offset: 0x000008E8
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc16String;
	    }

	    // Token: 0x06000030 RID: 48 RVA: 0x000026EC File Offset: 0x000008EC
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    var num = val.GetTypeCode();
		    if (num != Vtc.Tc16String)
		    {
			    if (num != Vtc.Tc18Object)
			    {
				    throw new ArgumentOutOfRangeException();
			    }
			    SetValue((string)((ObjectVariant)val).GetValue());
		    }
		    else
		    {
			    SetValue(((StringVariant)val).GetValue());
		    }
		    return this;
	    }

	    // Token: 0x06000031 RID: 49 RVA: 0x0000274C File Offset: 0x0000094C
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new StringVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x04000007 RID: 7
	    private string _value;
    }

    // Token: 0x0200000F RID: 15
    internal sealed class BoolVariant : VariantBase // \u0003\u2000
    {
	    // Token: 0x06000062 RID: 98 RVA: 0x00003470 File Offset: 0x00001670
	    public bool GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x06000063 RID: 99 RVA: 0x00003478 File Offset: 0x00001678
	    public void SetValue(bool val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x06000064 RID: 100 RVA: 0x00003484 File Offset: 0x00001684
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x06000065 RID: 101 RVA: 0x00003494 File Offset: 0x00001694
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue(Convert.ToBoolean(val));
	    }

	    // Token: 0x06000066 RID: 102 RVA: 0x000034A4 File Offset: 0x000016A4
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc1Bool;
	    }

	    // Token: 0x06000067 RID: 103 RVA: 0x000034A8 File Offset: 0x000016A8
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(((BoolVariant)val).GetValue());
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToBoolean(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue(Convert.ToBoolean(((UlongVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue(Convert.ToBoolean(((UintVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue(Convert.ToBoolean(((UshortVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue(Convert.ToBoolean(((SbyteVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue(Convert.ToBoolean(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(Convert.ToBoolean(((ByteVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc15Short:
			    SetValue(Convert.ToBoolean(((ShortVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue(Convert.ToBoolean(((IntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToBoolean(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue(Convert.ToBoolean(((IntVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc24Long:
			    SetValue(Convert.ToBoolean(((LongVariant)val).GetValue()));
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x06000068 RID: 104 RVA: 0x00003694 File Offset: 0x00001894
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new BoolVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x04000017 RID: 23
	    private bool _value;
    }

    // Token: 0x02000010 RID: 16
    internal sealed class IntVariant : VariantBase // \u0003\u2001
    {
	    // Token: 0x0600006A RID: 106 RVA: 0x000036BC File Offset: 0x000018BC
	    public int GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x0600006B RID: 107 RVA: 0x000036C4 File Offset: 0x000018C4
	    public void SetValue(int val) // \u0002
	    {

            _value = val;
	    }

	    // Token: 0x0600006C RID: 108 RVA: 0x000036D0 File Offset: 0x000018D0
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x0600006D RID: 109 RVA: 0x000036E0 File Offset: 0x000018E0
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    if (val is long)
		    {
			    SetValue((int)((long)val));
			    return;
		    }
		    if (val is ushort)
		    {
			    SetValue((ushort)val);
			    return;
		    }
		    if (val is uint)
		    {
			    SetValue((int)((uint)val));
			    return;
		    }
		    if (val is ulong)
		    {
			    SetValue((int)((ulong)val));
			    return;
		    }
		    if (val is float)
		    {
			    SetValue((int)((float)val));
			    return;
		    }
		    if (val is double)
		    {
			    SetValue((int)((double)val));
			    return;
		    }
		    SetValue(Convert.ToInt32(val));
	    }

	    // Token: 0x0600006E RID: 110 RVA: 0x0000377C File Offset: 0x0000197C
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new IntVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x0600006F RID: 111 RVA: 0x0000379C File Offset: 0x0000199C
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc19Int;
	    }

	    // Token: 0x06000070 RID: 112 RVA: 0x000037A0 File Offset: 0x000019A0
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToByte(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToInt32(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((int)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((int)((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((int)((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue(((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue(((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue((int)((uint)((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue(((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((int)((IntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToInt32(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue(((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((int)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue(Convert.ToInt32(((LongVariant)val).GetValue()));
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x04000018 RID: 24
	    private int _value;
    }

    // Token: 0x02000011 RID: 17
    internal sealed class IntPtrVariant : VariantBase // \u0003\u2002
    {
	    // Token: 0x06000072 RID: 114 RVA: 0x00003998 File Offset: 0x00001B98
	    public IntPtr GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x06000073 RID: 115 RVA: 0x000039A0 File Offset: 0x00001BA0
	    public void SetValue(IntPtr val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x06000074 RID: 116 RVA: 0x000039AC File Offset: 0x00001BAC
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new IntPtrVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x06000075 RID: 117 RVA: 0x000039CC File Offset: 0x00001BCC
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x06000076 RID: 118 RVA: 0x000039DC File Offset: 0x00001BDC
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue((IntPtr)val);
	    }

	    // Token: 0x06000077 RID: 119 RVA: 0x000039EC File Offset: 0x00001BEC
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc17IntPtr;
	    }

	    // Token: 0x06000078 RID: 120 RVA: 0x000039F0 File Offset: 0x00001BF0
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc3Method:
		    {
			    var mv = (MethodVariant)val;
			    SetValue(mv.GetFunctionPointer());
			    return this;
		    }
		    case Vtc.Tc5Enum:
			    SetValue(new IntPtr(Convert.ToInt64(((EnumVariant)val).GetValue())));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((IntPtr)((long)((UlongVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((IntPtr)((long)((FloatVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((IntPtr)((long)((UintVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue((IntPtr)((int)((UshortVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue((IntPtr)((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue((IntPtr)((int)((ByteVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc15Short:
			    SetValue((IntPtr)((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue(((IntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc18Object:
			    SetValue((IntPtr)((UIntPtrVariant)val).GetValue().ToUInt64());
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((IntPtr)((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((IntPtr)((long)((DoubleVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((IntPtr)((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x04000019 RID: 25
	    private IntPtr _value;
    }

    // Token: 0x02000014 RID: 20
    internal sealed class ValueTypeVariant : VariantBase // \u0003\u2005
    {
	    // Token: 0x06000086 RID: 134 RVA: 0x00003CF0 File Offset: 0x00001EF0
	    public ValueTypeVariant(object val)
	    {
		    if (val != null && !(val is ValueType))
		    {
			    throw new ArgumentException();
		    }
		    _value = val;
	    }

	    // Token: 0x06000087 RID: 135 RVA: 0x00003D10 File Offset: 0x00001F10
	    public object GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x06000088 RID: 136 RVA: 0x00003D18 File Offset: 0x00001F18
	    public void SetValue(object val) // \u0002
	    {
		    if (val != null && !(val is ValueType))
		    {
			    throw new ArgumentException();
		    }
		    _value = val;
	    }

	    // Token: 0x06000089 RID: 137 RVA: 0x00003D34 File Offset: 0x00001F34
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x0600008A RID: 138 RVA: 0x00003D3C File Offset: 0x00001F3C
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue(val);
	    }

	    // Token: 0x0600008B RID: 139 RVA: 0x00003D48 File Offset: 0x00001F48
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc11ValueType;
	    }

	    // Token: 0x0600008C RID: 140 RVA: 0x00003D4C File Offset: 0x00001F4C
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    var num = val.GetTypeCode();
		    if (num != Vtc.Tc11ValueType)
		    {
			    if (num != Vtc.Tc18Object)
			    {
				    SetValue(val.GetTypeCode());
			    }
			    else
			    {
				    SetValue(((UIntPtrVariant)val).GetValue());
			    }
		    }
		    else if (GetValue() != null)
		    {
			    var obj = ((ValueTypeVariant)val).GetValue();
			    var type = GetValue().GetType();
		        // ReSharper disable once UseMethodIsInstanceOfType
			    if (obj != null && !type.IsPrimitive && !type.IsEnum && type.IsAssignableFrom(obj.GetType()))
			    {
			        var fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.GetField | BindingFlags.SetField);
			        foreach (var fieldInfo in fields)
			        {
			            fieldInfo.SetValue(GetValue(), fieldInfo.GetValue(obj));
			        }
			    }
			    else
			    {
				    SetValue(obj);
			    }
		    }
		    else
		    {
			    SetValue(((ValueTypeVariant)val).GetValue());
		    }
		    return this;
	    }

	    // Token: 0x0600008D RID: 141 RVA: 0x00003E38 File Offset: 0x00002038
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new ValueTypeVariant(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x0400001D RID: 29
	    private object _value;
    }

    // Token: 0x0200001C RID: 28
    internal sealed class CharVariant : VariantBase // \u0005\u2000
    {
	    // Token: 0x060000A9 RID: 169 RVA: 0x000042D0 File Offset: 0x000024D0
	    public char GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x060000AA RID: 170 RVA: 0x000042D8 File Offset: 0x000024D8
	    public void SetValue(char val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x060000AB RID: 171 RVA: 0x000042E4 File Offset: 0x000024E4
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x060000AC RID: 172 RVA: 0x000042F4 File Offset: 0x000024F4
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue(Convert.ToChar(val));
	    }

	    // Token: 0x060000AD RID: 173 RVA: 0x00004304 File Offset: 0x00002504
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc6Char;
	    }

	    // Token: 0x060000AE RID: 174 RVA: 0x00004308 File Offset: 0x00002508
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToChar(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToChar(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc6Char:
			    SetValue(((CharVariant)val).GetValue());
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((char)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((char)((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue((char)((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue((char)((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue((char)((uint)((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue((char)((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue((char)((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((char)((int)((IntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToChar(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((char)((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((char)((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x060000AF RID: 175 RVA: 0x000044E0 File Offset: 0x000026E0
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new CharVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x04000026 RID: 38
	    private char _value;
    }

    // Token: 0x0200001D RID: 29
    internal sealed class LongVariant : VariantBase // \u0005\u2001
    {
	    // Token: 0x060000B1 RID: 177 RVA: 0x00004508 File Offset: 0x00002708
	    public long GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x060000B2 RID: 178 RVA: 0x00004510 File Offset: 0x00002710
	    public void SetValue(long val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x060000B3 RID: 179 RVA: 0x0000451C File Offset: 0x0000271C
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x060000B4 RID: 180 RVA: 0x0000452C File Offset: 0x0000272C
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    if (val is ulong)
		    {
			    SetValue((long)((ulong)val));
			    return;
		    }
		    if (val is float)
		    {
			    SetValue((long)((float)val));
			    return;
		    }
		    if (val is double)
		    {
			    SetValue((long)((double)val));
			    return;
		    }
		    SetValue(Convert.ToInt64(val));
	    }

	    // Token: 0x060000B5 RID: 181 RVA: 0x00004588 File Offset: 0x00002788
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new LongVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x060000B6 RID: 182 RVA: 0x000045A8 File Offset: 0x000027A8
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc24Long;
	    }

	    // Token: 0x060000B7 RID: 183 RVA: 0x000045AC File Offset: 0x000027AC
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToByte(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToInt64(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((long)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((long)((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue(((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue(((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue(((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue((long)((ulong)((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue(((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((long)((IntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToInt64(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue(((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((long)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue(((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x04000027 RID: 39
	    private long _value;
    }

    // Token: 0x0200001E RID: 30
    internal sealed class UIntPtrVariant : VariantBase // \u0005\u2002
    {
	    // Token: 0x060000B9 RID: 185 RVA: 0x000047A4 File Offset: 0x000029A4
	    public UIntPtr GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x060000BA RID: 186 RVA: 0x000047AC File Offset: 0x000029AC
	    public void SetValue(UIntPtr val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x060000BB RID: 187 RVA: 0x000047B8 File Offset: 0x000029B8
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new UIntPtrVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x060000BC RID: 188 RVA: 0x000047D8 File Offset: 0x000029D8
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x060000BD RID: 189 RVA: 0x000047E8 File Offset: 0x000029E8
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue((UIntPtr)val);
	    }

	    // Token: 0x060000BE RID: 190 RVA: 0x000047F8 File Offset: 0x000029F8
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc13UIntPtr;
	    }

	    // Token: 0x060000BF RID: 191 RVA: 0x000047FC File Offset: 0x000029FC
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc5Enum:
			    SetValue(new UIntPtr(Convert.ToUInt64(((EnumVariant)val).GetValue())));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((UIntPtr)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((UIntPtr)((ulong)((FloatVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((UIntPtr)((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue((UIntPtr)((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue(((UIntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue((UIntPtr)((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(((UIntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((UIntPtr)((ulong)((IntVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((UIntPtr)((ulong)((DoubleVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((UIntPtr)((ulong)((LongVariant)val).GetValue()));
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x04000028 RID: 40
	    private UIntPtr _value;
    }

    // Token: 0x02000029 RID: 41
    internal sealed class DoubleVariant : VariantBase // \u0006\u2000
    {
	    // Token: 0x0600012E RID: 302 RVA: 0x00005F98 File Offset: 0x00004198
	    public double GetValue()
	    {
		    return _value;
	    }

	    // Token: 0x0600012F RID: 303 RVA: 0x00005FA0 File Offset: 0x000041A0
	    public void SetValue(double val)
	    {
		    _value = val;
	    }

	    // Token: 0x06000130 RID: 304 RVA: 0x00005FAC File Offset: 0x000041AC
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x06000131 RID: 305 RVA: 0x00005FBC File Offset: 0x000041BC
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue(Convert.ToDouble(val));
	    }

	    // Token: 0x06000132 RID: 306 RVA: 0x00005FCC File Offset: 0x000041CC
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new DoubleVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x06000133 RID: 307 RVA: 0x00005FEC File Offset: 0x000041EC
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc21Double;
	    }

	    // Token: 0x06000134 RID: 308 RVA: 0x00005FF0 File Offset: 0x000041F0
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc7Ulong:
			    SetValue(((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue(((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue(((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue(((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue(((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue(((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc18Object:
			    SetValue((double)((UIntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc19Int:
			    SetValue(((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue(((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue(((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x0400004C RID: 76
	    private double _value;
    }

    // Token: 0x0200002A RID: 42
    internal sealed class UshortVariant : VariantBase // \u0006\u2001
    {
	    // Token: 0x06000136 RID: 310 RVA: 0x00006164 File Offset: 0x00004364
	    public ushort GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x06000137 RID: 311 RVA: 0x0000616C File Offset: 0x0000436C
	    public void SetValue(ushort val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x06000138 RID: 312 RVA: 0x00006178 File Offset: 0x00004378
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x06000139 RID: 313 RVA: 0x00006188 File Offset: 0x00004388
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    if (val is short)
		    {
			    SetValue((ushort)((short)val));
			    return;
		    }
		    if (val is int)
		    {
			    SetValue((ushort)((int)val));
			    return;
		    }
		    if (val is long)
		    {
			    SetValue((ushort)((long)val));
			    return;
		    }
		    if (val is uint)
		    {
			    SetValue((ushort)((uint)val));
			    return;
		    }
		    if (val is ulong)
		    {
			    SetValue((ushort)((ulong)val));
			    return;
		    }
		    if (val is float)
		    {
			    SetValue((ushort)((float)val));
			    return;
		    }
		    if (val is double)
		    {
			    SetValue((ushort)((double)val));
			    return;
		    }
		    SetValue(Convert.ToUInt16(val));
	    }

	    // Token: 0x0600013A RID: 314 RVA: 0x0000623C File Offset: 0x0000443C
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new UshortVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x0600013B RID: 315 RVA: 0x0000625C File Offset: 0x0000445C
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc10Ushort;
	    }

	    // Token: 0x0600013C RID: 316 RVA: 0x00006260 File Offset: 0x00004460
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToByte(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToUInt16(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((ushort)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((ushort)((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((ushort)((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue(((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue((ushort)((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue((ushort)((uint)((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue((ushort)((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((ushort)((int)((IntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToUInt16(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((ushort)((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((ushort)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((ushort)((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x0400004D RID: 77
	    private ushort _value;
    }

    // Token: 0x02000043 RID: 67
    internal sealed class EnumVariant : VariantBase // \u0008\u2000
    {
	    // Token: 0x060002E6 RID: 742 RVA: 0x00013F1C File Offset: 0x0001211C
	    public EnumVariant(Enum val)
	    {
		    if (val == null)
		    {
			    throw new ArgumentException();
		    }
		    _value = val;
	    }

	    // Token: 0x060002E7 RID: 743 RVA: 0x00013F34 File Offset: 0x00012134
	    public Enum GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x060002E8 RID: 744 RVA: 0x00013F3C File Offset: 0x0001213C
	    public void SetValue(Enum val) // \u0002
	    {
		    if (val == null)
		    {
			    throw new ArgumentException();
		    }
		    _value = val;
	    }

	    // Token: 0x060002E9 RID: 745 RVA: 0x00013F50 File Offset: 0x00012150
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x060002EA RID: 746 RVA: 0x00013F58 File Offset: 0x00012158
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue((Enum)Enum.Parse(GetValue().GetType(), val.ToString()));
	    }

	    // Token: 0x060002EB RID: 747 RVA: 0x00013F88 File Offset: 0x00012188
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc5Enum;
	    }

	    // Token: 0x060002EC RID: 748 RVA: 0x00013F8C File Offset: 0x0001218C
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    var num = val.GetTypeCode();
		    switch (num)
		    {
		    case Vtc.Tc5Enum:
		    {
			    var type = _value.GetType();
			    var @enum = ((EnumVariant)val).GetValue();
			    if (@enum.GetType() == type)
			    {
				    SetValue(@enum);
				    return this;
			    }
			    SetValue((Enum)Enum.ToObject(type, @enum));
			    return this;
		    }
		    case Vtc.Tc6Char:
		    case Vtc.Tc8Float:
		    case Vtc.Tc11ValueType:
		    case Vtc.Tc13UIntPtr:
		    case Vtc.Tc16String:
		    case Vtc.Tc17IntPtr:
			    break;
		    case Vtc.Tc7Ulong:
			    SetValue((Enum)Enum.ToObject(_value.GetType(), ((UlongVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((Enum)Enum.ToObject(_value.GetType(), ((UintVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue((Enum)Enum.ToObject(_value.GetType(), ((UshortVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue((Enum)Enum.ToObject(_value.GetType(), ((SbyteVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue((Enum)Enum.ToObject(_value.GetType(), ((ByteVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc15Short:
			    SetValue((Enum)Enum.ToObject(_value.GetType(), ((ShortVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc18Object:
			    SetValue((Enum)Enum.ToObject(_value.GetType(), ((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((Enum)Enum.ToObject(_value.GetType(), ((IntVariant)val).GetValue()));
			    return this;
		    default:
			    if (num == Vtc.Tc24Long)
			    {
				    SetValue((Enum)Enum.ToObject(_value.GetType(), ((LongVariant)val).GetValue()));
				    return this;
			    }
			    break;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x060002ED RID: 749 RVA: 0x000141C0 File Offset: 0x000123C0
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new EnumVariant(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x04000172 RID: 370
	    private Enum _value;
    }

    // Token: 0x02000044 RID: 68
    internal sealed class SbyteVariant : VariantBase // \u0008\u2001
    {
	    // Token: 0x060002EF RID: 751 RVA: 0x000141E4 File Offset: 0x000123E4
	    public sbyte GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x060002F0 RID: 752 RVA: 0x000141EC File Offset: 0x000123EC
	    public void SetValue(sbyte val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x060002F1 RID: 753 RVA: 0x000141F8 File Offset: 0x000123F8
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x060002F2 RID: 754 RVA: 0x00014208 File Offset: 0x00012408
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    if (val is byte)
		    {
			    SetValue((sbyte)((byte)val));
			    return;
		    }
		    if (val is short)
		    {
			    SetValue((sbyte)((short)val));
			    return;
		    }
		    if (val is int)
		    {
			    SetValue((sbyte)((int)val));
			    return;
		    }
		    if (val is long)
		    {
			    SetValue((sbyte)((long)val));
			    return;
		    }
		    if (val is ushort)
		    {
			    SetValue((sbyte)((ushort)val));
			    return;
		    }
		    if (val is uint)
		    {
			    SetValue((sbyte)((uint)val));
			    return;
		    }
		    if (val is ulong)
		    {
			    SetValue((sbyte)((ulong)val));
			    return;
		    }
		    if (val is float)
		    {
			    SetValue((sbyte)((float)val));
			    return;
		    }
		    if (val is double)
		    {
			    SetValue((sbyte)((double)val));
			    return;
		    }
		    SetValue(Convert.ToSByte(val));
	    }

	    // Token: 0x060002F3 RID: 755 RVA: 0x000142E8 File Offset: 0x000124E8
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new SbyteVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x060002F4 RID: 756 RVA: 0x00014308 File Offset: 0x00012508
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc12Sbyte;
	    }

	    // Token: 0x060002F5 RID: 757 RVA: 0x0001430C File Offset: 0x0001250C
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToSByte(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToSByte(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((sbyte)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((sbyte)((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((sbyte)((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue((sbyte)((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue(((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue((sbyte)((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue((sbyte)((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((sbyte)((int)((IntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToSByte(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((sbyte)((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((sbyte)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((sbyte)((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x04000173 RID: 371
	    private sbyte _value;
    }

    // Token: 0x0200004E RID: 78
    internal sealed class FloatVariant : VariantBase // \u000E\u2000
    {
	    // Token: 0x06000326 RID: 806 RVA: 0x00014CA4 File Offset: 0x00012EA4
	    public float GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x06000327 RID: 807 RVA: 0x00014CAC File Offset: 0x00012EAC
	    public void SetValue(float val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x06000328 RID: 808 RVA: 0x00014CB8 File Offset: 0x00012EB8
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x06000329 RID: 809 RVA: 0x00014CC8 File Offset: 0x00012EC8
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetValue(Convert.ToSingle(val));
	    }

	    // Token: 0x0600032A RID: 810 RVA: 0x00014CD8 File Offset: 0x00012ED8
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new FloatVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x0600032B RID: 811 RVA: 0x00014CF8 File Offset: 0x00012EF8
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc8Float;
	    }

	    // Token: 0x0600032C RID: 812 RVA: 0x00014CFC File Offset: 0x00012EFC
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToSingle(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue(((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue(((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue(((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue(((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue(((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue(((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc18Object:
			    SetValue((float)((UIntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc19Int:
			    SetValue(((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((float)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue(((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x0400017E RID: 382
	    private float _value;
    }

    // Token: 0x0200004F RID: 79
    internal sealed class UintVariant : VariantBase // \u000E\u2001
    {
	    // Token: 0x0600032E RID: 814 RVA: 0x00014E94 File Offset: 0x00013094
	    public uint GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x0600032F RID: 815 RVA: 0x00014E9C File Offset: 0x0001309C
	    public void SetValue(uint val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x06000330 RID: 816 RVA: 0x00014EA8 File Offset: 0x000130A8
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x06000331 RID: 817 RVA: 0x00014EB8 File Offset: 0x000130B8
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    if (val is short)
		    {
			    SetValue((uint)((short)val));
			    return;
		    }
		    if (val is int)
		    {
			    SetValue((uint)((int)val));
			    return;
		    }
		    if (val is long)
		    {
			    SetValue((uint)((long)val));
			    return;
		    }
		    if (val is ulong)
		    {
			    SetValue((uint)((ulong)val));
			    return;
		    }
		    if (val is float)
		    {
			    SetValue((uint)((float)val));
			    return;
		    }
		    if (val is double)
		    {
			    SetValue((uint)((double)val));
			    return;
		    }
		    SetValue(Convert.ToUInt32(val));
	    }

	    // Token: 0x06000332 RID: 818 RVA: 0x00014F54 File Offset: 0x00013154
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new UintVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x06000333 RID: 819 RVA: 0x00014F74 File Offset: 0x00013174
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc9Uint;
	    }

	    // Token: 0x06000334 RID: 820 RVA: 0x00014F78 File Offset: 0x00013178
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToByte(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToUInt32(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((uint)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((uint)((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue(((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue(((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue((uint)((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue((uint)((UIntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue((uint)((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((uint)((int)((IntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToUInt32(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((uint)((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((uint)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((uint)((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x0400017F RID: 383
	    private uint _value;
    }

    // Token: 0x0200005A RID: 90
    internal sealed class ByteVariant : VariantBase // \u000F\u2000
    {
	    // Token: 0x06000353 RID: 851 RVA: 0x0001540C File Offset: 0x0001360C
	    public byte GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x06000354 RID: 852 RVA: 0x00015414 File Offset: 0x00013614
	    public void SetValue(byte val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x06000355 RID: 853 RVA: 0x00015420 File Offset: 0x00013620
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new ByteVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x06000356 RID: 854 RVA: 0x00015440 File Offset: 0x00013640
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x06000357 RID: 855 RVA: 0x00015450 File Offset: 0x00013650
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    if (val is short)
		    {
			    SetValue((byte)((short)val));
			    return;
		    }
		    if (val is int)
		    {
			    SetValue((byte)((int)val));
			    return;
		    }
		    if (val is long)
		    {
			    SetValue((byte)((long)val));
			    return;
		    }
		    if (val is ushort)
		    {
			    SetValue((byte)((ushort)val));
			    return;
		    }
		    if (val is uint)
		    {
			    SetValue((byte)((uint)val));
			    return;
		    }
		    if (val is ulong)
		    {
			    SetValue((byte)((ulong)val));
			    return;
		    }
		    if (val is float)
		    {
			    SetValue((byte)((float)val));
			    return;
		    }
		    if (val is double)
		    {
			    SetValue((byte)((double)val));
			    return;
		    }
		    SetValue(Convert.ToByte(val));
	    }

	    // Token: 0x06000358 RID: 856 RVA: 0x0001551C File Offset: 0x0001371C
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc14Byte;
	    }

	    // Token: 0x06000359 RID: 857 RVA: 0x00015520 File Offset: 0x00013720
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToByte(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToByte(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue((byte)((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((byte)((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue((byte)((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue((byte)((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue((byte)((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue((byte)((uint)((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue((byte)((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((byte)((int)((IntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToByte(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((byte)((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((byte)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((byte)((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x04000187 RID: 391
	    private byte _value;
    }

    // Token: 0x0200005B RID: 91
    internal sealed class UlongVariant : VariantBase // \u000F\u2001
    {
	    // Token: 0x0600035B RID: 859 RVA: 0x00015718 File Offset: 0x00013918
	    public ulong GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x0600035C RID: 860 RVA: 0x00015720 File Offset: 0x00013920
	    public void SetValue(ulong val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x0600035D RID: 861 RVA: 0x0001572C File Offset: 0x0001392C
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetValue();
	    }

	    // Token: 0x0600035E RID: 862 RVA: 0x0001573C File Offset: 0x0001393C
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    if (val is short)
		    {
			    SetValue((ulong)(short)val);
			    return;
		    }
		    if (val is int)
		    {
			    SetValue((ulong)(int)val);
			    return;
		    }
		    if (val is long)
		    {
			    SetValue((ulong)((long)val));
			    return;
		    }
		    if (val is float)
		    {
			    SetValue((ulong)((float)val));
			    return;
		    }
		    if (val is double)
		    {
			    SetValue((ulong)((double)val));
			    return;
		    }
		    SetValue(Convert.ToUInt64(val));
	    }

	    // Token: 0x0600035F RID: 863 RVA: 0x000157C4 File Offset: 0x000139C4
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new UlongVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x06000360 RID: 864 RVA: 0x000157E4 File Offset: 0x000139E4
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc7Ulong;
	    }

	    // Token: 0x06000361 RID: 865 RVA: 0x000157E8 File Offset: 0x000139E8
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    switch (val.GetTypeCode())
		    {
		    case Vtc.Tc1Bool:
			    SetValue(Convert.ToByte(((BoolVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc5Enum:
			    SetValue(Convert.ToUInt64(((EnumVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc7Ulong:
			    SetValue(((UlongVariant)val).GetValue());
			    return this;
		    case Vtc.Tc8Float:
			    SetValue((ulong)((FloatVariant)val).GetValue());
			    return this;
		    case Vtc.Tc9Uint:
			    SetValue(((UintVariant)val).GetValue());
			    return this;
		    case Vtc.Tc10Ushort:
			    SetValue(((UshortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc12Sbyte:
			    SetValue((ulong)((SbyteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc13UIntPtr:
			    SetValue((ulong)((UIntPtrVariant)val).GetValue());
			    return this;
		    case Vtc.Tc14Byte:
			    SetValue(((ByteVariant)val).GetValue());
			    return this;
		    case Vtc.Tc15Short:
			    SetValue((ulong)((ShortVariant)val).GetValue());
			    return this;
		    case Vtc.Tc17IntPtr:
			    SetValue((ulong)((long)((IntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc18Object:
			    SetValue(Convert.ToUInt64(((UIntPtrVariant)val).GetValue()));
			    return this;
		    case Vtc.Tc19Int:
			    SetValue((ulong)((IntVariant)val).GetValue());
			    return this;
		    case Vtc.Tc21Double:
			    SetValue((ulong)((DoubleVariant)val).GetValue());
			    return this;
		    case Vtc.Tc24Long:
			    SetValue((ulong)((LongVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x04000188 RID: 392
	    private ulong _value;
    }

    // Token: 0x0200005C RID: 92
    internal abstract class ReferenceVariantBase : VariantBase // \u000F\u2002
    {
	    // Token: 0x06000363 RID: 867 RVA: 0x000159E0 File Offset: 0x00013BE0
	    public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    throw new InvalidOperationException();
	    }

	    // Token: 0x06000364 RID: 868 RVA: 0x000159E8 File Offset: 0x00013BE8
	    public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    throw new InvalidOperationException();
	    }

	    // Token: 0x06000365 RID: 869 RVA: 0x000159F0 File Offset: 0x00013BF0
	    public override bool IsAddr() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return true;
	    }
    }

    // Token: 0x02000007 RID: 7
    internal sealed class FieldInfoVariant : ReferenceVariantBase // \u0002\u2004
    {
	    // Token: 0x06000023 RID: 35 RVA: 0x00002600 File Offset: 0x00000800
	    public object GetObject() // \u0002
	    {
		    return _obj;
	    }

	    // Token: 0x06000024 RID: 36 RVA: 0x00002608 File Offset: 0x00000808
	    public void SetObject(object val) // \u0002
	    {
		    _obj = val;
	    }

	    // Token: 0x06000025 RID: 37 RVA: 0x00002614 File Offset: 0x00000814
	    public FieldInfo GetValue() // \u0002
	    {
		    return _field;
	    }

	    // Token: 0x06000026 RID: 38 RVA: 0x0000261C File Offset: 0x0000081C
	    public void SetValue(FieldInfo val) // \u0002
	    {
		    _field = val;
	    }

	    // Token: 0x06000027 RID: 39 RVA: 0x00002628 File Offset: 0x00000828
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc4FieldInfo;
	    }

	    // Token: 0x06000028 RID: 40 RVA: 0x0000262C File Offset: 0x0000082C
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    var num = val.GetTypeCode();
		    if (num == Vtc.Tc4FieldInfo)
		    {
			    SetObject(((FieldInfoVariant)val).GetObject());
			    SetValue(((FieldInfoVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x06000029 RID: 41 RVA: 0x0000267C File Offset: 0x0000087C
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new FieldInfoVariant();
		    ret.SetObject(_obj);
		    ret.SetValue(_field);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x04000005 RID: 5
	    private object _obj; // \u0002

	    // Token: 0x04000006 RID: 6
        private FieldInfo _field; // \u0003
    }

    // Token: 0x02000012 RID: 18
    internal sealed class VariantBaseHolder : ReferenceVariantBase // \u0003\u2003
    {
	    // Token: 0x0600007A RID: 122 RVA: 0x00003BF0 File Offset: 0x00001DF0
	    public VariantBase GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x0600007B RID: 123 RVA: 0x00003BF8 File Offset: 0x00001DF8
	    public void SetValue(VariantBase val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x0600007C RID: 124 RVA: 0x00003C04 File Offset: 0x00001E04
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc0VariantBaseHolder;
	    }

	    // Token: 0x0600007D RID: 125 RVA: 0x00003C08 File Offset: 0x00001E08
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    if (val.GetTypeCode() == Vtc.Tc0VariantBaseHolder)
		    {
			    SetValue(((VariantBaseHolder)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x0600007E RID: 126 RVA: 0x00003C48 File Offset: 0x00001E48
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new VariantBaseHolder();
		    ret.SetValue(GetValue());
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x0400001A RID: 26
	    private VariantBase _value;
    }

    // Token: 0x02000020 RID: 32
    internal sealed class LocalsIdxHolderVariant : ReferenceVariantBase // \u0005\u2004
    {
	    // Token: 0x060000C6 RID: 198 RVA: 0x000049A8 File Offset: 0x00002BA8
	    public int GetValue() // \u0002
	    {
		    return _value;
	    }

	    // Token: 0x060000C7 RID: 199 RVA: 0x000049B0 File Offset: 0x00002BB0
	    public void SetValue(int val) // \u0002
	    {
		    _value = val;
	    }

	    // Token: 0x060000C8 RID: 200 RVA: 0x000049BC File Offset: 0x00002BBC
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc23LocalsIdxHolder;
	    }

	    // Token: 0x060000C9 RID: 201 RVA: 0x000049C0 File Offset: 0x00002BC0
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    var num = val.GetTypeCode();
		    if (num == Vtc.Tc23LocalsIdxHolder)
		    {
			    SetValue(((LocalsIdxHolderVariant)val).GetValue());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x060000CA RID: 202 RVA: 0x00004A00 File Offset: 0x00002C00
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new LocalsIdxHolderVariant();
		    ret.SetValue(_value);
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x04000029 RID: 41
	    private int _value;
    }

    // Token: 0x02000046 RID: 70
    internal abstract class ArrayValueVariantBase : ReferenceVariantBase // \u0008\u2003
    {
	    // Token: 0x060002F9 RID: 761 RVA: 0x00014788 File Offset: 0x00012988
	    public Type GetHeldType() // \u0002
	    {
		    return _type;
	    }

	    // Token: 0x060002FA RID: 762 RVA: 0x00014790 File Offset: 0x00012990
	    public void SetHeldType(Type val) // \u0002
	    {
		    _type = val;
	    }

	    // Token: 0x060002FB RID: 763
	    public abstract object GetValue(); // \u0008\u2003\u2008\u2000\u2002\u200A\u0002

	    // Token: 0x060002FC RID: 764
	    public abstract void SetValue(object val); // \u0008\u2003\u2008\u2000\u2002\u200A\u0002

	    // Token: 0x060002FD RID: 765
	    public abstract bool IsEqual(ArrayValueVariantBase val); // \u0008\u2003\u2008\u2000\u2002\u200A\u0002

	    // Token: 0x04000174 RID: 372
	    private Type _type;
    }

    // Token: 0x02000053 RID: 83
    internal static class IntArrayComparison // \u000E\u2004
    {
	    // Token: 0x06000340 RID: 832 RVA: 0x00015294 File Offset: 0x00013494
	    public static bool Execute(int[] a1, int[] a2) // \u0002
	    {
		    if (a1 == a2)
		    {
			    return true;
		    }
		    if (a1 == null || a2 == null)
		    {
			    return false;
		    }
		    if (a1.Length != a2.Length)
		    {
			    return false;
		    }
	        return !a1.Where((t, i) => t != a2[i]).Any();
	    }
    }

    // Token: 0x0200002D RID: 45
    internal sealed class MdArrayValueVariant : ArrayValueVariantBase // \u0006\u2004
    {
	    // Token: 0x0600014F RID: 335 RVA: 0x000065AC File Offset: 0x000047AC
	    public Array GetArray() // \u0002
	    {
		    return _array;
	    }

	    // Token: 0x06000150 RID: 336 RVA: 0x000065B4 File Offset: 0x000047B4
	    public void SetArray(Array val) // \u0002
	    {
		    _array = val;
	    }

	    // Token: 0x06000151 RID: 337 RVA: 0x000065C0 File Offset: 0x000047C0
	    public int[] GetIndexes() // \u0002
	    {
		    return _indexes;
	    }

	    // Token: 0x06000152 RID: 338 RVA: 0x000065C8 File Offset: 0x000047C8
	    public void SetIndexes(int[] val) // \u0002
	    {
		    _indexes = val;
	    }

	    // Token: 0x06000153 RID: 339 RVA: 0x000065D4 File Offset: 0x000047D4
	    public override object GetValue() // \u0008\u2003\u2008\u2000\u2002\u200A\u0002
	    {
		    return GetArray().GetValue(GetIndexes());
	    }

	    // Token: 0x06000154 RID: 340 RVA: 0x000065E8 File Offset: 0x000047E8
	    public override void SetValue(object val) // \u0008\u2003\u2008\u2000\u2002\u200A\u0002
	    {
		    GetArray().SetValue(val, GetIndexes());
	    }

	    // Token: 0x06000155 RID: 341 RVA: 0x000065FC File Offset: 0x000047FC
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new MdArrayValueVariant();
		    ret.SetArray(GetArray());
		    ret.SetIndexes(GetIndexes());
		    ret.SetHeldType(GetHeldType());
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x06000156 RID: 342 RVA: 0x00006640 File Offset: 0x00004840
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc20MdArrayValue;
	    }

	    // Token: 0x06000157 RID: 343 RVA: 0x00006644 File Offset: 0x00004844
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    var num = val.GetTypeCode();
		    if (num == Vtc.Tc20MdArrayValue)
		    {
			    var src = (MdArrayValueVariant)val;
			    SetArray(src.GetArray());
			    SetIndexes(src.GetIndexes());
			    SetHeldType(src.GetHeldType());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x06000158 RID: 344 RVA: 0x000066A0 File Offset: 0x000048A0
	    public override bool IsEqual(ArrayValueVariantBase val) // \u0008\u2003\u2008\u2000\u2002\u200A\u0002
	    {
		    var peer = (MdArrayValueVariant)val;
		    return GetArray() == peer.GetArray() && IntArrayComparison.Execute(GetIndexes(), peer.GetIndexes());
	    }

	    // Token: 0x04000050 RID: 80
	    private Array _array; // \u0002

	    // Token: 0x04000051 RID: 81
	    private int[] _indexes; // \u0003
    }

    // Token: 0x02000052 RID: 82
    internal sealed class SdArrayValueVariant : ArrayValueVariantBase // \u000E\u2003
    {
	    // Token: 0x06000336 RID: 822 RVA: 0x0001516C File Offset: 0x0001336C
	    public Array GetArray() // \u0002
	    {
		    return _array;
	    }

	    // Token: 0x06000337 RID: 823 RVA: 0x00015174 File Offset: 0x00013374
	    public void SetArray(Array val) // \u0002
	    {
		    _array = val;
	    }

	    // Token: 0x06000338 RID: 824 RVA: 0x00015180 File Offset: 0x00013380
	    public long GetIndex() // \u0002
	    {
		    return _index;
	    }

	    // Token: 0x06000339 RID: 825 RVA: 0x00015188 File Offset: 0x00013388
	    public void SetIndex(long idx) // \u0002
	    {
		    _index = idx;
	    }

	    // Token: 0x0600033A RID: 826 RVA: 0x00015194 File Offset: 0x00013394
	    public override object GetValue() // \u0008\u2003\u2008\u2000\u2002\u200A\u0002
	    {
		    return _array.GetValue(_index);
	    }

	    // Token: 0x0600033B RID: 827 RVA: 0x000151A8 File Offset: 0x000133A8
	    public override void SetValue(object val) // \u0008\u2003\u2008\u2000\u2002\u200A\u0002
	    {
		    _array.SetValue(val, _index);
	    }

	    // Token: 0x0600033C RID: 828 RVA: 0x000151BC File Offset: 0x000133BC
	    public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    return Vtc.Tc22SdArrayValue;
	    }

	    // Token: 0x0600033D RID: 829 RVA: 0x000151C0 File Offset: 0x000133C0
	    public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    SetVariantType(val.GetVariantType());
		    var num = val.GetTypeCode();
		    if (num == Vtc.Tc22SdArrayValue)
		    {
			    var src = (SdArrayValueVariant)val;
			    SetArray(src.GetArray());
			    SetIndex(src.GetIndex());
			    SetHeldType(src.GetHeldType());
			    return this;
		    }
		    throw new ArgumentOutOfRangeException();
	    }

	    // Token: 0x0600033E RID: 830 RVA: 0x0001521C File Offset: 0x0001341C
	    public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002
	    {
		    var ret = new SdArrayValueVariant();
		    ret.SetArray(_array);
		    ret.SetIndex(_index);
		    ret.SetHeldType(GetHeldType());
		    ret.SetVariantType(GetVariantType());
		    return ret;
	    }

	    // Token: 0x0600033F RID: 831 RVA: 0x00015260 File Offset: 0x00013460
	    public override bool IsEqual(ArrayValueVariantBase val) // \u0008\u2003\u2008\u2000\u2002\u200A\u0002
	    {
		    var peer = (SdArrayValueVariant)val;
		    return GetIndex() == peer.GetIndex() && GetArray() == peer.GetArray();
	    }

	    // Token: 0x04000181 RID: 385
	    private Array _array; // \u0002

	    // Token: 0x04000182 RID: 386
	    private long _index; // \u0003
    }
}