using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Reflection;

namespace LitJson
{
	// Token: 0x02000239 RID: 569
	[DefaultMember("Item")]
	public class PKIBLOPMGPB : BPHPAPPIGNM, IEquatable<PKIBLOPMGPB>, IList, MLIKFIDAHCA, IEnumerable, ICollection, IDictionary
	{
		// Token: 0x06006A3C RID: 27196 RVA: 0x00229B78 File Offset: 0x00227D78
		string BPHPAPPIGNM.ToJson()
		{
			return this.BBNCDLJJGBK();
		}

		// Token: 0x170002EC RID: 748
		// (get) Token: 0x06006AAA RID: 27306 RVA: 0x0022ADBC File Offset: 0x00228FBC
		// (set) Token: 0x06006A3D RID: 27197 RVA: 0x00229B80 File Offset: 0x00227D80
		public PKIBLOPMGPB BCIENGLOHLG
		{
			get
			{
				this.CNMHHAEALLO();
				if (this.ANNBGHOPFBN == KDDIIDPALFG.Array)
				{
					return this.NHAPBKGMHLF[DMPGHHGCLFK];
				}
				return this.IHNIBHJCCKD[DMPGHHGCLFK].Value;
			}
			set
			{
				this.CNMHHAEALLO();
				if (this.ANNBGHOPFBN == KDDIIDPALFG.Array)
				{
					this.NHAPBKGMHLF[DMPGHHGCLFK] = value;
				}
				else
				{
					KeyValuePair<string, PKIBLOPMGPB> keyValuePair = this.IHNIBHJCCKD[DMPGHHGCLFK];
					KeyValuePair<string, PKIBLOPMGPB> keyValuePair2 = new KeyValuePair<string, PKIBLOPMGPB>(keyValuePair.Key, value);
					this.IHNIBHJCCKD[DMPGHHGCLFK] = keyValuePair2;
					this.AAMGBCBLIHD[keyValuePair.Key] = value;
				}
				this.LNIOBJAMBGA = null;
			}
		}

		// Token: 0x170002EB RID: 747
		// (get) Token: 0x06006A3E RID: 27198 RVA: 0x00229BF8 File Offset: 0x00227DF8
		// (set) Token: 0x06006A46 RID: 27206 RVA: 0x00229E2C File Offset: 0x0022802C
		public PKIBLOPMGPB BCIENGLOHLG
		{
			get
			{
				this.CPEIMGMEIAD();
				return this.AAMGBCBLIHD[AACNDIDHHKA];
			}
			set
			{
				this.CPEIMGMEIAD();
				KeyValuePair<string, PKIBLOPMGPB> keyValuePair = new KeyValuePair<string, PKIBLOPMGPB>(AACNDIDHHKA, value);
				if (this.AAMGBCBLIHD.ContainsKey(AACNDIDHHKA))
				{
					for (int i = 0; i < this.IHNIBHJCCKD.Count; i++)
					{
						if (this.IHNIBHJCCKD[i].Key == AACNDIDHHKA)
						{
							this.IHNIBHJCCKD[i] = keyValuePair;
							break;
						}
					}
				}
				else
				{
					this.IHNIBHJCCKD.Add(keyValuePair);
				}
				this.AAMGBCBLIHD[AACNDIDHHKA] = value;
				this.LNIOBJAMBGA = null;
			}
		}

		// Token: 0x06006A3F RID: 27199 RVA: 0x00229C10 File Offset: 0x00227E10
		public PKIBLOPMGPB(long DNIFODKLLOL)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Long;
			this.OAAPHEAHALE = DNIFODKLLOL;
		}

		// Token: 0x170002DE RID: 734
		// (get) Token: 0x06006A40 RID: 27200 RVA: 0x00229C28 File Offset: 0x00227E28
		bool IList.GEFOAPELHPL
		{
			get
			{
				return this.FCNKJHEJOMM().IsReadOnly;
			}
		}

		// Token: 0x06006A41 RID: 27201 RVA: 0x00229C38 File Offset: 0x00227E38
		public void BBNCDLJJGBK(CNIMHGBHCJJ OAEFNCEFHDC)
		{
			bool flag = OAEFNCEFHDC.MDNFOAAHGNL;
			OAEFNCEFHDC.MDNFOAAHGNL = false;
			PKIBLOPMGPB.JDFDJPHHHEI(this, OAEFNCEFHDC);
			OAEFNCEFHDC.MDNFOAAHGNL = flag;
		}

		// Token: 0x170002DF RID: 735
		object IDictionary.this[object ANOFFEKMECJ]
		{
			get
			{
				return this.CPEIMGMEIAD()[ANOFFEKMECJ];
			}
			set
			{
				if (!(ANOFFEKMECJ is string))
				{
					throw new ArgumentException("The key has to be a string");
				}
				PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(value);
				this.set_Item((string)ANOFFEKMECJ, pkiblopmgpb);
			}
		}

		// Token: 0x06006A43 RID: 27203 RVA: 0x00229C74 File Offset: 0x00227E74
		private bool CFMKEKANCEA()
		{
			return this.CPEIMGMEIAD().IsFixedSize;
		}

