using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using UnityEngine;
using UnityEngine.AI;

namespace Valve.VR.InteractionSystem
{
	// Token: 0x020005DB RID: 1499
	public static class OFPFHHLNHIC
	{
		// Token: 0x0600EE04 RID: 60932 RVA: 0x00471658 File Offset: 0x0046F858
		public static float DNNJGEBICKH(float KCKJDFMJNFO, float KADFJBOMBIN, float FDMEAJDJDNK, float COMNKILGNCK, float EBBLBCIAHMJ)
		{
			return COMNKILGNCK + (KCKJDFMJNFO - KADFJBOMBIN) * (EBBLBCIAHMJ - COMNKILGNCK) / (FDMEAJDJDNK - KADFJBOMBIN);
		}

		// Token: 0x0600EE05 RID: 60933 RVA: 0x00471668 File Offset: 0x0046F868
		public static float DKPCDKNIGLJ(float KCKJDFMJNFO, float KADFJBOMBIN, float FDMEAJDJDNK, float COMNKILGNCK, float EBBLBCIAHMJ)
		{
			return Mathf.Clamp(OFPFHHLNHIC.DNNJGEBICKH(KCKJDFMJNFO, KADFJBOMBIN, FDMEAJDJDNK, COMNKILGNCK, EBBLBCIAHMJ), Mathf.Min(COMNKILGNCK, EBBLBCIAHMJ), Mathf.Max(COMNKILGNCK, EBBLBCIAHMJ));
		}

		// Token: 0x0600EE06 RID: 60934 RVA: 0x0047168C File Offset: 0x0046F88C
		public static float JJFNNGDDBGI(float MMEBLCBANIL, float NOBAPCOKFIL, float BGJNLBNEINL)
		{
			float num = MMEBLCBANIL - NOBAPCOKFIL;
			if (num > BGJNLBNEINL)
			{
				NOBAPCOKFIL += BGJNLBNEINL;
			}
			else if (num < -BGJNLBNEINL)
			{
				NOBAPCOKFIL -= BGJNLBNEINL;
			}
			else
			{
				NOBAPCOKFIL = MMEBLCBANIL;
			}
			return NOBAPCOKFIL;
		}

		// Token: 0x0600EE07 RID: 60935 RVA: 0x004716C4 File Offset: 0x0046F8C4
		public static Vector3 ECLNMBHNLNI(Vector3 NDGGMDGOPHJ, Vector3 PLOEDBBOLCB, Vector3 MLOLFOOLJMF, float LHMELEOKNBJ)
		{
			Vector3 vector = Vector3.Lerp(NDGGMDGOPHJ, PLOEDBBOLCB, LHMELEOKNBJ);
			Vector3 vector2 = Vector3.Lerp(PLOEDBBOLCB, MLOLFOOLJMF, LHMELEOKNBJ);
			return Vector3.Lerp(vector, vector2, LHMELEOKNBJ);
		}

		// Token: 0x0600EE08 RID: 60936 RVA: 0x004716EC File Offset: 0x0046F8EC
		public static Vector3 PGIKIFIACDD(Vector3 NDGGMDGOPHJ, Vector3 PLOEDBBOLCB, Vector3 INEJAMKNCNJ, Vector3 MLOLFOOLJMF, float LHMELEOKNBJ)
		{
			Vector3 vector = Vector3.Lerp(NDGGMDGOPHJ, PLOEDBBOLCB, LHMELEOKNBJ);
			Vector3 vector2 = Vector3.Lerp(PLOEDBBOLCB, INEJAMKNCNJ, LHMELEOKNBJ);
			Vector3 vector3 = Vector3.Lerp(INEJAMKNCNJ, MLOLFOOLJMF, LHMELEOKNBJ);
			Vector3 vector4 = Vector3.Lerp(vector, vector2, LHMELEOKNBJ);
			Vector3 vector5 = Vector3.Lerp(vector2, vector3, LHMELEOKNBJ);
			return Vector3.Lerp(vector4, vector5, LHMELEOKNBJ);
		}

