using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading;
using AmplitudeMiniJSON;
using RecNet;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Serialization;

namespace AmplitudeAnalytics
{
	// Token: 0x02000A84 RID: 2692
	public class AmplitudeAnalyticsClient : SingletonMonoBehaviour<AmplitudeAnalyticsClient>
	{
		// Token: 0x060148B3 RID: 84147 RVA: 0x005C1D3C File Offset: 0x005BFF3C
		private void Update()
		{
			if (!this.NOCJONDDHEF)
			{
				return;
			}
			this.MLOBNKNBNEG += Time.deltaTime;
			if (this.MLOBNKNBNEG >= 1f)
			{
				this.KHBMAFKJKNA = 0;
				this.NBDNLGAOENP = 0;
				this.MLOBNKNBNEG = 0f;
			}
			if (!this.FNJPEPLCIJK && (Time.realtimeSinceStartup >= this.HGCEDADADPF + this.settings.BatchIntervalSeconds || AmplitudeAnalyticsClient.HMNOJGLGGFL.BBPNJLFGBMN.PFMKGBAKMMM >= 10))
			{
				base.StartCoroutine(this.LCBAIAEDJOD(-1f));
			}
			if (!this.ECMAEOCMHDA && (Time.realtimeSinceStartup + this.settings.BatchIntervalSeconds / 2f >= this.EEEJIHJEIJH + this.settings.BatchIntervalSeconds || AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI.PFMKGBAKMMM >= 10))
			{
				base.StartCoroutine(this.IFKIPFIIFFI(-1f));
			}
		}