		// Token: 0x06006A44 RID: 27204 RVA: 0x00229C84 File Offset: 0x00227E84
		bool BPHPAPPIGNM.GetBoolean()
		{
			if (this.ANNBGHOPFBN != KDDIIDPALFG.Boolean)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a boolean");
			}
			return this.HABNDGFGENJ;
		}

		// Token: 0x06006A45 RID: 27205 RVA: 0x00229CA4 File Offset: 0x00227EA4
		private static void JDFDJPHHHEI(BPHPAPPIGNM INNGECIOBOO, CNIMHGBHCJJ OAEFNCEFHDC)
		{
			if (INNGECIOBOO == null)
			{
				OAEFNCEFHDC.OFBDEHOIODM(null);
				return;
			}
			if (INNGECIOBOO.COLBIKGMKPI)
			{
				OAEFNCEFHDC.OFBDEHOIODM(INNGECIOBOO.PGFLEFNNPJI());
				return;
			}
			if (INNGECIOBOO.PMDAOKLNCFK)
			{
				OAEFNCEFHDC.OFBDEHOIODM(INNGECIOBOO.DCCHBNKIEKC());
				return;
			}
			if (INNGECIOBOO.NGMHLHBLPGO)
			{
				OAEFNCEFHDC.OFBDEHOIODM(INNGECIOBOO.POEFKDECDMB());
				return;
			}
			if (INNGECIOBOO.HICOIGPOBKO)
			{
				OAEFNCEFHDC.OFBDEHOIODM(INNGECIOBOO.COIKFACHGHM());
				return;
			}
			if (INNGECIOBOO.BAHCBHINPAJ)
			{
				OAEFNCEFHDC.OFBDEHOIODM(INNGECIOBOO.MHEABAMHOIF());
				return;
			}
			if (INNGECIOBOO.BEJFNFJMPLC)
			{
				OAEFNCEFHDC.GCMEJMDKMOE();
				IEnumerator enumerator = INNGECIOBOO.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						object obj = enumerator.Current;
						PKIBLOPMGPB.JDFDJPHHHEI((PKIBLOPMGPB)obj, OAEFNCEFHDC);
					}
				}
				finally
				{
					IDisposable disposable;
					if ((disposable = enumerator as IDisposable) != null)
					{
						disposable.Dispose();
					}
				}
				OAEFNCEFHDC.FMHFFMJELPI();
				return;
			}
			if (INNGECIOBOO.IMPJCAGENLC)
			{
				OAEFNCEFHDC.AKDJLMKJDEO();
				IDictionaryEnumerator enumerator2 = INNGECIOBOO.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						object obj2 = enumerator2.Current;
						DictionaryEntry dictionaryEntry = (DictionaryEntry)obj2;
						OAEFNCEFHDC.GDGICAFIHPJ((string)dictionaryEntry.Key);
						PKIBLOPMGPB.JDFDJPHHHEI((PKIBLOPMGPB)dictionaryEntry.Value, OAEFNCEFHDC);
					}
				}
				finally
				{
					IDisposable disposable2;
					if ((disposable2 = enumerator2 as IDisposable) != null)
					{
						disposable2.Dispose();
					}
				}
				OAEFNCEFHDC.GKOILCKPCLJ();
				return;
			}
		}

		// Token: 0x170002E0 RID: 736
		// (get) Token: 0x06006A7D RID: 27261 RVA: 0x0022A7AC File Offset: 0x002289AC
		// (set) Token: 0x06006A47 RID: 27207 RVA: 0x00229ECC File Offset: 0x002280CC
		object MLIKFIDAHCA.LCGMFFOPNII
		{
			get
			{
				this.CPEIMGMEIAD();
				return this.IHNIBHJCCKD[LPFNGFHKNCE].Value;
			}
			set
			{
				this.CPEIMGMEIAD();
				PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(value);
				KeyValuePair<string, PKIBLOPMGPB> keyValuePair = this.IHNIBHJCCKD[LPFNGFHKNCE];
				this.AAMGBCBLIHD[keyValuePair.Key] = pkiblopmgpb;
				KeyValuePair<string, PKIBLOPMGPB> keyValuePair2 = new KeyValuePair<string, PKIBLOPMGPB>(keyValuePair.Key, pkiblopmgpb);
				this.IHNIBHJCCKD[LPFNGFHKNCE] = keyValuePair2;
			}
		}

		// Token: 0x170002CF RID: 719
		// (get) Token: 0x06006A48 RID: 27208 RVA: 0x00229F24 File Offset: 0x00228124
		int ICollection.DALPANGHKFE
		{
			get
			{
				return this.NKEHDKABAPE;
			}
		}

		// Token: 0x06006A4A RID: 27210 RVA: 0x00229F64 File Offset: 0x00228164
		public bool EAICFNADGPM()
		{
			return this.ANNBGHOPFBN == KDDIIDPALFG.Object;
		}

		// Token: 0x06006A4B RID: 27211 RVA: 0x00229F70 File Offset: 0x00228170
		public static double NPHAJOCKCNI(PKIBLOPMGPB AOAILGGFDHJ)
		{
			if (AOAILGGFDHJ.ANNBGHOPFBN != KDDIIDPALFG.Array)
			{
				throw new InvalidCastException("active_camera");
			}
			return AOAILGGFDHJ.MJEDFAGNCPL;
		}

		// Token: 0x06006A4C RID: 27212 RVA: 0x00229F90 File Offset: 0x00228190
		public PKIBLOPMGPB()
		{
		}

		// Token: 0x170002D7 RID: 727
		// (get) Token: 0x06006A4D RID: 27213 RVA: 0x00229F98 File Offset: 0x00228198
		bool BPHPAPPIGNM.HMNKKJNCIOJ
		{
			get
			{
				return this.PMDAOKLNCFK;
			}
		}

		// Token: 0x06006A4E RID: 27214 RVA: 0x00229FA0 File Offset: 0x002281A0
		private string EKBINAPFBOO()
		{
			if (this.ANNBGHOPFBN != KDDIIDPALFG.Object)
			{
				throw new InvalidOperationException("GoogleAnalyticsRequestCache");
			}
			return this.ENIHMLHDOAB;
		}

		// Token: 0x06006A4F RID: 27215 RVA: 0x00229FC0 File Offset: 0x002281C0
		public static double HOOFJGAAMKN(PKIBLOPMGPB AOAILGGFDHJ)
		{
			if (AOAILGGFDHJ.ANNBGHOPFBN != KDDIIDPALFG.Double)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a double");
			}
			return AOAILGGFDHJ.MJEDFAGNCPL;
		}

		// Token: 0x170002E3 RID: 739
		// (get) Token: 0x06006A50 RID: 27216 RVA: 0x00229FE0 File Offset: 0x002281E0
		public bool BEJFNFJMPLC
		{
			get
			{
				return this.ANNBGHOPFBN == KDDIIDPALFG.Array;
			}
		}

		// Token: 0x06006A51 RID: 27217 RVA: 0x00229FEC File Offset: 0x002281EC
		public void NFGBPFHKLGF()
		{
			if (this.IMPJCAGENLC)
			{
				((IDictionary)this).Clear();
				return;
			}
			if (this.BEJFNFJMPLC)
			{
				((IList)this).Clear();
				return;
			}
		}

		// Token: 0x06006A52 RID: 27218 RVA: 0x0022A014 File Offset: 0x00228214
		bool IList.Contains(object NOBAPCOKFIL)
		{
			return this.FCNKJHEJOMM().Contains(NOBAPCOKFIL);
		}

		// Token: 0x170002D1 RID: 721
		// (get) Token: 0x06006A53 RID: 27219 RVA: 0x0022A024 File Offset: 0x00228224
		object ICollection.CACHOGFNMII
		{
			get
			{
				return this.CNMHHAEALLO().SyncRoot;
			}
		}

		// Token: 0x06006A54 RID: 27220 RVA: 0x0022A034 File Offset: 0x00228234
		public static bool JGIBOLFMHJM(PKIBLOPMGPB AOAILGGFDHJ)
		{
			if (AOAILGGFDHJ.ANNBGHOPFBN != KDDIIDPALFG.Boolean)
			{
				throw new InvalidCastException("ParseNegotiation");
			}
			return AOAILGGFDHJ.HABNDGFGENJ;
		}

		// Token: 0x06006A55 RID: 27221 RVA: 0x0022A054 File Offset: 0x00228254
		void IDictionary.Clear()
		{
			this.CPEIMGMEIAD().Clear();
			this.IHNIBHJCCKD.Clear();
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x06006A56 RID: 27222 RVA: 0x0022A074 File Offset: 0x00228274
		public void LLECKKMBPKO(KDDIIDPALFG ANNBGHOPFBN)
		{
			if (this.ANNBGHOPFBN == ANNBGHOPFBN)
			{
				return;
			}
			switch (ANNBGHOPFBN)
			{
			case KDDIIDPALFG.Object:
				this.AAMGBCBLIHD = new Dictionary<string, PKIBLOPMGPB>();
				this.IHNIBHJCCKD = new List<KeyValuePair<string, PKIBLOPMGPB>>();
				break;
			case KDDIIDPALFG.Array:
				this.NHAPBKGMHLF = new List<PKIBLOPMGPB>();
				break;
			case KDDIIDPALFG.String:
				this.ENIHMLHDOAB = null;
				break;
			case KDDIIDPALFG.Int:
				this.FEIPIFGKLFJ = 0;
				break;
			case KDDIIDPALFG.Long:
				this.OAAPHEAHALE = 0L;
				break;
			case KDDIIDPALFG.Double:
				this.MJEDFAGNCPL = 0.0;
				break;
			case KDDIIDPALFG.Boolean:
				this.HABNDGFGENJ = false;
				break;
			}
			this.ANNBGHOPFBN = ANNBGHOPFBN;
		}

		// Token: 0x170002E2 RID: 738
		// (get) Token: 0x06006A57 RID: 27223 RVA: 0x0022A138 File Offset: 0x00228338
		public int NKEHDKABAPE
		{
			get
			{
				return this.CNMHHAEALLO().Count;
			}
		}

		// Token: 0x06006A58 RID: 27224 RVA: 0x0022A148 File Offset: 0x00228348
		public PKIBLOPMGPB NEMPDIJDDGC(int DMPGHHGCLFK)
		{
			this.CNMHHAEALLO();
			if (this.ANNBGHOPFBN == KDDIIDPALFG.Boolean)
			{
				return this.NHAPBKGMHLF[DMPGHHGCLFK];
			}
			return this.IHNIBHJCCKD[DMPGHHGCLFK].Value;
		}

		// Token: 0x06006A59 RID: 27225 RVA: 0x0022A18C File Offset: 0x0022838C
		int IList.Add(object NOBAPCOKFIL)
		{
			return this.OPJKMCEACMD(NOBAPCOKFIL);
		}

		// Token: 0x06006A5A RID: 27226 RVA: 0x0022A198 File Offset: 0x00228398
		int BPHPAPPIGNM.GetInt()
		{
			if (this.ANNBGHOPFBN != KDDIIDPALFG.Int)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold an int");
			}
			return this.FEIPIFGKLFJ;
		}

		// Token: 0x06006A5B RID: 27227 RVA: 0x0022A1B8 File Offset: 0x002283B8
		private void FMPGLOHPIOH(object ANOFFEKMECJ, object NOBAPCOKFIL)
		{
			if (!(ANOFFEKMECJ is string))
			{
				throw new ArgumentException("x");
			}
			PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(NOBAPCOKFIL);
			this.set_Item((string)ANOFFEKMECJ, pkiblopmgpb);
		}

		// Token: 0x06006A5C RID: 27228 RVA: 0x0022A1F0 File Offset: 0x002283F0
		private static void AOKPDFBLGCN(BPHPAPPIGNM INNGECIOBOO, CNIMHGBHCJJ OAEFNCEFHDC)
		{
			if (INNGECIOBOO == null)
			{
				OAEFNCEFHDC.HDMPCODGKLG(null);
				return;
			}
			if (INNGECIOBOO.COLBIKGMKPI)
			{
				OAEFNCEFHDC.NAALHOIKGOJ(INNGECIOBOO.PGFLEFNNPJI());
				return;
			}
			if (INNGECIOBOO.PMDAOKLNCFK)
			{
				OAEFNCEFHDC.HOPGBNDIPBN(INNGECIOBOO.DCCHBNKIEKC());
				return;
			}
			if (INNGECIOBOO.NGMHLHBLPGO)
			{
				OAEFNCEFHDC.OFBDEHOIODM(INNGECIOBOO.POEFKDECDMB());
				return;
			}
			if (INNGECIOBOO.HICOIGPOBKO)
			{
				OAEFNCEFHDC.IMFCBKGHDJP(INNGECIOBOO.COIKFACHGHM());
				return;
			}
			if (INNGECIOBOO.BAHCBHINPAJ)
			{
				OAEFNCEFHDC.OFBDEHOIODM(INNGECIOBOO.MHEABAMHOIF());
				return;
			}
			if (INNGECIOBOO.BEJFNFJMPLC)
			{
				OAEFNCEFHDC.OFAKPIEGFGN();
				IEnumerator enumerator = INNGECIOBOO.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						object obj = enumerator.Current;
						PKIBLOPMGPB.JDFDJPHHHEI((PKIBLOPMGPB)obj, OAEFNCEFHDC);
					}
				}
				finally
				{
					IDisposable disposable;
					if ((disposable = enumerator as IDisposable) != null)
					{
						disposable.Dispose();
					}
				}
				OAEFNCEFHDC.GPKENCNOFLE();
				return;
			}
			if (INNGECIOBOO.IMPJCAGENLC)
			{
				OAEFNCEFHDC.AKDJLMKJDEO();
				IDictionaryEnumerator enumerator2 = INNGECIOBOO.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						object obj2 = enumerator2.Current;
						DictionaryEntry dictionaryEntry = (DictionaryEntry)obj2;
						OAEFNCEFHDC.PDMDKKNDFMH((string)dictionaryEntry.Key);
						PKIBLOPMGPB.JDFDJPHHHEI((PKIBLOPMGPB)dictionaryEntry.Value, OAEFNCEFHDC);
					}
				}
				finally
				{
					IDisposable disposable2;
					if ((disposable2 = enumerator2 as IDisposable) != null)
					{
						disposable2.Dispose();
					}
				}
				OAEFNCEFHDC.BPBFCDILODE();
				return;
			}
		}

		// Token: 0x170002D8 RID: 728
		// (get) Token: 0x06006A5D RID: 27229 RVA: 0x0022A378 File Offset: 0x00228578
		bool BPHPAPPIGNM.FKAPNAIDHDG
		{
			get
			{
				return this.NGMHLHBLPGO;
			}
		}

		// Token: 0x06006A5E RID: 27230 RVA: 0x0022A380 File Offset: 0x00228580
		void BPHPAPPIGNM.SetString(string APKGDFCHJOD)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.String;
			this.ENIHMLHDOAB = APKGDFCHJOD;
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x170002D5 RID: 725
		// (get) Token: 0x06006A5F RID: 27231 RVA: 0x0022A398 File Offset: 0x00228598
		ICollection IDictionary.HJGAEADPPLJ
		{
			get
			{
				this.CPEIMGMEIAD();
				IList<PKIBLOPMGPB> list = new List<PKIBLOPMGPB>();
				foreach (KeyValuePair<string, PKIBLOPMGPB> keyValuePair in this.IHNIBHJCCKD)
				{
					list.Add(keyValuePair.Value);
				}
				return (ICollection)list;
			}
		}

		// Token: 0x06006A60 RID: 27232 RVA: 0x0022A40C File Offset: 0x0022860C
		public static PKIBLOPMGPB EDHNDLCFIOL(string AOAILGGFDHJ)
		{
			return new PKIBLOPMGPB(AOAILGGFDHJ);
		}

		// Token: 0x06006A61 RID: 27233 RVA: 0x0022A414 File Offset: 0x00228614
		private IList FCNKJHEJOMM()
		{
			if (this.ANNBGHOPFBN == KDDIIDPALFG.Array)
			{
				return (IList)this.NHAPBKGMHLF;
			}
			if (this.ANNBGHOPFBN != KDDIIDPALFG.None)
			{
				throw new InvalidOperationException("Instance of JsonData is not a list");
			}
			this.ANNBGHOPFBN = KDDIIDPALFG.Array;
			this.NHAPBKGMHLF = new List<PKIBLOPMGPB>();
			return (IList)this.NHAPBKGMHLF;
		}

		// Token: 0x06006A62 RID: 27234 RVA: 0x0022A46C File Offset: 0x0022866C
		IEnumerator IEnumerable.GetEnumerator()
		{
			return this.CNMHHAEALLO().GetEnumerator();
		}

		// Token: 0x06006A63 RID: 27235 RVA: 0x0022A47C File Offset: 0x0022867C
		void IList.RemoveAt(int DMPGHHGCLFK)
		{
			this.FCNKJHEJOMM().RemoveAt(DMPGHHGCLFK);
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x170002D0 RID: 720
		// (get) Token: 0x06006A64 RID: 27236 RVA: 0x0022A494 File Offset: 0x00228694
		bool ICollection.PPKOKJAMNHO
		{
			get
			{
				return this.CNMHHAEALLO().IsSynchronized;
			}
		}

		// Token: 0x06006A65 RID: 27237 RVA: 0x0022A4A4 File Offset: 0x002286A4
		public PKIBLOPMGPB(int DNIFODKLLOL)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Int;
			this.FEIPIFGKLFJ = DNIFODKLLOL;
		}

		// Token: 0x06006A66 RID: 27238 RVA: 0x0022A4BC File Offset: 0x002286BC
		public int OPJKMCEACMD(object NOBAPCOKFIL)
		{
			PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(NOBAPCOKFIL);
			this.LNIOBJAMBGA = null;
			return this.FCNKJHEJOMM().Add(pkiblopmgpb);
		}

		// Token: 0x06006A67 RID: 27239 RVA: 0x0022A4E4 File Offset: 0x002286E4
		private void JELEEOKHGMP(int LPFNGFHKNCE, object NOBAPCOKFIL)
		{
			this.CPEIMGMEIAD();
			PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(NOBAPCOKFIL);
			KeyValuePair<string, PKIBLOPMGPB> keyValuePair = this.IHNIBHJCCKD[LPFNGFHKNCE];
			this.AAMGBCBLIHD[keyValuePair.Key] = pkiblopmgpb;
			KeyValuePair<string, PKIBLOPMGPB> keyValuePair2 = new KeyValuePair<string, PKIBLOPMGPB>(keyValuePair.Key, pkiblopmgpb);
			this.IHNIBHJCCKD[LPFNGFHKNCE] = keyValuePair2;
		}

		// Token: 0x06006A68 RID: 27240 RVA: 0x0022A53C File Offset: 0x0022873C
		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return ((MLIKFIDAHCA)this).GetEnumerator();
		}

		// Token: 0x170002DB RID: 731
		// (get) Token: 0x06006A69 RID: 27241 RVA: 0x0022A544 File Offset: 0x00228744
		bool BPHPAPPIGNM.NGNCEPEGKOH
		{
			get
			{
				return this.IMPJCAGENLC;
			}
		}

		// Token: 0x06006A6A RID: 27242 RVA: 0x0022A54C File Offset: 0x0022874C
		void IDictionary.Add(object ANOFFEKMECJ, object NOBAPCOKFIL)
		{
			PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(NOBAPCOKFIL);
			this.CPEIMGMEIAD().Add(ANOFFEKMECJ, pkiblopmgpb);
			KeyValuePair<string, PKIBLOPMGPB> keyValuePair = new KeyValuePair<string, PKIBLOPMGPB>((string)ANOFFEKMECJ, pkiblopmgpb);
			this.IHNIBHJCCKD.Add(keyValuePair);
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x170002D6 RID: 726
		// (get) Token: 0x06006A6B RID: 27243 RVA: 0x0022A590 File Offset: 0x00228790
		bool BPHPAPPIGNM.IMNNMPNCDPL
		{
			get
			{
				return this.BEJFNFJMPLC;
			}
		}

		// Token: 0x06006A6C RID: 27244 RVA: 0x0022A598 File Offset: 0x00228798
		void ICollection.CopyTo(Array GDLLJBOEGNF, int DMPGHHGCLFK)
		{
			this.CNMHHAEALLO().CopyTo(GDLLJBOEGNF, DMPGHHGCLFK);
		}

		// Token: 0x06006A6D RID: 27245 RVA: 0x0022A5A8 File Offset: 0x002287A8
		private bool NLNBJGGIKPK()
		{
			return this.NGMHLHBLPGO;
		}

		// Token: 0x06006A6E RID: 27246 RVA: 0x0022A5B0 File Offset: 0x002287B0
		void MLIKFIDAHCA.Insert(int LPFNGFHKNCE, object ANOFFEKMECJ, object NOBAPCOKFIL)
		{
			string text = (string)ANOFFEKMECJ;
			PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(NOBAPCOKFIL);
			this.set_Item(text, pkiblopmgpb);
			KeyValuePair<string, PKIBLOPMGPB> keyValuePair = new KeyValuePair<string, PKIBLOPMGPB>(text, pkiblopmgpb);
			this.IHNIBHJCCKD.Insert(LPFNGFHKNCE, keyValuePair);
		}

		// Token: 0x170002DA RID: 730
		// (get) Token: 0x06006A6F RID: 27247 RVA: 0x0022A5EC File Offset: 0x002287EC
		bool BPHPAPPIGNM.HBHEPIEICAN
		{
			get
			{
				return this.BAHCBHINPAJ;
			}
		}

		// Token: 0x06006A70 RID: 27248 RVA: 0x0022A5F4 File Offset: 0x002287F4
		void MLIKFIDAHCA.RemoveAt(int LPFNGFHKNCE)
		{
			this.CPEIMGMEIAD();
			this.AAMGBCBLIHD.Remove(this.IHNIBHJCCKD[LPFNGFHKNCE].Key);
			this.IHNIBHJCCKD.RemoveAt(LPFNGFHKNCE);
		}

		// Token: 0x06006A71 RID: 27249 RVA: 0x0022A634 File Offset: 0x00228834
		void BPHPAPPIGNM.SetDouble(double APKGDFCHJOD)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Double;
			this.MJEDFAGNCPL = APKGDFCHJOD;
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x170002E1 RID: 737
		object IList.this[int DMPGHHGCLFK]
		{
			get
			{
				return this.FCNKJHEJOMM()[DMPGHHGCLFK];
			}
			set
			{
				this.FCNKJHEJOMM();
				PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(value);
				this.set_Item(DMPGHHGCLFK, pkiblopmgpb);
			}
		}

		// Token: 0x06006A73 RID: 27251 RVA: 0x0022A670 File Offset: 0x00228870
		void BPHPAPPIGNM.ToJson(CNIMHGBHCJJ OAEFNCEFHDC)
		{
			this.BBNCDLJJGBK(OAEFNCEFHDC);
		}

		// Token: 0x06006A74 RID: 27252 RVA: 0x0022A67C File Offset: 0x0022887C
		bool IDictionary.Contains(object ANOFFEKMECJ)
		{
			return this.CPEIMGMEIAD().Contains(ANOFFEKMECJ);
		}

		// Token: 0x170002E6 RID: 742
		// (get) Token: 0x06006A75 RID: 27253 RVA: 0x0022A68C File Offset: 0x0022888C
		public bool HICOIGPOBKO
		{
			get
			{
				return this.ANNBGHOPFBN == KDDIIDPALFG.Int;
			}
		}

		// Token: 0x06006A76 RID: 27254 RVA: 0x0022A698 File Offset: 0x00228898
		public static bool HOOFJGAAMKN(PKIBLOPMGPB AOAILGGFDHJ)
		{
			if (AOAILGGFDHJ.ANNBGHOPFBN != KDDIIDPALFG.Boolean)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a double");
			}
			return AOAILGGFDHJ.HABNDGFGENJ;
		}

		// Token: 0x06006A77 RID: 27255 RVA: 0x0022A6B8 File Offset: 0x002288B8
		public PKIBLOPMGPB(string ECFMJBEFGGB)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.String;
			this.ENIHMLHDOAB = ECFMJBEFGGB;
		}

		// Token: 0x06006A78 RID: 27256 RVA: 0x0022A6D0 File Offset: 0x002288D0
		public static int HOOFJGAAMKN(PKIBLOPMGPB AOAILGGFDHJ)
		{
			if (AOAILGGFDHJ.ANNBGHOPFBN != KDDIIDPALFG.Int)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold an int");
			}
			return AOAILGGFDHJ.FEIPIFGKLFJ;
		}

		// Token: 0x06006A79 RID: 27257 RVA: 0x0022A6F0 File Offset: 0x002288F0
		string BPHPAPPIGNM.GetString()
		{
			if (this.ANNBGHOPFBN != KDDIIDPALFG.String)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a string");
			}
			return this.ENIHMLHDOAB;
		}

		// Token: 0x06006A7A RID: 27258 RVA: 0x0022A710 File Offset: 0x00228910
		void IDictionary.Remove(object ANOFFEKMECJ)
		{
			this.CPEIMGMEIAD().Remove(ANOFFEKMECJ);
			for (int i = 0; i < this.IHNIBHJCCKD.Count; i++)
			{
				if (this.IHNIBHJCCKD[i].Key == (string)ANOFFEKMECJ)
				{
					this.IHNIBHJCCKD.RemoveAt(i);
					break;
				}
			}
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x06006A7B RID: 27259 RVA: 0x0022A784 File Offset: 0x00228984
		private object CMDACHEAEFI(int DMPGHHGCLFK)
		{
			return this.FCNKJHEJOMM()[DMPGHHGCLFK];
		}

		// Token: 0x06006A7C RID: 27260 RVA: 0x0022A794 File Offset: 0x00228994
		void BPHPAPPIGNM.SetLong(long APKGDFCHJOD)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Long;
			this.OAAPHEAHALE = APKGDFCHJOD;
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x06006A7E RID: 27262 RVA: 0x0022A7D4 File Offset: 0x002289D4
		void BPHPAPPIGNM.SetBoolean(bool APKGDFCHJOD)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Boolean;
			this.HABNDGFGENJ = APKGDFCHJOD;
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x170002D9 RID: 729
		// (get) Token: 0x06006A7F RID: 27263 RVA: 0x0022A7EC File Offset: 0x002289EC
		bool BPHPAPPIGNM.KIGEDIEHLBF
		{
			get
			{
				return this.HICOIGPOBKO;
			}
		}

		// Token: 0x06006A80 RID: 27264 RVA: 0x0022A7F4 File Offset: 0x002289F4
		public string BBNCDLJJGBK()
		{
			if (this.LNIOBJAMBGA != null)
			{
				return this.LNIOBJAMBGA;
			}
			StringWriter stringWriter = new StringWriter();
			PKIBLOPMGPB.JDFDJPHHHEI(this, new CNIMHGBHCJJ(stringWriter)
			{
				MDNFOAAHGNL = false
			});
			this.LNIOBJAMBGA = stringWriter.ToString();
			return this.LNIOBJAMBGA;
		}

		// Token: 0x06006A81 RID: 27265 RVA: 0x0022A840 File Offset: 0x00228A40
		IDictionaryEnumerator MLIKFIDAHCA.GetEnumerator()
		{
			this.CPEIMGMEIAD();
			return new FOJDIAJCACK(this.IHNIBHJCCKD.GetEnumerator());
		}

		// Token: 0x06006A82 RID: 27266 RVA: 0x0022A85C File Offset: 0x00228A5C
		double BPHPAPPIGNM.GetDouble()
		{
			if (this.ANNBGHOPFBN != KDDIIDPALFG.Double)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a double");
			}
			return this.MJEDFAGNCPL;
		}

		// Token: 0x06006A83 RID: 27267 RVA: 0x0022A87C File Offset: 0x00228A7C
		public override string ToString()
		{
			switch (this.ANNBGHOPFBN)
			{
			case KDDIIDPALFG.Object:
				return "JsonData object";
			case KDDIIDPALFG.Array:
				return "JsonData array";
			case KDDIIDPALFG.String:
				return this.ENIHMLHDOAB;
			case KDDIIDPALFG.Int:
				return this.FEIPIFGKLFJ.ToString();
			case KDDIIDPALFG.Long:
				return this.OAAPHEAHALE.ToString();
			case KDDIIDPALFG.Double:
				return this.MJEDFAGNCPL.ToString();
			case KDDIIDPALFG.Boolean:
				return this.HABNDGFGENJ.ToString();
			default:
				return "Uninitialized JsonData";
			}
		}

		// Token: 0x06006A84 RID: 27268 RVA: 0x0022A91C File Offset: 0x00228B1C
		public KDDIIDPALFG GNBLCJBCFMP()
		{
			return this.ANNBGHOPFBN;
		}

		// Token: 0x170002E4 RID: 740
		// (get) Token: 0x06006A85 RID: 27269 RVA: 0x0022A924 File Offset: 0x00228B24
		public bool PMDAOKLNCFK
		{
			get
			{
				return this.ANNBGHOPFBN == KDDIIDPALFG.Boolean;
			}
		}

		// Token: 0x06006A86 RID: 27270 RVA: 0x0022A930 File Offset: 0x00228B30
		private ICollection CNMHHAEALLO()
		{
			if (this.ANNBGHOPFBN == KDDIIDPALFG.Array)
			{
				return (ICollection)this.NHAPBKGMHLF;
			}
			if (this.ANNBGHOPFBN == KDDIIDPALFG.Object)
			{
				return (ICollection)this.AAMGBCBLIHD;
			}
			throw new InvalidOperationException("The JsonData instance has to be initialized first");
		}

		// Token: 0x06006A87 RID: 27271 RVA: 0x0022A96C File Offset: 0x00228B6C
		private void CLCBLAMAGLM(int LPFNGFHKNCE, object ANOFFEKMECJ, object NOBAPCOKFIL)
		{
			string text = (string)ANOFFEKMECJ;
			PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(NOBAPCOKFIL);
			this.set_Item(text, pkiblopmgpb);
			KeyValuePair<string, PKIBLOPMGPB> keyValuePair = new KeyValuePair<string, PKIBLOPMGPB>(text, pkiblopmgpb);
			this.IHNIBHJCCKD.Insert(LPFNGFHKNCE, keyValuePair);
		}

		// Token: 0x06006A88 RID: 27272 RVA: 0x0022A9A8 File Offset: 0x00228BA8
		public PKIBLOPMGPB(object INNGECIOBOO)
		{
			if (INNGECIOBOO is bool)
			{
				this.ANNBGHOPFBN = KDDIIDPALFG.Boolean;
				this.HABNDGFGENJ = (bool)INNGECIOBOO;
				return;
			}
			if (INNGECIOBOO is double)
			{
				this.ANNBGHOPFBN = KDDIIDPALFG.Double;
				this.MJEDFAGNCPL = (double)INNGECIOBOO;
				return;
			}
			if (INNGECIOBOO is int)
			{
				this.ANNBGHOPFBN = KDDIIDPALFG.Int;
				this.FEIPIFGKLFJ = (int)INNGECIOBOO;
				return;
			}
			if (INNGECIOBOO is long)
			{
				this.ANNBGHOPFBN = KDDIIDPALFG.Long;
				this.OAAPHEAHALE = (long)INNGECIOBOO;
				return;
			}
			if (INNGECIOBOO is string)
			{
				this.ANNBGHOPFBN = KDDIIDPALFG.String;
				this.ENIHMLHDOAB = (string)INNGECIOBOO;
				return;
			}
			throw new ArgumentException("Unable to wrap the given object with JsonData");
		}

		// Token: 0x170002E5 RID: 741
		// (get) Token: 0x06006A89 RID: 27273 RVA: 0x0022AA60 File Offset: 0x00228C60
		public bool NGMHLHBLPGO
		{
			get
			{
				return this.ANNBGHOPFBN == KDDIIDPALFG.Double;
			}
		}

		// Token: 0x06006A8A RID: 27274 RVA: 0x0022AA6C File Offset: 0x00228C6C
		private void PIKACGMMPNE(int DMPGHHGCLFK, object NOBAPCOKFIL)
		{
			this.FCNKJHEJOMM();
			PKIBLOPMGPB pkiblopmgpb = this.BANLBPMKGPH(NOBAPCOKFIL);
			this.set_Item(DMPGHHGCLFK, pkiblopmgpb);
		}

		// Token: 0x170002DC RID: 732
		// (get) Token: 0x06006A8B RID: 27275 RVA: 0x0022AA90 File Offset: 0x00228C90
		bool BPHPAPPIGNM.FECIGNHIHHF
		{
			get
			{
				return this.COLBIKGMKPI;
			}
		}

		// Token: 0x06006A8C RID: 27276 RVA: 0x0022AA98 File Offset: 0x00228C98
		private void DFNDPCFLJDD(int LPFNGFHKNCE)
		{
			this.CPEIMGMEIAD();
			this.AAMGBCBLIHD.Remove(this.IHNIBHJCCKD[LPFNGFHKNCE].Key);
			this.IHNIBHJCCKD.RemoveAt(LPFNGFHKNCE);
		}

		// Token: 0x06006A8D RID: 27277 RVA: 0x0022AAD8 File Offset: 0x00228CD8
		void IList.Insert(int DMPGHHGCLFK, object NOBAPCOKFIL)
		{
			this.FCNKJHEJOMM().Insert(DMPGHHGCLFK, NOBAPCOKFIL);
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x06006A8E RID: 27278 RVA: 0x0022AAF0 File Offset: 0x00228CF0
		void IList.Clear()
		{
			this.FCNKJHEJOMM().Clear();
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x06006A8F RID: 27279 RVA: 0x0022AB04 File Offset: 0x00228D04
		private void CAAEECBLCHA()
		{
			this.CPEIMGMEIAD().Clear();
			this.IHNIBHJCCKD.Clear();
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x170002D2 RID: 722
		// (get) Token: 0x06006A90 RID: 27280 RVA: 0x0022AB24 File Offset: 0x00228D24
		bool IDictionary.BFJPIPMJFFD
		{
			get
			{
				return this.CPEIMGMEIAD().IsFixedSize;
			}
		}

		// Token: 0x06006A91 RID: 27281 RVA: 0x0022AB34 File Offset: 0x00228D34
		public PKIBLOPMGPB(bool NECEDBGHGAA)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Boolean;
			this.HABNDGFGENJ = NECEDBGHGAA;
		}

		// Token: 0x06006A92 RID: 27282 RVA: 0x0022AB4C File Offset: 0x00228D4C
		public static long HOOFJGAAMKN(PKIBLOPMGPB AOAILGGFDHJ)
		{
			if (AOAILGGFDHJ.ANNBGHOPFBN != KDDIIDPALFG.Long)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold an int");
			}
			return AOAILGGFDHJ.OAAPHEAHALE;
		}

		// Token: 0x170002E7 RID: 743
		// (get) Token: 0x06006A93 RID: 27283 RVA: 0x0022AB6C File Offset: 0x00228D6C
		public bool BAHCBHINPAJ
		{
			get
			{
				return this.ANNBGHOPFBN == KDDIIDPALFG.Long;
			}
		}

		// Token: 0x06006A94 RID: 27284 RVA: 0x0022AB78 File Offset: 0x00228D78
		int IList.IndexOf(object NOBAPCOKFIL)
		{
			return this.FCNKJHEJOMM().IndexOf(NOBAPCOKFIL);
		}

		// Token: 0x06006A96 RID: 27286 RVA: 0x0022AB98 File Offset: 0x00228D98
		void IList.Remove(object NOBAPCOKFIL)
		{
			this.FCNKJHEJOMM().Remove(NOBAPCOKFIL);
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x170002E9 RID: 745
		// (get) Token: 0x06006A97 RID: 27287 RVA: 0x0022ABB0 File Offset: 0x00228DB0
		public bool COLBIKGMKPI
		{
			get
			{
				return this.ANNBGHOPFBN == KDDIIDPALFG.String;
			}
		}

		// Token: 0x06006A98 RID: 27288 RVA: 0x0022ABBC File Offset: 0x00228DBC
		public bool IGJFOOGELIE()
		{
			return this.ANNBGHOPFBN == KDDIIDPALFG.String;
		}

		// Token: 0x06006A99 RID: 27289 RVA: 0x0022ABC8 File Offset: 0x00228DC8
		public static long MOEEMGIEAIE(PKIBLOPMGPB AOAILGGFDHJ)
		{
			if (AOAILGGFDHJ.ANNBGHOPFBN != KDDIIDPALFG.None)
			{
				throw new InvalidCastException("JoinRandom failed: No open game. Calling: OnPhotonRandomJoinFailed() and staying on master server.");
			}
			return AOAILGGFDHJ.OAAPHEAHALE;
		}

		// Token: 0x170002D3 RID: 723
		// (get) Token: 0x06006A9A RID: 27290 RVA: 0x0022ABE8 File Offset: 0x00228DE8
		bool IDictionary.GHJDHDOHNFN
		{
			get
			{
				return this.CPEIMGMEIAD().IsReadOnly;
			}
		}

		// Token: 0x06006A9B RID: 27291 RVA: 0x0022ABF8 File Offset: 0x00228DF8
		public static PKIBLOPMGPB EDHNDLCFIOL(double AOAILGGFDHJ)
		{
			return new PKIBLOPMGPB(AOAILGGFDHJ);
		}

		// Token: 0x170002DD RID: 733
		// (get) Token: 0x06006A9C RID: 27292 RVA: 0x0022AC00 File Offset: 0x00228E00
		bool IList.MPDIANPHBNE
		{
			get
			{
				return this.FCNKJHEJOMM().IsFixedSize;
			}
		}

		// Token: 0x06006A9D RID: 27293 RVA: 0x0022AC10 File Offset: 0x00228E10
		private IDictionary CPEIMGMEIAD()
		{
			if (this.ANNBGHOPFBN == KDDIIDPALFG.Object)
			{
				return (IDictionary)this.AAMGBCBLIHD;
			}
			if (this.ANNBGHOPFBN != KDDIIDPALFG.None)
			{
				throw new InvalidOperationException("Instance of JsonData is not a dictionary");
			}
			this.ANNBGHOPFBN = KDDIIDPALFG.Object;
			this.AAMGBCBLIHD = new Dictionary<string, PKIBLOPMGPB>();
			this.IHNIBHJCCKD = new List<KeyValuePair<string, PKIBLOPMGPB>>();
			return (IDictionary)this.AAMGBCBLIHD;
		}

		// Token: 0x170002D4 RID: 724
		// (get) Token: 0x06006A9E RID: 27294 RVA: 0x0022AC74 File Offset: 0x00228E74
		ICollection IDictionary.JGOHFNIEPKJ
		{
			get
			{
				this.CPEIMGMEIAD();
				IList<string> list = new List<string>();
				foreach (KeyValuePair<string, PKIBLOPMGPB> keyValuePair in this.IHNIBHJCCKD)
				{
					list.Add(keyValuePair.Key);
				}
				return (ICollection)list;
			}
		}

		// Token: 0x06006A9F RID: 27295 RVA: 0x0022ACE8 File Offset: 0x00228EE8
		private PKIBLOPMGPB BANLBPMKGPH(object INNGECIOBOO)
		{
			if (INNGECIOBOO == null)
			{
				return null;
			}
			if (INNGECIOBOO is PKIBLOPMGPB)
			{
				return (PKIBLOPMGPB)INNGECIOBOO;
			}
			return new PKIBLOPMGPB(INNGECIOBOO);
		}

		// Token: 0x170002EA RID: 746
		// (get) Token: 0x06006AA0 RID: 27296 RVA: 0x0022AD0C File Offset: 0x00228F0C
		public ICollection<string> BLKILOODJOJ
		{
			get
			{
				this.CPEIMGMEIAD();
				return this.AAMGBCBLIHD.Keys;
			}
		}

		// Token: 0x06006AA1 RID: 27297 RVA: 0x0022AD20 File Offset: 0x00228F20
		public static PKIBLOPMGPB EDHNDLCFIOL(long AOAILGGFDHJ)
		{
			return new PKIBLOPMGPB(AOAILGGFDHJ);
		}

		// Token: 0x06006AA2 RID: 27298 RVA: 0x0022AD28 File Offset: 0x00228F28
		public static PKIBLOPMGPB EDHNDLCFIOL(int AOAILGGFDHJ)
		{
			return new PKIBLOPMGPB(AOAILGGFDHJ);
		}

		// Token: 0x170002E8 RID: 744
		// (get) Token: 0x06006AA3 RID: 27299 RVA: 0x0022AD30 File Offset: 0x00228F30
		public bool IMPJCAGENLC
		{
			get
			{
				return this.ANNBGHOPFBN == KDDIIDPALFG.Object;
			}
		}

		// Token: 0x06006AA4 RID: 27300 RVA: 0x0022AD3C File Offset: 0x00228F3C
		private void KDFCENHBNIO(long APKGDFCHJOD)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Array;
			this.OAAPHEAHALE = APKGDFCHJOD;
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x06006AA5 RID: 27301 RVA: 0x0022AD54 File Offset: 0x00228F54
		public PKIBLOPMGPB(double DNIFODKLLOL)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Double;
			this.MJEDFAGNCPL = DNIFODKLLOL;
		}

		// Token: 0x06006AA6 RID: 27302 RVA: 0x0022AD6C File Offset: 0x00228F6C
		void BPHPAPPIGNM.SetInt(int APKGDFCHJOD)
		{
			this.ANNBGHOPFBN = KDDIIDPALFG.Int;
			this.FEIPIFGKLFJ = APKGDFCHJOD;
			this.LNIOBJAMBGA = null;
		}

		// Token: 0x06006AA7 RID: 27303 RVA: 0x0022AD84 File Offset: 0x00228F84
		private bool AIPKAEOEBPI(object ANOFFEKMECJ)
		{
			return this.CPEIMGMEIAD().Contains(ANOFFEKMECJ);
		}

		// Token: 0x06006AA8 RID: 27304 RVA: 0x0022AD94 File Offset: 0x00228F94
		public static string HOOFJGAAMKN(PKIBLOPMGPB AOAILGGFDHJ)
		{
			if (AOAILGGFDHJ.ANNBGHOPFBN != KDDIIDPALFG.String)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a string");
			}
			return AOAILGGFDHJ.ENIHMLHDOAB;
		}

		// Token: 0x06006AA9 RID: 27305 RVA: 0x0022ADB4 File Offset: 0x00228FB4
		public static PKIBLOPMGPB EDHNDLCFIOL(bool AOAILGGFDHJ)
		{
			return new PKIBLOPMGPB(AOAILGGFDHJ);
		}

		// Token: 0x06006AAB RID: 27307 RVA: 0x0022AE00 File Offset: 0x00229000
		public bool Equals(PKIBLOPMGPB ILFEPFCLLFJ)
		{
			if (ILFEPFCLLFJ == null)
			{
				return false;
			}
			if (ILFEPFCLLFJ.ANNBGHOPFBN != this.ANNBGHOPFBN)
			{
				return false;
			}
			switch (this.ANNBGHOPFBN)
			{
			case KDDIIDPALFG.None:
				return true;
			case KDDIIDPALFG.Object:
				return this.AAMGBCBLIHD.Equals(ILFEPFCLLFJ.AAMGBCBLIHD);
			case KDDIIDPALFG.Array:
				return this.NHAPBKGMHLF.Equals(ILFEPFCLLFJ.NHAPBKGMHLF);
			case KDDIIDPALFG.String:
				return this.ENIHMLHDOAB.Equals(ILFEPFCLLFJ.ENIHMLHDOAB);
			case KDDIIDPALFG.Int:
				return this.FEIPIFGKLFJ.Equals(ILFEPFCLLFJ.FEIPIFGKLFJ);
			case KDDIIDPALFG.Long:
				return this.OAAPHEAHALE.Equals(ILFEPFCLLFJ.OAAPHEAHALE);
			case KDDIIDPALFG.Double:
				return this.MJEDFAGNCPL.Equals(ILFEPFCLLFJ.MJEDFAGNCPL);
			case KDDIIDPALFG.Boolean:
				return this.HABNDGFGENJ.Equals(ILFEPFCLLFJ.HABNDGFGENJ);
			default:
				return false;
			}
		}

		// Token: 0x06006AAC RID: 27308 RVA: 0x0022AEDC File Offset: 0x002290DC
		long BPHPAPPIGNM.GetLong()
		{
			if (this.ANNBGHOPFBN != KDDIIDPALFG.Long)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a long");
			}
			return this.OAAPHEAHALE;
		}

		// Token: 0x06006AAD RID: 27309 RVA: 0x0022AEFC File Offset: 0x002290FC
		public void GPPHLMKGPLC(KDDIIDPALFG ANNBGHOPFBN)
		{
			if (this.ANNBGHOPFBN == ANNBGHOPFBN)
			{
				return;
			}
			switch (ANNBGHOPFBN)
			{
			case KDDIIDPALFG.Object:
				this.AAMGBCBLIHD = new Dictionary<string, PKIBLOPMGPB>();
				this.IHNIBHJCCKD = new List<KeyValuePair<string, PKIBLOPMGPB>>();
				break;
			case KDDIIDPALFG.Array:
				this.NHAPBKGMHLF = new List<PKIBLOPMGPB>();
				break;
			case KDDIIDPALFG.String:
				this.ENIHMLHDOAB = null;
				break;
			case KDDIIDPALFG.Int:
				this.FEIPIFGKLFJ = 0;
				break;
			case KDDIIDPALFG.Long:
				this.OAAPHEAHALE = 1L;
				break;
			case KDDIIDPALFG.Double:
				this.MJEDFAGNCPL = 1909.0;
				break;
			case KDDIIDPALFG.Boolean:
				this.HABNDGFGENJ = true;
				break;
			}
			this.ANNBGHOPFBN = ANNBGHOPFBN;
		}

		// Token: 0x04000E54 RID: 3668
		private IList<PKIBLOPMGPB> NHAPBKGMHLF;

		// Token: 0x04000E55 RID: 3669
		private bool HABNDGFGENJ;

		// Token: 0x04000E56 RID: 3670
		private double MJEDFAGNCPL;

		// Token: 0x04000E57 RID: 3671
		private int FEIPIFGKLFJ;

		// Token: 0x04000E58 RID: 3672
		private long OAAPHEAHALE;

		// Token: 0x04000E59 RID: 3673
		private IDictionary<string, PKIBLOPMGPB> AAMGBCBLIHD;

		// Token: 0x04000E5A RID: 3674
		private string ENIHMLHDOAB;

		// Token: 0x04000E5B RID: 3675
		private string LNIOBJAMBGA;

		// Token: 0x04000E5C RID: 3676
		private KDDIIDPALFG ANNBGHOPFBN;

		// Token: 0x04000E5D RID: 3677
		private IList<KeyValuePair<string, PKIBLOPMGPB>> IHNIBHJCCKD;
	}
}