		// Token: 0x0600EE09 RID: 60937 RVA: 0x00471738 File Offset: 0x0046F938
		public static Vector3 PMJHFLAFNBL(string KCFHHIBIECA)
		{
			string[] array = KCFHHIBIECA.Substring(1, KCFHHIBIECA.Length - 1).Split(new char[] { ',' });
			float num = float.Parse(array[0]);
			float num2 = float.Parse(array[1]);
			float num3 = float.Parse(array[2]);
			Vector3 vector = new Vector3(num, num2, num3);
			return vector;
		}

		// Token: 0x0600EE0A RID: 60938 RVA: 0x0047178C File Offset: 0x0046F98C
		public static Vector2 BFKBCLHGDPH(string KCFHHIBIECA)
		{
			string[] array = KCFHHIBIECA.Substring(1, KCFHHIBIECA.Length - 1).Split(new char[] { ',' });
			float num = float.Parse(array[0]);
			float num2 = float.Parse(array[1]);
			Vector3 vector = new Vector2(num, num2);
			return vector;
		}

		// Token: 0x0600EE0B RID: 60939 RVA: 0x004717E0 File Offset: 0x0046F9E0
		public static float JNJGNFPDHKC(float NOBAPCOKFIL, float MLCNKHEEDNL, float EGIPNAJLAGN)
		{
			return (NOBAPCOKFIL - MLCNKHEEDNL) / (EGIPNAJLAGN - MLCNKHEEDNL);
		}

		// Token: 0x0600EE0C RID: 60940 RVA: 0x004717F8 File Offset: 0x0046F9F8
		public static Vector3 PBBFFIPCJAE(Vector2 MAIFPGCJJLG)
		{
			return new Vector3(MAIFPGCJJLG.x, 0f, MAIFPGCJJLG.y);
		}

		// Token: 0x0600EE0D RID: 60941 RVA: 0x00471814 File Offset: 0x0046FA14
		public static Vector2 NJKEJMBMANF(Vector3 MAIFPGCJJLG)
		{
			return new Vector2(MAIFPGCJJLG.x, MAIFPGCJJLG.z);
		}

		// Token: 0x0600EE0E RID: 60942 RVA: 0x0047182C File Offset: 0x0046FA2C
		public static float FLIGAABNOCE(Vector2 MAIFPGCJJLG)
		{
			float magnitude = MAIFPGCJJLG.magnitude;
			if (MAIFPGCJJLG.y >= 0f)
			{
				return Mathf.Acos(MAIFPGCJJLG.x / magnitude);
			}
			return Mathf.Acos(-MAIFPGCJJLG.x / magnitude) + 3.1415927f;
		}

		// Token: 0x0600EE0F RID: 60943 RVA: 0x00471878 File Offset: 0x0046FA78
		public static float MIOOEPMHMGH(Vector3 MAIFPGCJJLG)
		{
			float magnitude = MAIFPGCJJLG.magnitude;
			if (MAIFPGCJJLG.z >= 0f)
			{
				return Mathf.Acos(MAIFPGCJJLG.x / magnitude);
			}
			return Mathf.Acos(-MAIFPGCJJLG.x / magnitude) + 3.1415927f;
		}

		// Token: 0x0600EE10 RID: 60944 RVA: 0x004718C4 File Offset: 0x0046FAC4
		public static void ACGHJHGJKPK<T>(ref T DPIIIAGCMLK, ref T BDKNHBMMGPK)
		{
			T t = DPIIIAGCMLK;
			DPIIIAGCMLK = BDKNHBMMGPK;
			BDKNHBMMGPK = t;
		}

		// Token: 0x0600EE11 RID: 60945 RVA: 0x004718EC File Offset: 0x0046FAEC
		public static void OFFICKPKMFJ<T>(T[] GDLLJBOEGNF)
		{
			for (int i = GDLLJBOEGNF.Length - 1; i > 0; i--)
			{
				int num = global::UnityEngine.Random.Range(0, i);
				OFPFHHLNHIC.ACGHJHGJKPK<T>(ref GDLLJBOEGNF[i], ref GDLLJBOEGNF[num]);
			}
		}