		// Token: 0x060148B4 RID: 84148 RVA: 0x005C1E38 File Offset: 0x005C0038
		public static ABGKCPDMLJN EIMBNFCOKML(string NDPNANMNCDL, Func<AmplitudeAnalyticsIdentifyMessage.DeviceInfo> IFAOKLLBJEB)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return ABGKCPDMLJN.HBAIMNCFBLH;
			}
			SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG = NDPNANMNCDL;
			SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.CJHOAJEAABA = false;
			return AmplitudeAnalyticsEvent.GGOLPJFOBAK("_pos", AmplitudeAnalyticsClient.IHHFDHDLEJG(), (long)AmplitudeAnalyticsClient.MHCLFJIJCKE, NDPNANMNCDL).MFOPHFMCIEJ(IFAOKLLBJEB());
		}

		// Token: 0x060148B5 RID: 84149 RVA: 0x005C1E90 File Offset: 0x005C0090
		public static ABGKCPDMLJN HPIEEFFFIHG(string NDPNANMNCDL, Func<AmplitudeAnalyticsIdentifyMessage.DeviceInfo> IFAOKLLBJEB)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return ABGKCPDMLJN.HBAIMNCFBLH;
			}
			SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.PCIPLOCLJKK(NDPNANMNCDL);
			SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.CJHOAJEAABA = false;
			return AmplitudeAnalyticsEvent.EFJCMOPEMKJ("Go to ", AmplitudeAnalyticsClient.EBKMJABKJJA, (long)AmplitudeAnalyticsClient.MHCLFJIJCKE, NDPNANMNCDL).MFOPHFMCIEJ(IFAOKLLBJEB());
		}

		// Token: 0x060148B6 RID: 84150 RVA: 0x005C1EE8 File Offset: 0x005C00E8
		public void SendEndSessionEvent()
		{
			if (this.NOCJONDDHEF && !this.CJHOAJEAABA)
			{
				this.CJHOAJEAABA = true;
				ABGKCPDMLJN abgkcpdmljn = AmplitudeAnalyticsEvent.EFJCMOPEMKJ("session_end", AmplitudeAnalyticsClient.EBKMJABKJJA, (long)AmplitudeAnalyticsClient.MHCLFJIJCKE, this.OCAHLHMIPMG);
				this.LogEventAsync(abgkcpdmljn.GMBCDDGJCOO());
			}
		}

		// Token: 0x060148B7 RID: 84151 RVA: 0x005C1F3C File Offset: 0x005C013C
		protected override void Awake()
		{
			base.Awake();
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				base.enabled = false;
				return;
			}
			AmplitudeAnalyticsClient.HMNOJGLGGFL.BBPNJLFGBMN.KOJFGMBIEJE();
			AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI.KOJFGMBIEJE();
		}

		// Token: 0x060148B8 RID: 84152 RVA: 0x005C1F6C File Offset: 0x005C016C
		public static ABGKCPDMLJN InitializeEvent(string NDPNANMNCDL)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return ABGKCPDMLJN.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsClient.InitializeEvent(NDPNANMNCDL, JKMEHAOPLNK.CBCCHGJNNKC);
		}

		// Token: 0x060148BA RID: 84154 RVA: 0x005C1FAC File Offset: 0x005C01AC
		private IEnumerator DLNJCCODLCN()
		{
			float num = 3f;
			this.AICPKFBPFKN = AmplitudeAnalyticsClient.BBAPHFJEPFM.WaitingForFlush;
			yield return this.WaitForFlush(num);
			this.AICPKFBPFKN = AmplitudeAnalyticsClient.BBAPHFJEPFM.Flushed;
			Application.Quit();
			yield break;
		}

		// Token: 0x060148BB RID: 84155 RVA: 0x005C1FC8 File Offset: 0x005C01C8
		public IEnumerator OutOfSessionEvent(string NALJBMNHCMP)
		{
			AmplitudeAnalyticsEvent amplitudeAnalyticsEvent = AmplitudeAnalyticsEvent.EFJCMOPEMKJ(NALJBMNHCMP, -1L, 0L, null).GMBCDDGJCOO();
			string eventApiURL = this.settings.eventApiURL;
			string text = "event";
			Dictionary<string, object> dictionary = amplitudeAnalyticsEvent.ICMFBONNCHO();
			if (AmplitudeAnalyticsClient.DINNJGHCFHI == null)
			{
				AmplitudeAnalyticsClient.DINNJGHCFHI = new Action<long, string, Dictionary<string, object>>(AmplitudeAnalyticsClient.EOBLAOFNBIP);
			}
			return this.KMPIFMEFBDI<Dictionary<string, object>>(eventApiURL, text, dictionary, AmplitudeAnalyticsClient.DINNJGHCFHI);
		}

		// Token: 0x060148BC RID: 84156 RVA: 0x005C2020 File Offset: 0x005C0220
		public void MGDKMNIKJIN(Action<bool> NOBAPCOKFIL)
		{
			Action<bool> action = this.MBJKFOKOLEJ;
			Action<bool> action2;
			do
			{
				action2 = action;
				action = Interlocked.CompareExchange<Action<bool>>(ref this.MBJKFOKOLEJ, (Action<bool>)Delegate.Combine(action2, NOBAPCOKFIL), action);
			}
			while (action != action2);
		}

		// Token: 0x060148BD RID: 84157 RVA: 0x005C2058 File Offset: 0x005C0258
		public static CACKGEGLEJJ AGLKBKDODGK()
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return CACKGEGLEJJ.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsIdentifyMessage.EFJCMOPEMKJ(SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG);
		}

		// Token: 0x060148BE RID: 84158 RVA: 0x005C207C File Offset: 0x005C027C
		private IEnumerator EDIAOPLKEEI(float ABPJFFBGJBF = -1f)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				yield break;
			}
			this.ECMAEOCMHDA = true;
			this.EEEJIHJEIJH = Time.realtimeSinceStartup;
			AmplitudeAnalyticsClient.HMNOJGLGGFL cibkapobppi = AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI;
			string identifyApiURL = this.settings.identifyApiURL;
			AmplitudeAnalyticsClient.HMNOJGLGGFL hmnojglggfl = cibkapobppi;
			string text = identifyApiURL;
			string text2 = "identification";
			if (AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI == null)
			{
				AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI = new Action<int>(AmplitudeAnalyticsClient.KGOIBDBEGGO.OJKNBNGGBEC);
			}
			yield return this.MGHAHLHAGEA(hmnojglggfl, text, text2, ABPJFFBGJBF, AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI);
			this.ECMAEOCMHDA = false;
			yield break;
		}

		// Token: 0x060148BF RID: 84159 RVA: 0x005C20A0 File Offset: 0x005C02A0
		private void DHOCCIEHAGP()
		{
			if (this.MBJKFOKOLEJ != null)
			{
				this.MBJKFOKOLEJ(this.NOCJONDDHEF);
			}
			if (this.NOCJONDDHEF)
			{
				ABGKCPDMLJN abgkcpdmljn = AmplitudeAnalyticsEvent.EFJCMOPEMKJ("session_end", AmplitudeAnalyticsClient.EBKMJABKJJA, (long)AmplitudeAnalyticsClient.MHCLFJIJCKE, this.OCAHLHMIPMG);
				this.LogEventAsync(abgkcpdmljn.GMBCDDGJCOO());
			}
		}

		// Token: 0x17000815 RID: 2069
		// (get) Token: 0x060148D7 RID: 84183 RVA: 0x005C2488 File Offset: 0x005C0688
		// (set) Token: 0x060148C0 RID: 84160 RVA: 0x005C20FC File Offset: 0x005C02FC
		public static long EBKMJABKJJA
		{
			get
			{
				return AmplitudeAnalyticsClient.FLKDLBJBFNL;
			}
			set
			{
				AmplitudeAnalyticsClient.FLKDLBJBFNL = value;
			}
		}

		// Token: 0x060148C1 RID: 84161 RVA: 0x005C2104 File Offset: 0x005C0304
		public static long KAJKINGNBPF()
		{
			return AmplitudeAnalyticsClient.FLKDLBJBFNL;
		}

		// Token: 0x060148C2 RID: 84162 RVA: 0x005C210C File Offset: 0x005C030C
		public static ABGKCPDMLJN InitializeEvent(string NDPNANMNCDL, Func<AmplitudeAnalyticsIdentifyMessage.DeviceInfo> IFAOKLLBJEB)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return ABGKCPDMLJN.HBAIMNCFBLH;
			}
			SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG = NDPNANMNCDL;
			SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.CJHOAJEAABA = false;
			return AmplitudeAnalyticsEvent.EFJCMOPEMKJ("session_start", AmplitudeAnalyticsClient.EBKMJABKJJA, (long)AmplitudeAnalyticsClient.MHCLFJIJCKE, NDPNANMNCDL).MFOPHFMCIEJ(IFAOKLLBJEB());
		}

		// Token: 0x060148C3 RID: 84163 RVA: 0x005C2164 File Offset: 0x005C0364
		private IEnumerator KMPIFMEFBDI<T>(string KFBLNOCKOND, string NFEDJLINGJO, T AHPJDBJLDEH, Action<long, string, T> PHLHCDHNDJH)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled || string.IsNullOrEmpty(ANCDCLKNPFI.KHJGACFJMEB))
			{
				yield break;
			}
			WWWForm wwwform = new WWWForm();
			wwwform.AddField("api_key", ANCDCLKNPFI.KHJGACFJMEB);
			string text = HOEKEPDDBBF.DNGBHIBIGLN(AHPJDBJLDEH);
			wwwform.AddField(NFEDJLINGJO, text);
			UnityWebRequest unityWebRequest = UnityWebRequest.Post(KFBLNOCKOND, wwwform);
			unityWebRequest.downloadHandler = new DownloadHandlerBuffer();
			yield return unityWebRequest.Send();
			PHLHCDHNDJH(unityWebRequest.responseCode, unityWebRequest.downloadHandler.text, AHPJDBJLDEH);
			yield break;
		}

		// Token: 0x060148C4 RID: 84164 RVA: 0x005C2198 File Offset: 0x005C0398
		public void JBCENKMGEJH(Action<bool> NOBAPCOKFIL)
		{
			Action<bool> action = this.MBJKFOKOLEJ;
			Action<bool> action2;
			do
			{
				action2 = action;
				action = Interlocked.CompareExchange<Action<bool>>(ref this.MBJKFOKOLEJ, (Action<bool>)Delegate.Remove(action2, NOBAPCOKFIL), action);
			}
			while (action != action2);
		}

		// Token: 0x1400008C RID: 140
		// (add) Token: 0x060148C5 RID: 84165 RVA: 0x005C21D0 File Offset: 0x005C03D0
		// (remove) Token: 0x060148DF RID: 84191 RVA: 0x005C258C File Offset: 0x005C078C
		[field: DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event Action<bool> MBJKFOKOLEJ;

		// Token: 0x060148C6 RID: 84166 RVA: 0x005C2208 File Offset: 0x005C0408
		private void DJGEFEHFFLD()
		{
			if (this.MBJKFOKOLEJ != null)
			{
				this.MBJKFOKOLEJ(this.NOCJONDDHEF);
			}
			if (this.NOCJONDDHEF)
			{
				ABGKCPDMLJN abgkcpdmljn = AmplitudeAnalyticsEvent.OCABPHCAOJL("gizmos", AmplitudeAnalyticsClient.CKFGKOELPBG(), (long)AmplitudeAnalyticsClient.MHCLFJIJCKE, this.OCAHLHMIPMG);
				this.LogEventAsync(abgkcpdmljn.GMBCDDGJCOO());
			}
		}

		// Token: 0x060148C7 RID: 84167 RVA: 0x005C2264 File Offset: 0x005C0464
		public void EOGIKGMAJCI(AmplitudeAnalyticsIdentifyMessage CNCCFANFOFL)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return;
			}
			if (!this.NOCJONDDHEF)
			{
				throw new InvalidOperationException("Error deserializing ActivityEquipment {0}: Serialized GUID {1} does not match prefab value {2}");
			}
			AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI.GAGJPMFIGKK(CNCCFANFOFL, true);
		}

		// Token: 0x060148C8 RID: 84168 RVA: 0x005C2294 File Offset: 0x005C0494
		public static CACKGEGLEJJ EMBNKHEIAEF()
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return CACKGEGLEJJ.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsIdentifyMessage.EFJCMOPEMKJ(SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG);
		}

		// Token: 0x060148C9 RID: 84169 RVA: 0x005C22B8 File Offset: 0x005C04B8
		public static long PGCABCCNPKJ()
		{
			return AmplitudeAnalyticsClient.FLKDLBJBFNL;
		}

		// Token: 0x060148CA RID: 84170 RVA: 0x005C22C0 File Offset: 0x005C04C0
		private bool IAFHAJNECLC(float JBDLCPGODKK, float ABPJFFBGJBF)
		{
			if (ABPJFFBGJBF <= 0f)
			{
				return false;
			}
			float num = Time.realtimeSinceStartup - JBDLCPGODKK;
			return num > ABPJFFBGJBF;
		}

		// Token: 0x060148CB RID: 84171 RVA: 0x005C22E8 File Offset: 0x005C04E8
		public static long LJGANPFHPOL()
		{
			return (long)(DateTime.UtcNow - new DateTime(127, 0, 1, 1, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
		}

		// Token: 0x060148CC RID: 84172 RVA: 0x005C2318 File Offset: 0x005C0518
		public static CACKGEGLEJJ Identify()
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return CACKGEGLEJJ.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsIdentifyMessage.EFJCMOPEMKJ(SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG);
		}

		// Token: 0x060148CD RID: 84173 RVA: 0x005C233C File Offset: 0x005C053C
		public void DKMHEEKDCDE(AmplitudeAnalyticsClient.Settings EHLKBCGKMPB)
		{
			global::UnityEngine.Debug.Log("Failed to modify game session in-progress state");
			this.settings = EHLKBCGKMPB;
		}

		// Token: 0x060148CE RID: 84174 RVA: 0x005C2350 File Offset: 0x005C0550
		public IEnumerator EJDBHPKEJHG(AmplitudeAnalyticsEvent OANNBDIPLBL)
		{
			yield return this.LCBAIAEDJOD(-1f);
			this.NOCJONDDHEF = true;
			this.LogEventAsync(OANNBDIPLBL);
			yield break;
		}

		// Token: 0x060148CF RID: 84175 RVA: 0x005C2374 File Offset: 0x005C0574
		public static long CKFGKOELPBG()
		{
			return AmplitudeAnalyticsClient.FLKDLBJBFNL;
		}

		// Token: 0x060148D0 RID: 84176 RVA: 0x005C237C File Offset: 0x005C057C
		public static long UTCMillisSinceEpoch()
		{
			return (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
		}

		// Token: 0x060148D1 RID: 84177 RVA: 0x005C23AC File Offset: 0x005C05AC
		private void CKDLEHGDLJN()
		{
			if (this.MBJKFOKOLEJ != null)
			{
				this.MBJKFOKOLEJ(this.NOCJONDDHEF);
			}
			if (this.NOCJONDDHEF)
			{
				ABGKCPDMLJN abgkcpdmljn = AmplitudeAnalyticsEvent.FLHMBAEHCIO("Warning: SFX array is null.", AmplitudeAnalyticsClient.CKFGKOELPBG(), (long)AmplitudeAnalyticsClient.MHCLFJIJCKE, this.OCAHLHMIPMG);
				this.LogEventAsync(abgkcpdmljn.GMBCDDGJCOO());
			}
		}

		// Token: 0x060148D2 RID: 84178 RVA: 0x005C2408 File Offset: 0x005C0608
		public static long INHKKPIIKLE()
		{
			return AmplitudeAnalyticsClient.FLKDLBJBFNL;
		}

		// Token: 0x060148D3 RID: 84179 RVA: 0x005C2410 File Offset: 0x005C0610
		public IEnumerator Initialize(AmplitudeAnalyticsEvent OANNBDIPLBL)
		{
			yield return this.LCBAIAEDJOD(-1f);
			this.NOCJONDDHEF = true;
			this.LogEventAsync(OANNBDIPLBL);
			yield break;
		}

		// Token: 0x060148D4 RID: 84180 RVA: 0x005C2434 File Offset: 0x005C0634
		public static CACKGEGLEJJ LHJAHIPPHIM()
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return CACKGEGLEJJ.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsIdentifyMessage.EFJCMOPEMKJ(SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG);
		}

		// Token: 0x060148D5 RID: 84181 RVA: 0x005C2458 File Offset: 0x005C0658
		private void OnApplicationQuit()
		{
			this.GNLDNCELBBB();
		}

		// Token: 0x060148D6 RID: 84182 RVA: 0x005C2460 File Offset: 0x005C0660
		private bool OMELKGMHLIC(float JBDLCPGODKK, float ABPJFFBGJBF)
		{
			if (ABPJFFBGJBF <= 1441f)
			{
				return true;
			}
			float num = Time.realtimeSinceStartup - JBDLCPGODKK;
			return num > ABPJFFBGJBF;
		}

		// Token: 0x060148D8 RID: 84184 RVA: 0x005C2490 File Offset: 0x005C0690
		[CompilerGenerated]
		private static void EOBLAOFNBIP(long BHCHKFPGKIM, string EJDAIKFLCCL, Dictionary<string, object> NILLMCJCHJH)
		{
		}

		// Token: 0x060148D9 RID: 84185 RVA: 0x005C2494 File Offset: 0x005C0694
		public static ABGKCPDMLJN Event(string NALJBMNHCMP)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return ABGKCPDMLJN.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsEvent.EFJCMOPEMKJ(NALJBMNHCMP, AmplitudeAnalyticsClient.EBKMJABKJJA, (long)AmplitudeAnalyticsClient.MHCLFJIJCKE, SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG);
		}

		// Token: 0x060148DA RID: 84186 RVA: 0x005C24C4 File Offset: 0x005C06C4
		private void EDKAIKIGOGB()
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return;
			}
			if (this.AICPKFBPFKN == AmplitudeAnalyticsClient.BBAPHFJEPFM.Running)
			{
				this.SendEndSessionEvent();
				Application.CancelQuit();
				if (this.MBJKFOKOLEJ != null)
				{
					this.MBJKFOKOLEJ(this.NOCJONDDHEF);
				}
				base.StartCoroutine(this.HCPNPIHAAAG());
			}
		}

		// Token: 0x060148DB RID: 84187 RVA: 0x005C251C File Offset: 0x005C071C
		private void OCEJENEOCJK()
		{
			this.HGCEDADADPF = 682f;
			this.EEEJIHJEIJH = 27f;
		}

		// Token: 0x060148DC RID: 84188 RVA: 0x005C2534 File Offset: 0x005C0734
		private void Start()
		{
			this.HGCEDADADPF = float.MinValue;
			this.EEEJIHJEIJH = float.MinValue;
		}

		// Token: 0x060148DD RID: 84189 RVA: 0x005C254C File Offset: 0x005C074C
		private IEnumerator LCBAIAEDJOD(float ABPJFFBGJBF = -1f)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				yield break;
			}
			this.FNJPEPLCIJK = true;
			this.HGCEDADADPF = Time.realtimeSinceStartup;
			bool flag = true;
			if (this.NBDNLGAOENP >= 100)
			{
				global::UnityEngine.Debug.LogWarning("Too many batches being sent. Skipping flush for now");
				flag = false;
			}
			if (this.KHBMAFKJKNA >= 1000)
			{
				global::UnityEngine.Debug.LogWarning("Too many events being sent. Skipping flush for now");
				flag = false;
			}
			if (flag)
			{
				AmplitudeAnalyticsClient.HMNOJGLGGFL bbpnjlfgbmn = AmplitudeAnalyticsClient.HMNOJGLGGFL.BBPNJLFGBMN;
				string eventApiURL = this.settings.eventApiURL;
				Action<int> action = new Action<int>(base.OJKNBNGGBEC);
				yield return this.MGHAHLHAGEA(bbpnjlfgbmn, eventApiURL, "event", ABPJFFBGJBF, action);
			}
			this.FNJPEPLCIJK = false;
			yield break;
		}

		// Token: 0x060148DE RID: 84190 RVA: 0x005C2570 File Offset: 0x005C0770
		private IEnumerator HCPNPIHAAAG()
		{
			num = 3f;
			this.AICPKFBPFKN = AmplitudeAnalyticsClient.BBAPHFJEPFM.WaitingForFlush;
			yield return this.WaitForFlush(num);
			this.AICPKFBPFKN = AmplitudeAnalyticsClient.BBAPHFJEPFM.Flushed;
			Application.Quit();
			yield break;
		}

		// Token: 0x060148E0 RID: 84192 RVA: 0x005C25C4 File Offset: 0x005C07C4
		public void JKDALMAOABO(AmplitudeAnalyticsClient.Settings EHLKBCGKMPB)
		{
			global::UnityEngine.Debug.Log("SplitTestAssignedSegments");
			this.settings = EHLKBCGKMPB;
		}

		// Token: 0x060148E1 RID: 84193 RVA: 0x005C25D8 File Offset: 0x005C07D8
		private void CJDFMFPIFDB()
		{
			if (!this.NOCJONDDHEF)
			{
				return;
			}
			this.MLOBNKNBNEG += Time.deltaTime;
			if (this.MLOBNKNBNEG >= 569f)
			{
				this.KHBMAFKJKNA = 1;
				this.NBDNLGAOENP = 0;
				this.MLOBNKNBNEG = 1134f;
			}
			if (!this.FNJPEPLCIJK && (Time.realtimeSinceStartup >= this.HGCEDADADPF + this.settings.BatchIntervalSeconds || AmplitudeAnalyticsClient.HMNOJGLGGFL.BBPNJLFGBMN.PINOCEKCEEN() >= -84))
			{
				base.StartCoroutine(this.LCBAIAEDJOD(1057f));
			}
			if (!this.ECMAEOCMHDA && (Time.realtimeSinceStartup + this.settings.BatchIntervalSeconds / 912f >= this.EEEJIHJEIJH + this.settings.BatchIntervalSeconds || AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI.PINOCEKCEEN() >= -82))
			{
				base.StartCoroutine(this.IFKIPFIIFFI(1801f));
			}
		}

		// Token: 0x060148E2 RID: 84194 RVA: 0x005C26D4 File Offset: 0x005C08D4
		public static CACKGEGLEJJ OLCICFEHKFF()
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return CACKGEGLEJJ.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsIdentifyMessage.EFJCMOPEMKJ(SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG);
		}

		// Token: 0x17000814 RID: 2068
		// (get) Token: 0x060148E3 RID: 84195 RVA: 0x005C26F8 File Offset: 0x005C08F8
		private static int MHCLFJIJCKE
		{
			get
			{
				int num = 0;
				if (PlayerPrefs.HasKey("amplitude_sequence_number"))
				{
					num = PlayerPrefs.GetInt("amplitude_sequence_number");
				}
				int num2;
				if (num < 2147483646)
				{
					num2 = num + 1;
				}
				else
				{
					num2 = 0;
				}
				PlayerPrefs.SetInt("amplitude_sequence_number", num2);
				return num;
			}
		}

		// Token: 0x060148E4 RID: 84196 RVA: 0x005C2744 File Offset: 0x005C0944
		private IEnumerator FPBBBAACFMO()
		{
			num = 3f;
			this.AICPKFBPFKN = AmplitudeAnalyticsClient.BBAPHFJEPFM.WaitingForFlush;
			yield return this.WaitForFlush(num);
			this.AICPKFBPFKN = AmplitudeAnalyticsClient.BBAPHFJEPFM.Flushed;
			Application.Quit();
			yield break;
		}

		// Token: 0x060148E5 RID: 84197 RVA: 0x005C2760 File Offset: 0x005C0960
		public static ABGKCPDMLJN JMALFPLCKGJ(string NDPNANMNCDL)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return ABGKCPDMLJN.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsClient.HPIEEFFFIHG(NDPNANMNCDL, JKMEHAOPLNK.CBCCHGJNNKC);
		}

		// Token: 0x060148E6 RID: 84198 RVA: 0x005C2780 File Offset: 0x005C0980
		private IEnumerator IFKIPFIIFFI(float ABPJFFBGJBF = -1f)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				yield break;
			}
			this.ECMAEOCMHDA = true;
			this.EEEJIHJEIJH = Time.realtimeSinceStartup;
			cibkapobppi = AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI;
			identifyApiURL = this.settings.identifyApiURL;
			AmplitudeAnalyticsClient.HMNOJGLGGFL hmnojglggfl = cibkapobppi;
			string text = identifyApiURL;
			string text2 = "identification";
			if (AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI == null)
			{
				AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI = new Action<int>(AmplitudeAnalyticsClient.KGOIBDBEGGO.OJKNBNGGBEC);
			}
			yield return this.MGHAHLHAGEA(hmnojglggfl, text, text2, ABPJFFBGJBF, AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI);
			this.ECMAEOCMHDA = false;
			yield break;
		}

		// Token: 0x060148E7 RID: 84199 RVA: 0x005C27A4 File Offset: 0x005C09A4
		public void ForceSettings(AmplitudeAnalyticsClient.Settings EHLKBCGKMPB)
		{
			global::UnityEngine.Debug.Log("Forcing settings for Amplitude");
			this.settings = EHLKBCGKMPB;
		}

		// Token: 0x060148E8 RID: 84200 RVA: 0x005C27B8 File Offset: 0x005C09B8
		public static CACKGEGLEJJ KMEHHAHCEFC()
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return CACKGEGLEJJ.HBAIMNCFBLH;
			}
			return AmplitudeAnalyticsIdentifyMessage.EFJCMOPEMKJ(SingletonMonoBehaviour<AmplitudeAnalyticsClient>.NCKMBFBMBFM.OCAHLHMIPMG);
		}

		// Token: 0x060148E9 RID: 84201 RVA: 0x005C27DC File Offset: 0x005C09DC
		public IEnumerator WaitForFlush(float ABPJFFBGJBF = 30f)
		{
			while (this.FNJPEPLCIJK && ABPJFFBGJBF > 0f)
			{
				ABPJFFBGJBF -= Time.unscaledDeltaTime;
				yield return null;
			}
			while (this.ECMAEOCMHDA && ABPJFFBGJBF > 0f)
			{
				ABPJFFBGJBF -= Time.unscaledDeltaTime;
				yield return null;
			}
			yield return this.LCBAIAEDJOD(ABPJFFBGJBF);
			yield break;
		}

		// Token: 0x060148EA RID: 84202 RVA: 0x005C2800 File Offset: 0x005C0A00
		protected void PCIPLOCLJKK(string NOBAPCOKFIL)
		{
			this.<FDPHEKMDKEL>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060148EC RID: 84204 RVA: 0x005C281C File Offset: 0x005C0A1C
		private void GNLDNCELBBB()
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return;
			}
			if (this.AICPKFBPFKN == AmplitudeAnalyticsClient.BBAPHFJEPFM.Running)
			{
				this.SendEndSessionEvent();
				Application.CancelQuit();
				if (this.MBJKFOKOLEJ != null)
				{
					this.MBJKFOKOLEJ(this.NOCJONDDHEF);
				}
				base.StartCoroutine(this.HCPNPIHAAAG());
			}
		}

		// Token: 0x17000813 RID: 2067
		// (get) Token: 0x060148ED RID: 84205 RVA: 0x005C2874 File Offset: 0x005C0A74
		// (set) Token: 0x060148F7 RID: 84215 RVA: 0x005C2AA8 File Offset: 0x005C0CA8
		public string OCAHLHMIPMG { get; protected set; }

		// Token: 0x060148EE RID: 84206 RVA: 0x005C287C File Offset: 0x005C0A7C
		private IEnumerator MGHAHLHAGEA(AmplitudeAnalyticsClient.HMNOJGLGGFL IIKEGHAGJBD, string KFBLNOCKOND, string NFEDJLINGJO, float ABPJFFBGJBF, Action<int> JMENCIHGALD)
		{
			AmplitudeAnalyticsClient.CNPJKMOMLBD.MMNEHJIACIP mmnehjiacip = new AmplitudeAnalyticsClient.CNPJKMOMLBD.MMNEHJIACIP();
			mmnehjiacip.PNDHCMIJLFP = this;
			mmnehjiacip.IIKEGHAGJBD = IIKEGHAGJBD;
			mmnehjiacip.JMENCIHGALD = JMENCIHGALD;
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				yield break;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			mmnehjiacip.PLHLJCMOJLF = false;
			bool flag = false;
			int num = 0;
			List<Dictionary<string, object>> list;
			while ((list = mmnehjiacip.IIKEGHAGJBD.JDIKEKDENFC(10)) != null && !mmnehjiacip.PLHLJCMOJLF && !(flag = this.IAFHAJNECLC(realtimeSinceStartup, ABPJFFBGJBF)))
			{
				num = list.Count;
				yield return this.KMPIFMEFBDI<List<Dictionary<string, object>>>(KFBLNOCKOND, NFEDJLINGJO, list, new Action<long, string, List<Dictionary<string, object>>>(mmnehjiacip.OJKNBNGGBEC));
			}
			if (num > 0 && this.settings.verboseLogging)
			{
				global::UnityEngine.Debug.Log(string.Format("[{0}] Flush complete: {1} events sent {2} to \"{3}\". Finished with error: {4}. TimedOut: {5}", new object[]
				{
					string.Format("{0:s}", DateTime.Now),
					num,
					(!mmnehjiacip.PLHLJCMOJLF && !flag) ? "successfully" : "unsuccessfully",
					NFEDJLINGJO,
					mmnehjiacip.PLHLJCMOJLF,
					flag
				}));
			}
			yield break;
		}

		// Token: 0x060148EF RID: 84207 RVA: 0x005C28BC File Offset: 0x005C0ABC
		public void LogIdentifyAsync(AmplitudeAnalyticsIdentifyMessage CNCCFANFOFL)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return;
			}
			if (!this.NOCJONDDHEF)
			{
				throw new InvalidOperationException("You must initialize before you can log events");
			}
			AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI.CKIGELMEJKE(CNCCFANFOFL, false);
		}

		// Token: 0x060148F0 RID: 84208 RVA: 0x005C28EC File Offset: 0x005C0AEC
		public IEnumerator BCBJHEKAMJF(AmplitudeAnalyticsEvent OANNBDIPLBL)
		{
			yield return this.LCBAIAEDJOD(-1f);
			this.NOCJONDDHEF = true;
			this.LogEventAsync(OANNBDIPLBL);
			yield break;
		}

		// Token: 0x060148F1 RID: 84209 RVA: 0x005C2910 File Offset: 0x005C0B10
		private IEnumerator CICKMMBPIFM(float ABPJFFBGJBF = -1f)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				yield break;
			}
			this.ECMAEOCMHDA = true;
			this.EEEJIHJEIJH = Time.realtimeSinceStartup;
			cibkapobppi = AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI;
			identifyApiURL = this.settings.identifyApiURL;
			AmplitudeAnalyticsClient.HMNOJGLGGFL hmnojglggfl = cibkapobppi;
			string text = identifyApiURL;
			string text2 = "identification";
			if (AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI == null)
			{
				AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI = new Action<int>(AmplitudeAnalyticsClient.KGOIBDBEGGO.OJKNBNGGBEC);
			}
			yield return this.MGHAHLHAGEA(hmnojglggfl, text, text2, ABPJFFBGJBF, AmplitudeAnalyticsClient.KGOIBDBEGGO.DINNJGHCFHI);
			this.ECMAEOCMHDA = false;
			yield break;
		}

		// Token: 0x060148F2 RID: 84210 RVA: 0x005C2934 File Offset: 0x005C0B34
		private void MOHFAAOOCEB()
		{
			this.GNLDNCELBBB();
		}

		// Token: 0x060148F3 RID: 84211 RVA: 0x005C293C File Offset: 0x005C0B3C
		private void EEPEOCMOGIL()
		{
			if (!this.NOCJONDDHEF)
			{
				return;
			}
			this.MLOBNKNBNEG += Time.deltaTime;
			if (this.MLOBNKNBNEG >= 224f)
			{
				this.KHBMAFKJKNA = 1;
				this.NBDNLGAOENP = 0;
				this.MLOBNKNBNEG = 1162f;
			}
			if (!this.FNJPEPLCIJK && (Time.realtimeSinceStartup >= this.HGCEDADADPF + this.settings.BatchIntervalSeconds || AmplitudeAnalyticsClient.HMNOJGLGGFL.BBPNJLFGBMN.JDCOFHNJMKA() >= -76))
			{
				base.StartCoroutine(this.LCBAIAEDJOD(1911f));
			}
			if (!this.ECMAEOCMHDA && (Time.realtimeSinceStartup + this.settings.BatchIntervalSeconds / 73f >= this.EEEJIHJEIJH + this.settings.BatchIntervalSeconds || AmplitudeAnalyticsClient.HMNOJGLGGFL.CIBKAPOBPPI.AJMFEHJCLLM() >= 73))
			{
				base.StartCoroutine(this.EDIAOPLKEEI(685f));
			}
		}

		// Token: 0x060148F4 RID: 84212 RVA: 0x005C2A38 File Offset: 0x005C0C38
		private IEnumerator ALNKEAIFENJ()
		{
			num = 3f;
			this.AICPKFBPFKN = AmplitudeAnalyticsClient.BBAPHFJEPFM.WaitingForFlush;
			yield return this.WaitForFlush(num);
			this.AICPKFBPFKN = AmplitudeAnalyticsClient.BBAPHFJEPFM.Flushed;
			Application.Quit();
			yield break;
		}

		// Token: 0x060148F5 RID: 84213 RVA: 0x005C2A54 File Offset: 0x005C0C54
		public IEnumerator LGJAFEIIILN(float ABPJFFBGJBF = 30f)
		{
			while (this.FNJPEPLCIJK && ABPJFFBGJBF > 0f)
			{
				ABPJFFBGJBF -= Time.unscaledDeltaTime;
				yield return null;
			}
			while (this.ECMAEOCMHDA && ABPJFFBGJBF > 0f)
			{
				ABPJFFBGJBF -= Time.unscaledDeltaTime;
				yield return null;
			}
			yield return this.LCBAIAEDJOD(ABPJFFBGJBF);
			yield break;
		}

		// Token: 0x060148F6 RID: 84214 RVA: 0x005C2A78 File Offset: 0x005C0C78
		public static long KPEPBELNKDM()
		{
			return (long)(DateTime.UtcNow - new DateTime(8, 0, 0, 1, 0, 1, DateTimeKind.Unspecified)).TotalMilliseconds;
		}

		// Token: 0x060148F8 RID: 84216 RVA: 0x005C2AB4 File Offset: 0x005C0CB4
		public void LogEventAsync(AmplitudeAnalyticsEvent LDMDLNHJKMC)
		{
			if (!AmplitudeAnalyticsClient.IsEnabled)
			{
				return;
			}
			if (!this.NOCJONDDHEF)
			{
				throw new InvalidOperationException("You must initialize before you can log events");
			}
			AmplitudeAnalyticsClient.HMNOJGLGGFL.BBPNJLFGBMN.CKIGELMEJKE(LDMDLNHJKMC, false);
		}

		// Token: 0x060148F9 RID: 84217 RVA: 0x005C2AE4 File Offset: 0x005C0CE4
		public static long IHHFDHDLEJG()
		{
			return AmplitudeAnalyticsClient.FLKDLBJBFNL;
		}

		// Token: 0x060148FA RID: 84218 RVA: 0x005C2AEC File Offset: 0x005C0CEC
		public static long ODNMAIDNCEA()
		{
			return AmplitudeAnalyticsClient.FLKDLBJBFNL;
		}

		// Token: 0x040038BB RID: 14523
		public static readonly bool IsEnabled = true;

		// Token: 0x040038BC RID: 14524
		private const string FODACDCHOBN = "event";

		// Token: 0x040038BD RID: 14525
		private const string FMOAFJCDNFE = "identification";

		// Token: 0x040038BF RID: 14527
		[SerializeField]
		private AmplitudeAnalyticsClient.Settings settings;

		// Token: 0x040038C0 RID: 14528
		private bool NOCJONDDHEF;

		// Token: 0x040038C1 RID: 14529
		private bool CJHOAJEAABA;

		// Token: 0x040038C2 RID: 14530
		private float HGCEDADADPF = float.MinValue;

		// Token: 0x040038C3 RID: 14531
		private float EEEJIHJEIJH = float.MinValue;

		// Token: 0x040038C5 RID: 14533
		private AmplitudeAnalyticsClient.BBAPHFJEPFM AICPKFBPFKN;

		// Token: 0x040038C6 RID: 14534
		private static long FLKDLBJBFNL = -1L;

		// Token: 0x040038C7 RID: 14535
		private int KHBMAFKJKNA;

		// Token: 0x040038C8 RID: 14536
		private int NBDNLGAOENP;

		// Token: 0x040038C9 RID: 14537
		private float MLOBNKNBNEG;

		// Token: 0x040038CA RID: 14538
		private bool FNJPEPLCIJK;

		// Token: 0x040038CB RID: 14539
		private bool ECMAEOCMHDA;

		// Token: 0x040038CC RID: 14540
		private const long BFEOEIFBMBF = -1L;

		// Token: 0x040038CD RID: 14541
		[CompilerGenerated]
		private static Action<long, string, Dictionary<string, object>> DINNJGHCFHI;

		// Token: 0x02000A85 RID: 2693
		private enum BBAPHFJEPFM
		{
			// Token: 0x040038CF RID: 14543
			Running,
			// Token: 0x040038D0 RID: 14544
			WaitingForFlush,
			// Token: 0x040038D1 RID: 14545
			Flushed
		}

		// Token: 0x02000A86 RID: 2694
		private class HMNOJGLGGFL
		{
			// Token: 0x060148FB RID: 84219 RVA: 0x005C2AF4 File Offset: 0x005C0CF4
			public void GAKHAHFKJPK(List<Dictionary<string, object>> DMGIKPJMFMB)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				foreach (Dictionary<string, object> dictionary in DMGIKPJMFMB)
				{
					this.BHDMIDCCEJM(dictionary, true);
				}
				this.ELPCBEBAEAH();
			}

			// Token: 0x060148FC RID: 84220 RVA: 0x005C2B60 File Offset: 0x005C0D60
			public void BANMMHIELCJ(List<Dictionary<string, object>> DMGIKPJMFMB)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				foreach (Dictionary<string, object> dictionary in DMGIKPJMFMB)
				{
					this.DGIMGHGPCHA(dictionary, false);
				}
				this.ELPCBEBAEAH();
			}

			// Token: 0x060148FD RID: 84221 RVA: 0x005C2BCC File Offset: 0x005C0DCC
			public void KKPEBEKBEKC()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				string text = HOEKEPDDBBF.DNGBHIBIGLN(this.NEEHDOAJFKE);
				PlayerPrefs.SetString(this.PJGPPBNPGFD, text);
				PlayerPrefs.Save();
			}

			// Token: 0x060148FE RID: 84222 RVA: 0x005C2C04 File Offset: 0x005C0E04
			public void GDNIPJPIPMC(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Add(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.KKPEBEKBEKC();
				}
			}

			// Token: 0x060148FF RID: 84223 RVA: 0x005C2C2C File Offset: 0x005C0E2C
			public void NPAGGHAAPKP(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Add(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.KKPEBEKBEKC();
				}
			}

			// Token: 0x06014900 RID: 84224 RVA: 0x005C2C54 File Offset: 0x005C0E54
			public void DNNJOMHBPLG(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.HKBOKCFAPBB();
				}
			}

			// Token: 0x06014901 RID: 84225 RVA: 0x005C2C7C File Offset: 0x005C0E7C
			public void MNLLACEENPL(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.GOOPOPEBIKK();
				}
			}

			// Token: 0x06014902 RID: 84226 RVA: 0x005C2CA4 File Offset: 0x005C0EA4
			public void EIJOEDEAEOK(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.ELPCBEBAEAH();
				}
			}

			// Token: 0x06014903 RID: 84227 RVA: 0x005C2CCC File Offset: 0x005C0ECC
			public void JHHJIDDNGAK(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.ELPCBEBAEAH();
				}
			}

			// Token: 0x06014904 RID: 84228 RVA: 0x005C2CF4 File Offset: 0x005C0EF4
			public int AJMFEHJCLLM()
			{
				return this.NEEHDOAJFKE.Count;
			}

			// Token: 0x06014905 RID: 84229 RVA: 0x005C2D04 File Offset: 0x005C0F04
			public void AAGFINPOEHA()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				try
				{
					string @string = PlayerPrefs.GetString(this.PJGPPBNPGFD);
					if (!string.IsNullOrEmpty(@string))
					{
						List<object> list = HOEKEPDDBBF.DKMOHDIJHAE(@string) as List<object>;
						if (list == null)
						{
							throw new InvalidCastException("modify/description");
						}
						foreach (object obj in list)
						{
							Dictionary<string, object> dictionary = obj as Dictionary<string, object>;
							this.NEEHDOAJFKE.Add(dictionary);
						}
					}
				}
				catch (Exception ex)
				{
					global::UnityEngine.Debug.LogException(ex);
					PlayerPrefs.DeleteKey(this.PJGPPBNPGFD);
					AmplitudeAnalyticsClient.Event("Ch1hY3Rpdml0eV9lcXVpcG1lbnRfZGF0YS5wcm90bxIHcmVjcm9vbSIqChVB").PFNEDMJJALA();
				}
			}

			// Token: 0x06014906 RID: 84230 RVA: 0x005C2DEC File Offset: 0x005C0FEC
			public void LNOPONOLOPH(AmplitudeAnalyticsIdentifyMessage INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.GDNIPJPIPMC(INNGECIOBOO.OKMGACFMDFI(), MIDPGKBAEJL);
			}

			// Token: 0x06014907 RID: 84231 RVA: 0x005C2E08 File Offset: 0x005C1008
			public void AKNDMDIIDKM()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				try
				{
					string @string = PlayerPrefs.GetString(this.PJGPPBNPGFD);
					if (!string.IsNullOrEmpty(@string))
					{
						List<object> list = HOEKEPDDBBF.DKMOHDIJHAE(@string) as List<object>;
						if (list == null)
						{
							throw new InvalidCastException("Proxy-Connection");
						}
						foreach (object obj in list)
						{
							Dictionary<string, object> dictionary = obj as Dictionary<string, object>;
							this.NEEHDOAJFKE.Add(dictionary);
						}
					}
				}
				catch (Exception ex)
				{
					global::UnityEngine.Debug.LogException(ex);
					PlayerPrefs.DeleteKey(this.PJGPPBNPGFD);
					AmplitudeAnalyticsClient.Event("type").PFNEDMJJALA();
				}
			}

			// Token: 0x06014908 RID: 84232 RVA: 0x005C2EF0 File Offset: 0x005C10F0
			private HMNOJGLGGFL(string PJGPPBNPGFD)
			{
				this.PJGPPBNPGFD = PJGPPBNPGFD;
			}

			// Token: 0x0601490A RID: 84234 RVA: 0x005C2F2C File Offset: 0x005C112C
			public List<Dictionary<string, object>> MLODINMGNHB(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 0)
				{
					return this.NEEHDOAJFKE.GetRange(1, num);
				}
				return null;
			}

			// Token: 0x0601490B RID: 84235 RVA: 0x005C2F70 File Offset: 0x005C1170
			public List<Dictionary<string, object>> JDIKEKDENFC(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 0)
				{
					return this.NEEHDOAJFKE.GetRange(0, num);
				}
				return null;
			}

			// Token: 0x0601490C RID: 84236 RVA: 0x005C2FB4 File Offset: 0x005C11B4
			public List<Dictionary<string, object>> ONDDNGDHHHP(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 1)
				{
					return this.NEEHDOAJFKE.GetRange(0, num);
				}
				return null;
			}

			// Token: 0x0601490D RID: 84237 RVA: 0x005C2FF8 File Offset: 0x005C11F8
			public void DGIMGHGPCHA(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.ELPCBEBAEAH();
				}
			}

			// Token: 0x0601490E RID: 84238 RVA: 0x005C3020 File Offset: 0x005C1220
			public void FHNIAOGOEOH(List<Dictionary<string, object>> DMGIKPJMFMB)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				foreach (Dictionary<string, object> dictionary in DMGIKPJMFMB)
				{
					this.IOAAEKILPKK(dictionary, false);
				}
				this.GOOPOPEBIKK();
			}

			// Token: 0x0601490F RID: 84239 RVA: 0x005C308C File Offset: 0x005C128C
			public void HKBOKCFAPBB()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				string text = HOEKEPDDBBF.DNGBHIBIGLN(this.NEEHDOAJFKE);
				PlayerPrefs.SetString(this.PJGPPBNPGFD, text);
				PlayerPrefs.Save();
			}

			// Token: 0x06014910 RID: 84240 RVA: 0x005C30C4 File Offset: 0x005C12C4
			public void CAJADDGHBFJ(AmplitudeAnalyticsIdentifyMessage INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.MFOFDKALKDI(INNGECIOBOO.ICMFBONNCHO(), MIDPGKBAEJL);
			}

			// Token: 0x06014911 RID: 84241 RVA: 0x005C30E0 File Offset: 0x005C12E0
			public void KOJFGMBIEJE()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				try
				{
					string @string = PlayerPrefs.GetString(this.PJGPPBNPGFD);
					if (!string.IsNullOrEmpty(@string))
					{
						List<object> list = HOEKEPDDBBF.DKMOHDIJHAE(@string) as List<object>;
						if (list == null)
						{
							throw new InvalidCastException("Expected a list of objects, got null");
						}
						foreach (object obj in list)
						{
							Dictionary<string, object> dictionary = obj as Dictionary<string, object>;
							this.NEEHDOAJFKE.Add(dictionary);
						}
					}
				}
				catch (Exception ex)
				{
					global::UnityEngine.Debug.LogException(ex);
					PlayerPrefs.DeleteKey(this.PJGPPBNPGFD);
					AmplitudeAnalyticsClient.Event("Amplitude_DiskLoad_failed").PFNEDMJJALA();
				}
			}

			// Token: 0x06014912 RID: 84242 RVA: 0x005C31C8 File Offset: 0x005C13C8
			public void GHBOCJDMENG(AmplitudeAnalyticsIdentifyMessage INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.MLKBBOPADNH(INNGECIOBOO.DCJBHHNDCKI(), MIDPGKBAEJL);
			}

			// Token: 0x06014913 RID: 84243 RVA: 0x005C31E4 File Offset: 0x005C13E4
			public void AOPMCNGBNND()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				try
				{
					string @string = PlayerPrefs.GetString(this.PJGPPBNPGFD);
					if (!string.IsNullOrEmpty(@string))
					{
						List<object> list = HOEKEPDDBBF.DKMOHDIJHAE(@string) as List<object>;
						if (list == null)
						{
							throw new InvalidCastException("Failed to load render model {0} - {1}");
						}
						foreach (object obj in list)
						{
							Dictionary<string, object> dictionary = obj as Dictionary<string, object>;
							this.NEEHDOAJFKE.Add(dictionary);
						}
					}
				}
				catch (Exception ex)
				{
					global::UnityEngine.Debug.LogException(ex);
					PlayerPrefs.DeleteKey(this.PJGPPBNPGFD);
					AmplitudeAnalyticsClient.Event("VirtualButtonPressedRight").PFNEDMJJALA();
				}
			}

			// Token: 0x06014914 RID: 84244 RVA: 0x005C32CC File Offset: 0x005C14CC
			public void CDMNIBCHPLI(List<Dictionary<string, object>> DMGIKPJMFMB)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				foreach (Dictionary<string, object> dictionary in DMGIKPJMFMB)
				{
					this.IOAAEKILPKK(dictionary, true);
				}
				this.HKBOKCFAPBB();
			}

			// Token: 0x06014915 RID: 84245 RVA: 0x005C3338 File Offset: 0x005C1538
			public void CFMFELICMBD(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Add(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.KKPEBEKBEKC();
				}
			}

			// Token: 0x06014916 RID: 84246 RVA: 0x005C3360 File Offset: 0x005C1560
			public int PPPKFCJPFGK()
			{
				return this.NEEHDOAJFKE.Count;
			}

			// Token: 0x06014917 RID: 84247 RVA: 0x005C3370 File Offset: 0x005C1570
			public int PINOCEKCEEN()
			{
				return this.NEEHDOAJFKE.Count;
			}

			// Token: 0x06014918 RID: 84248 RVA: 0x005C3380 File Offset: 0x005C1580
			public List<Dictionary<string, object>> EKFEHCDJLOB(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 1)
				{
					return this.NEEHDOAJFKE.GetRange(1, num);
				}
				return null;
			}

			// Token: 0x06014919 RID: 84249 RVA: 0x005C33C4 File Offset: 0x005C15C4
			public void MLKBBOPADNH(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Add(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.KKPEBEKBEKC();
				}
			}

			// Token: 0x0601491A RID: 84250 RVA: 0x005C33EC File Offset: 0x005C15EC
			public List<Dictionary<string, object>> BDCABFDJFJM(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 0)
				{
					return this.NEEHDOAJFKE.GetRange(0, num);
				}
				return null;
			}

			// Token: 0x0601491B RID: 84251 RVA: 0x005C3430 File Offset: 0x005C1630
			public void OFIEAHFEJNA(List<Dictionary<string, object>> DMGIKPJMFMB)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				foreach (Dictionary<string, object> dictionary in DMGIKPJMFMB)
				{
					this.EIJOEDEAEOK(dictionary, true);
				}
				this.ELPCBEBAEAH();
			}

			// Token: 0x0601491C RID: 84252 RVA: 0x005C349C File Offset: 0x005C169C
			public List<Dictionary<string, object>> DAFNODJFDOK(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 0)
				{
					return this.NEEHDOAJFKE.GetRange(1, num);
				}
				return null;
			}

			// Token: 0x0601491D RID: 84253 RVA: 0x005C34E0 File Offset: 0x005C16E0
			public void CPKKBJIJEPI(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.GOOPOPEBIKK();
				}
			}

			// Token: 0x0601491E RID: 84254 RVA: 0x005C3508 File Offset: 0x005C1708
			public void KGFCHDAFABB(List<Dictionary<string, object>> DMGIKPJMFMB)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				foreach (Dictionary<string, object> dictionary in DMGIKPJMFMB)
				{
					this.EIJOEDEAEOK(dictionary, true);
				}
				this.ELPCBEBAEAH();
			}

			// Token: 0x0601491F RID: 84255 RVA: 0x005C3574 File Offset: 0x005C1774
			public List<Dictionary<string, object>> MNPHCNPEBPJ(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 0)
				{
					return this.NEEHDOAJFKE.GetRange(1, num);
				}
				return null;
			}

			// Token: 0x06014920 RID: 84256 RVA: 0x005C35B8 File Offset: 0x005C17B8
			public void BHDMIDCCEJM(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.HKBOKCFAPBB();
				}
			}

			// Token: 0x06014921 RID: 84257 RVA: 0x005C35E0 File Offset: 0x005C17E0
			public void PKGCJBJJCKB()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				try
				{
					string @string = PlayerPrefs.GetString(this.PJGPPBNPGFD);
					if (!string.IsNullOrEmpty(@string))
					{
						List<object> list = HOEKEPDDBBF.DKMOHDIJHAE(@string) as List<object>;
						if (list == null)
						{
							throw new InvalidCastException("orienttopath");
						}
						foreach (object obj in list)
						{
							Dictionary<string, object> dictionary = obj as Dictionary<string, object>;
							this.NEEHDOAJFKE.Add(dictionary);
						}
					}
				}
				catch (Exception ex)
				{
					global::UnityEngine.Debug.LogException(ex);
					PlayerPrefs.DeleteKey(this.PJGPPBNPGFD);
					AmplitudeAnalyticsClient.Event("Checklist button error: ").PFNEDMJJALA();
				}
			}

			// Token: 0x06014922 RID: 84258 RVA: 0x005C36C8 File Offset: 0x005C18C8
			public void MFOFDKALKDI(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Add(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.KKPEBEKBEKC();
				}
			}

			// Token: 0x06014923 RID: 84259 RVA: 0x005C36F0 File Offset: 0x005C18F0
			public void GAGJPMFIGKK(AmplitudeAnalyticsIdentifyMessage INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.MLKBBOPADNH(INNGECIOBOO.BHAPHOFDEHG(), MIDPGKBAEJL);
			}

			// Token: 0x06014924 RID: 84260 RVA: 0x005C370C File Offset: 0x005C190C
			public int JDCOFHNJMKA()
			{
				return this.NEEHDOAJFKE.Count;
			}

			// Token: 0x06014925 RID: 84261 RVA: 0x005C371C File Offset: 0x005C191C
			public List<Dictionary<string, object>> DPNNBGCPMOK(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 1)
				{
					return this.NEEHDOAJFKE.GetRange(1, num);
				}
				return null;
			}

			// Token: 0x17000816 RID: 2070
			// (get) Token: 0x06014926 RID: 84262 RVA: 0x005C3760 File Offset: 0x005C1960
			public int PFMKGBAKMMM
			{
				get
				{
					return this.NEEHDOAJFKE.Count;
				}
			}

			// Token: 0x06014927 RID: 84263 RVA: 0x005C3770 File Offset: 0x005C1970
			public void MBKILBDCFMO()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				try
				{
					string @string = PlayerPrefs.GetString(this.PJGPPBNPGFD);
					if (!string.IsNullOrEmpty(@string))
					{
						List<object> list = HOEKEPDDBBF.DKMOHDIJHAE(@string) as List<object>;
						if (list == null)
						{
							throw new InvalidCastException("ShowTeleportHint");
						}
						foreach (object obj in list)
						{
							Dictionary<string, object> dictionary = obj as Dictionary<string, object>;
							this.NEEHDOAJFKE.Add(dictionary);
						}
					}
				}
				catch (Exception ex)
				{
					global::UnityEngine.Debug.LogException(ex);
					PlayerPrefs.DeleteKey(this.PJGPPBNPGFD);
					AmplitudeAnalyticsClient.Event("easetype").PFNEDMJJALA();
				}
			}

			// Token: 0x06014928 RID: 84264 RVA: 0x005C3858 File Offset: 0x005C1A58
			public List<Dictionary<string, object>> NGCCIEKKNPF(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 0)
				{
					return this.NEEHDOAJFKE.GetRange(1, num);
				}
				return null;
			}

			// Token: 0x06014929 RID: 84265 RVA: 0x005C389C File Offset: 0x005C1A9C
			public void KMFHJMBMMFP(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.GOOPOPEBIKK();
				}
			}

			// Token: 0x0601492A RID: 84266 RVA: 0x005C38C4 File Offset: 0x005C1AC4
			public List<Dictionary<string, object>> MPIGKNAALDD(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 0)
				{
					return this.NEEHDOAJFKE.GetRange(0, num);
				}
				return null;
			}

			// Token: 0x0601492B RID: 84267 RVA: 0x005C3908 File Offset: 0x005C1B08
			public void AJMHDLDBFJJ(AmplitudeAnalyticsIdentifyMessage INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.PIEPLMCPECB(INNGECIOBOO.OKMGACFMDFI(), MIDPGKBAEJL);
			}

			// Token: 0x0601492C RID: 84268 RVA: 0x005C3924 File Offset: 0x005C1B24
			public List<Dictionary<string, object>> GKNDNGIGLMG(int HLCIHFKLBFJ)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return null;
				}
				int num = Mathf.Min(HLCIHFKLBFJ, this.NEEHDOAJFKE.Count);
				if (num > 0)
				{
					return this.NEEHDOAJFKE.GetRange(1, num);
				}
				return null;
			}

			// Token: 0x0601492D RID: 84269 RVA: 0x005C3968 File Offset: 0x005C1B68
			public void BKHDGOPKANC(List<Dictionary<string, object>> DMGIKPJMFMB)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				foreach (Dictionary<string, object> dictionary in DMGIKPJMFMB)
				{
					this.MNLLACEENPL(dictionary, false);
				}
				this.KKPEBEKBEKC();
			}

			// Token: 0x0601492E RID: 84270 RVA: 0x005C39D4 File Offset: 0x005C1BD4
			public void IOAAEKILPKK(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Remove(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.KKPEBEKBEKC();
				}
			}

			// Token: 0x0601492F RID: 84271 RVA: 0x005C39FC File Offset: 0x005C1BFC
			public int MIGGLFKEINC()
			{
				return this.NEEHDOAJFKE.Count;
			}

			// Token: 0x06014930 RID: 84272 RVA: 0x005C3A0C File Offset: 0x005C1C0C
			public void CKIGELMEJKE(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Add(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.ELPCBEBAEAH();
				}
			}

			// Token: 0x06014931 RID: 84273 RVA: 0x005C3A34 File Offset: 0x005C1C34
			public void KFMMNLKBECG(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Add(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.HKBOKCFAPBB();
				}
			}

			// Token: 0x06014932 RID: 84274 RVA: 0x005C3A5C File Offset: 0x005C1C5C
			public void HENMPHFABLM()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				try
				{
					string @string = PlayerPrefs.GetString(this.PJGPPBNPGFD);
					if (!string.IsNullOrEmpty(@string))
					{
						List<object> list = HOEKEPDDBBF.DKMOHDIJHAE(@string) as List<object>;
						if (list == null)
						{
							throw new InvalidCastException("Delete");
						}
						foreach (object obj in list)
						{
							Dictionary<string, object> dictionary = obj as Dictionary<string, object>;
							this.NEEHDOAJFKE.Add(dictionary);
						}
					}
				}
				catch (Exception ex)
				{
					global::UnityEngine.Debug.LogException(ex);
					PlayerPrefs.DeleteKey(this.PJGPPBNPGFD);
					AmplitudeAnalyticsClient.Event("+gamesession:").PFNEDMJJALA();
				}
			}

			// Token: 0x06014933 RID: 84275 RVA: 0x005C3B44 File Offset: 0x005C1D44
			public int FJAECKHMKCH()
			{
				return this.NEEHDOAJFKE.Count;
			}

			// Token: 0x06014934 RID: 84276 RVA: 0x005C3B54 File Offset: 0x005C1D54
			public void PIEPLMCPECB(Dictionary<string, object> INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.NEEHDOAJFKE.Add(INNGECIOBOO);
				if (!MIDPGKBAEJL)
				{
					this.KKPEBEKBEKC();
				}
			}

			// Token: 0x06014935 RID: 84277 RVA: 0x005C3B7C File Offset: 0x005C1D7C
			public void KKJMEPMOACG(AmplitudeAnalyticsIdentifyMessage INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.PIEPLMCPECB(INNGECIOBOO.OKMGACFMDFI(), MIDPGKBAEJL);
			}

			// Token: 0x06014936 RID: 84278 RVA: 0x005C3B98 File Offset: 0x005C1D98
			public void CKIGELMEJKE(AmplitudeAnalyticsIdentifyMessage INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.CKIGELMEJKE(INNGECIOBOO.ICMFBONNCHO(), MIDPGKBAEJL);
			}

			// Token: 0x06014937 RID: 84279 RVA: 0x005C3BB4 File Offset: 0x005C1DB4
			public void GOOPOPEBIKK()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				string text = HOEKEPDDBBF.DNGBHIBIGLN(this.NEEHDOAJFKE);
				PlayerPrefs.SetString(this.PJGPPBNPGFD, text);
				PlayerPrefs.Save();
			}

			// Token: 0x06014938 RID: 84280 RVA: 0x005C3BEC File Offset: 0x005C1DEC
			public void INIFHDPMHCE(AmplitudeAnalyticsIdentifyMessage INNGECIOBOO, bool MIDPGKBAEJL = false)
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				this.CKIGELMEJKE(INNGECIOBOO.ICMFBONNCHO(), MIDPGKBAEJL);
			}

			// Token: 0x06014939 RID: 84281 RVA: 0x005C3C08 File Offset: 0x005C1E08
			public int BHIADLJCDJE()
			{
				return this.NEEHDOAJFKE.Count;
			}

			// Token: 0x0601493A RID: 84282 RVA: 0x005C3C18 File Offset: 0x005C1E18
			public void ELPCBEBAEAH()
			{
				if (!AmplitudeAnalyticsClient.IsEnabled)
				{
					return;
				}
				string text = HOEKEPDDBBF.DNGBHIBIGLN(this.NEEHDOAJFKE);
				PlayerPrefs.SetString(this.PJGPPBNPGFD, text);
				PlayerPrefs.Save();
			}

			// Token: 0x040038D2 RID: 14546
			private const string DHEDMDPHPDI = "queued_events";

			// Token: 0x040038D3 RID: 14547
			private const string DMLHGHJBJMJ = "queued_identify";

			// Token: 0x040038D4 RID: 14548
			public static AmplitudeAnalyticsClient.HMNOJGLGGFL BBPNJLFGBMN = new AmplitudeAnalyticsClient.HMNOJGLGGFL("queued_events");

			// Token: 0x040038D5 RID: 14549
			public static AmplitudeAnalyticsClient.HMNOJGLGGFL CIBKAPOBPPI = new AmplitudeAnalyticsClient.HMNOJGLGGFL("queued_identify");

			// Token: 0x040038D6 RID: 14550
			private List<Dictionary<string, object>> NEEHDOAJFKE = new List<Dictionary<string, object>>();

			// Token: 0x040038D7 RID: 14551
			private readonly string PJGPPBNPGFD;
		}

		// Token: 0x02000A87 RID: 2695
		[Serializable]
		public class Settings
		{
			// Token: 0x040038D8 RID: 14552
			[FormerlySerializedAs("ApiURL")]
			public string eventApiURL;

			// Token: 0x040038D9 RID: 14553
			public string identifyApiURL;

			// Token: 0x040038DA RID: 14554
			public float BatchIntervalSeconds = 30f;

			// Token: 0x040038DB RID: 14555
			public bool verboseLogging;
		}
	}
}