		// Token: 0x0600EE12 RID: 60946 RVA: 0x0047192C File Offset: 0x0046FB2C
		public static void OFFICKPKMFJ<T>(List<T> MKEOFCIGBDG)
		{
			for (int i = MKEOFCIGBDG.Count - 1; i > 0; i--)
			{
				int num = global::UnityEngine.Random.Range(0, i);
				T t = MKEOFCIGBDG[i];
				MKEOFCIGBDG[i] = MKEOFCIGBDG[num];
				MKEOFCIGBDG[num] = t;
			}
		}

		// Token: 0x0600EE13 RID: 60947 RVA: 0x00471978 File Offset: 0x0046FB78
		public static int FOLPBCCKANH(int MLCNKHEEDNL, int EGIPNAJLAGN, List<int> ELODGAIFIBE, int EBLJFNGHHPJ)
		{
			int num = global::UnityEngine.Random.Range(MLCNKHEEDNL, EGIPNAJLAGN - ELODGAIFIBE.Count);
			for (int i = 0; i < ELODGAIFIBE.Count; i++)
			{
				if (num >= ELODGAIFIBE[i])
				{
					num++;
				}
			}
			ELODGAIFIBE.Add(num);
			if (ELODGAIFIBE.Count > EBLJFNGHHPJ)
			{
				ELODGAIFIBE.RemoveRange(0, ELODGAIFIBE.Count - EBLJFNGHHPJ);
			}
			return num;
		}

		// Token: 0x0600EE14 RID: 60948 RVA: 0x004719E0 File Offset: 0x0046FBE0
		public static Transform CPJGEOJDPHJ(Transform CNGOCFABIFK, string EKKMPHMGCLB)
		{
			if (CNGOCFABIFK.name == EKKMPHMGCLB)
			{
				return CNGOCFABIFK;
			}
			IEnumerator enumerator = CNGOCFABIFK.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					object obj = enumerator.Current;
					Transform transform = (Transform)obj;
					Transform transform2 = OFPFHHLNHIC.CPJGEOJDPHJ(transform, EKKMPHMGCLB);
					if (transform2 != null)
					{
						return transform2;
					}
				}
			}
			finally
			{
				IDisposable disposable;
				if ((disposable = enumerator as IDisposable) != null)
				{
					disposable.Dispose();
				}
			}
			return null;
		}

		// Token: 0x0600EE15 RID: 60949 RVA: 0x00471A6C File Offset: 0x0046FC6C
		public static bool JJHMEPBDIBC<T>(T[] GDLLJBOEGNF)
		{
			return GDLLJBOEGNF == null || GDLLJBOEGNF.Length == 0;
		}

		// Token: 0x0600EE16 RID: 60950 RVA: 0x00471A84 File Offset: 0x0046FC84
		public static bool BFACOODCBHF<T>(T[] GDLLJBOEGNF, int CIMNKHDEFOH)
		{
			return GDLLJBOEGNF != null && CIMNKHDEFOH >= 0 && CIMNKHDEFOH < GDLLJBOEGNF.Length;
		}

		// Token: 0x0600EE17 RID: 60951 RVA: 0x00471AA0 File Offset: 0x0046FCA0
		public static bool BFACOODCBHF<T>(List<T> MKEOFCIGBDG, int CIMNKHDEFOH)
		{
			return MKEOFCIGBDG != null && MKEOFCIGBDG.Count != 0 && CIMNKHDEFOH >= 0 && CIMNKHDEFOH < MKEOFCIGBDG.Count;
		}

		// Token: 0x0600EE18 RID: 60952 RVA: 0x00471AC8 File Offset: 0x0046FCC8
		public static int IAAOFLBPJAL<T>(List<T> MKEOFCIGBDG, T OKKMGANCMGB)
		{
			int num = MKEOFCIGBDG.IndexOf(OKKMGANCMGB);
			if (num == -1)
			{
				MKEOFCIGBDG.Add(OKKMGANCMGB);
				num = MKEOFCIGBDG.Count - 1;
			}
			return num;
		}

		// Token: 0x0600EE19 RID: 60953 RVA: 0x00471AF8 File Offset: 0x0046FCF8
		public static List<T> GGDGJLFOLBJ<T>(List<T> MKEOFCIGBDG, Predicate<T> CGIPLILNILF)
		{
			List<T> list = MKEOFCIGBDG.FindAll(CGIPLILNILF);
			MKEOFCIGBDG.RemoveAll(CGIPLILNILF);
			return list;
		}

		// Token: 0x0600EE1A RID: 60954 RVA: 0x00471B18 File Offset: 0x0046FD18
		public static T JPCAJLJMJLK<T>(GameObject MKMCHJFIONM) where T : Component
		{
			T component = MKMCHJFIONM.GetComponent<T>();
			if (component)
			{
				return component;
			}
			return MKMCHJFIONM.AddComponent<T>();
		}

		// Token: 0x0600EE1B RID: 60955 RVA: 0x00471B44 File Offset: 0x0046FD44
		public static void DNNIECHLNOD<T>(List<T> MKEOFCIGBDG, int DMPGHHGCLFK)
		{
			MKEOFCIGBDG[DMPGHHGCLFK] = MKEOFCIGBDG[MKEOFCIGBDG.Count - 1];
			MKEOFCIGBDG.RemoveAt(MKEOFCIGBDG.Count - 1);
		}

		// Token: 0x0600EE1C RID: 60956 RVA: 0x00471B6C File Offset: 0x0046FD6C
		public static void JNAOHOIHJLC<T, U>(T OKIBEPPDAHI, U AKKPKCJLDDK) where T : MonoBehaviour where U : MonoBehaviour
		{
			OKIBEPPDAHI.gameObject.SetActive(false);
			AKKPKCJLDDK.gameObject.SetActive(true);
		}

		// Token: 0x0600EE1D RID: 60957 RVA: 0x00471B94 File Offset: 0x0046FD94
		public static void NMEMKBGMAED(Transform DKCNBKFJCLK, int CAEFCGKGGIM, int LOBLHPAKJCD)
		{
			if (DKCNBKFJCLK.gameObject.layer == CAEFCGKGGIM)
			{
				DKCNBKFJCLK.gameObject.layer = LOBLHPAKJCD;
			}
			int childCount = DKCNBKFJCLK.childCount;
			for (int i = 0; i < childCount; i++)
			{
				OFPFHHLNHIC.NMEMKBGMAED(DKCNBKFJCLK.GetChild(i), CAEFCGKGGIM, LOBLHPAKJCD);
			}
		}

		// Token: 0x0600EE1E RID: 60958 RVA: 0x00471BE8 File Offset: 0x0046FDE8
		public static void MBFGIEJCDGO(Vector3 MIKPIBIENPH, Color CNJBINEPFMM, float KLEEKKMJPJK)
		{
			Vector3 vector = MIKPIBIENPH + Vector3.right * KLEEKKMJPJK;
			Vector3 vector2 = MIKPIBIENPH - Vector3.right * KLEEKKMJPJK;
			global::UnityEngine.Debug.DrawLine(vector, vector2, CNJBINEPFMM);
			Vector3 vector3 = MIKPIBIENPH + Vector3.up * KLEEKKMJPJK;
			Vector3 vector4 = MIKPIBIENPH - Vector3.up * KLEEKKMJPJK;
			global::UnityEngine.Debug.DrawLine(vector3, vector4, CNJBINEPFMM);
			Vector3 vector5 = MIKPIBIENPH + Vector3.forward * KLEEKKMJPJK;
			Vector3 vector6 = MIKPIBIENPH - Vector3.forward * KLEEKKMJPJK;
			global::UnityEngine.Debug.DrawLine(vector5, vector6, CNJBINEPFMM);
		}

		// Token: 0x0600EE1F RID: 60959 RVA: 0x00471C80 File Offset: 0x0046FE80
		public static void GFHBCLGOCGB(Transform LHMELEOKNBJ, bool HEMIGBHDJCE = true)
		{
			LHMELEOKNBJ.localPosition = Vector3.zero;
			LHMELEOKNBJ.localRotation = Quaternion.identity;
			if (HEMIGBHDJCE)
			{
				LHMELEOKNBJ.localScale = new Vector3(1f, 1f, 1f);
			}
		}

		// Token: 0x0600EE20 RID: 60960 RVA: 0x00471CB8 File Offset: 0x0046FEB8
		public static Vector3 MFGMKCNAPHO(Vector3 MKPPJBFGPFJ, Vector3 MPAJLIKNBJM, Vector3 CHCAPBIPCGB)
		{
			Vector3 vector = CHCAPBIPCGB - MKPPJBFGPFJ;
			Vector3 normalized = (MPAJLIKNBJM - MKPPJBFGPFJ).normalized;
			float num = Vector3.Distance(MKPPJBFGPFJ, MPAJLIKNBJM);
			float num2 = Vector3.Dot(normalized, vector);
			if (num2 <= 0f)
			{
				return MKPPJBFGPFJ;
			}
			if (num2 >= num)
			{
				return MPAJLIKNBJM;
			}
			Vector3 vector2 = normalized * num2;
			return MKPPJBFGPFJ + vector2;
		}

		// Token: 0x0600EE21 RID: 60961 RVA: 0x00471D1C File Offset: 0x0046FF1C
		public static void BABGDGNJIBC(GameObject FMEGPDMNPED, float PLJBPCKADDK, Action JOINLHEALDL, bool MLGEGCEJKGB = false)
		{
			AfterTimer_Component afterTimer_Component = FMEGPDMNPED.AddComponent<AfterTimer_Component>();
			afterTimer_Component.Init(PLJBPCKADDK, JOINLHEALDL, MLGEGCEJKGB);
		}

		// Token: 0x0600EE22 RID: 60962 RVA: 0x00471D3C File Offset: 0x0046FF3C
		public static void ADBJDCPLFEM(Collider CINAFOGLFIB, string NFAFJOMABOK, SendMessageOptions NDFLNNONDNJ)
		{
			Rigidbody attachedRigidbody = CINAFOGLFIB.attachedRigidbody;
			if (attachedRigidbody && attachedRigidbody.gameObject != CINAFOGLFIB.gameObject)
			{
				attachedRigidbody.SendMessage(NFAFJOMABOK, NDFLNNONDNJ);
			}
			CINAFOGLFIB.SendMessage(NFAFJOMABOK, NDFLNNONDNJ);
		}

		// Token: 0x0600EE23 RID: 60963 RVA: 0x00471D84 File Offset: 0x0046FF84
		public static void ADBJDCPLFEM(Collider CINAFOGLFIB, string NFAFJOMABOK, object IHFMLNLKIJA, SendMessageOptions NDFLNNONDNJ)
		{
			Rigidbody attachedRigidbody = CINAFOGLFIB.attachedRigidbody;
			if (attachedRigidbody && attachedRigidbody.gameObject != CINAFOGLFIB.gameObject)
			{
				attachedRigidbody.SendMessage(NFAFJOMABOK, IHFMLNLKIJA, NDFLNNONDNJ);
			}
			CINAFOGLFIB.SendMessage(NFAFJOMABOK, IHFMLNLKIJA, NDFLNNONDNJ);
		}

		// Token: 0x0600EE24 RID: 60964 RVA: 0x00471DCC File Offset: 0x0046FFCC
		public static void JFNHMIKNMPI(GameObject OIBCGACJGBM, GameObject CGGMBKFGABP)
		{
			Collider[] componentsInChildren = OIBCGACJGBM.GetComponentsInChildren<Collider>();
			Collider[] componentsInChildren2 = CGGMBKFGABP.GetComponentsInChildren<Collider>();
			if (componentsInChildren.Length == 0 || componentsInChildren2.Length == 0)
			{
				return;
			}
			foreach (Collider collider in componentsInChildren)
			{
				foreach (Collider collider2 in componentsInChildren2)
				{
					if (collider.enabled && collider2.enabled)
					{
						Physics.IgnoreCollision(collider, collider2, true);
					}
				}
			}
		}

		// Token: 0x0600EE25 RID: 60965 RVA: 0x00471E5C File Offset: 0x0047005C
		public static IEnumerator ILLNIILJPCJ(IEnumerator APGHHOPCDJE, Action DIOECBJAKPC)
		{
			while (APGHHOPCDJE.MoveNext())
			{
				object obj = APGHHOPCDJE.Current;
				yield return obj;
			}
			DIOECBJAKPC();
			yield break;
		}

		// Token: 0x0600EE26 RID: 60966 RVA: 0x00471E80 File Offset: 0x00470080
		public static Color JBGCJCBPOOF(this Color HNOPCLEFEIG, float ELFEPDAKCDL)
		{
			HNOPCLEFEIG.a = ELFEPDAKCDL;
			return HNOPCLEFEIG;
		}

		// Token: 0x0600EE27 RID: 60967 RVA: 0x00471E8C File Offset: 0x0047008C
		public static void NGODENFOFGO()
		{
			Process.GetCurrentProcess().Kill();
		}

		// Token: 0x0600EE28 RID: 60968 RVA: 0x00471E98 File Offset: 0x00470098
		public static decimal GOHOINDBPML(float NOBAPCOKFIL, int MPOLODEEAJC = 2)
		{
			return Math.Round((decimal)NOBAPCOKFIL, MPOLODEEAJC);
		}

		// Token: 0x0600EE29 RID: 60969 RVA: 0x00471EA8 File Offset: 0x004700A8
		public static T PFEBENHDBDH<T>(this IEnumerable<T> ECFENKBBJOK)
		{
			if (ECFENKBBJOK == null)
			{
				throw new ArgumentException("Argument cannot be null.", "source");
			}
			int num = ECFENKBBJOK.Count<T>();
			if (num == 0)
			{
				throw new InvalidOperationException("Enumerable must contain at least one element.");
			}
			return ECFENKBBJOK.OrderBy(new Func<T, T>(OFPFHHLNHIC.KJPPOMNPIAJ<T>)).ElementAt(num / 2);
		}

		// Token: 0x0600EE2A RID: 60970 RVA: 0x00471F00 File Offset: 0x00470100
		public static void ODNPKKKGGNF<T>(this IEnumerable<T> ECFENKBBJOK, Action<T> HJNJOGJJMOF)
		{
			if (ECFENKBBJOK == null)
			{
				throw new ArgumentException("Argument cannot be null.", "source");
			}
			foreach (T t in ECFENKBBJOK)
			{
				HJNJOGJJMOF(t);
			}
		}

		// Token: 0x0600EE2B RID: 60971 RVA: 0x00471F6C File Offset: 0x0047016C
		public static string AGELNFMNHCG(string NALMLHMBHPM)
		{
			bool flag = true;
			while (flag)
			{
				int num = NALMLHMBHPM.IndexOf("\\n");
				if (num == -1)
				{
					flag = false;
				}
				else
				{
					NALMLHMBHPM = NALMLHMBHPM.Remove(num - 1, 3);
					NALMLHMBHPM = NALMLHMBHPM.Insert(num - 1, "\n");
				}
			}
			return NALMLHMBHPM;
		}

		// Token: 0x0600EE2C RID: 60972 RVA: 0x00471FC0 File Offset: 0x004701C0
		public static float CILLJGIOPMH(NavMeshPath KHKFPPAPDOP)
		{
			if (KHKFPPAPDOP.corners.Length < 2)
			{
				return 0f;
			}
			Vector3 vector = KHKFPPAPDOP.corners[0];
			float num = 0f;
			for (int i = 1; i < KHKFPPAPDOP.corners.Length; i++)
			{
				Vector3 vector2 = KHKFPPAPDOP.corners[i];
				num += Vector3.Distance(vector, vector2);
				vector = vector2;
			}
			return num;
		}

		// Token: 0x0600EE2D RID: 60973 RVA: 0x00472034 File Offset: 0x00470234
		public static bool MGECMNIFHKG(string LMIIJBLEJFI)
		{
			string[] commandLineArgs = Environment.GetCommandLineArgs();
			for (int i = 0; i < commandLineArgs.Length; i++)
			{
				if (commandLineArgs[i].Equals(LMIIJBLEJFI))
				{
					return true;
				}
			}
			return false;
		}

		// Token: 0x0600EE2E RID: 60974 RVA: 0x0047206C File Offset: 0x0047026C
		public static int ICENBHIOOCB(string LMIIJBLEJFI, int DFKKJBNEBGF)
		{
			string[] commandLineArgs = Environment.GetCommandLineArgs();
			int i = 0;
			while (i < commandLineArgs.Length)
			{
				if (commandLineArgs[i].Equals(LMIIJBLEJFI))
				{
					if (i == commandLineArgs.Length - 1)
					{
						return DFKKJBNEBGF;
					}
					return int.Parse(commandLineArgs[i + 1]);
				}
				else
				{
					i++;
				}
			}
			return DFKKJBNEBGF;
		}

		// Token: 0x0600EE2F RID: 60975 RVA: 0x004720BC File Offset: 0x004702BC
		public static float ICENBHIOOCB(string LMIIJBLEJFI, float PGBGKLCKHLM)
		{
			string[] commandLineArgs = Environment.GetCommandLineArgs();
			int i = 0;
			while (i < commandLineArgs.Length)
			{
				if (commandLineArgs[i].Equals(LMIIJBLEJFI))
				{
					if (i == commandLineArgs.Length - 1)
					{
						return PGBGKLCKHLM;
					}
					return (float)double.Parse(commandLineArgs[i + 1]);
				}
				else
				{
					i++;
				}
			}
			return PGBGKLCKHLM;
		}

		// Token: 0x0600EE30 RID: 60976 RVA: 0x0047210C File Offset: 0x0047030C
		public static void ACLHHKNALMJ(GameObject MKMCHJFIONM, bool CAAAFEKOAAF)
		{
			if (MKMCHJFIONM != null)
			{
				MKMCHJFIONM.SetActive(CAAAFEKOAAF);
			}
		}

		// Token: 0x0600EE31 RID: 60977 RVA: 0x00472124 File Offset: 0x00470324
		public static string CBJEHGMDFFP(params string[] EJEOGJJCBOP)
		{
			if (EJEOGJJCBOP.Length == 0)
			{
				return string.Empty;
			}
			string text = EJEOGJJCBOP[0];
			for (int i = 1; i < EJEOGJJCBOP.Length; i++)
			{
				text = Path.Combine(text, EJEOGJJCBOP[i]);
			}
			return text;
		}

		// Token: 0x0600EE32 RID: 60978 RVA: 0x00472164 File Offset: 0x00470364
		[CompilerGenerated]
		private static T KJPPOMNPIAJ<T>(T ILFEPFCLLFJ)
		{
			return ILFEPFCLLFJ;
		}

		// Token: 0x04002241 RID: 8769
		public const float OHJDAFEIOPP = 0.3048f;

		// Token: 0x04002242 RID: 8770
		public const float NEBKNGMDNGC = 30.48f;

		// Token: 0x04002243 RID: 8771
		public const float AEEGDDIIMHL = 0.0254f;

		// Token: 0x04002244 RID: 8772
		public const float IEKEGJCCPMA = 2.54f;

		// Token: 0x04002245 RID: 8773
		public const float EPFLBECNNIB = 3.28084f;

		// Token: 0x04002246 RID: 8774
		public const float DOGEGAPECEL = 39.3701f;

		// Token: 0x04002247 RID: 8775
		public const float BGAJBEINGAB = 0.0328084f;

		// Token: 0x04002248 RID: 8776
		public const float DGFCDGHPCHE = 0.393701f;

		// Token: 0x04002249 RID: 8777
		public const float KKDEMFNLOHG = 0.621371f;

		// Token: 0x0400224A RID: 8778
		public const float CIJBGMBDDOO = 1.60934f;
	}
}