using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using CodeStage.AntiCheat.ObscuredTypes;
using ExitGames.Client.Photon;
using RecNet;
using RecRoom;
using RecRoom.Core.AI;
using UnityEngine;

// Token: 0x0200111E RID: 4382
public static class NNGFEGAEJPG
{
	// Token: 0x060257B1 RID: 153521 RVA: 0x00A685C4 File Offset: 0x00A667C4
	public static bool DLANDAIDPMK(this string EJDAIKFLCCL)
	{
		Regex regex = new Regex("^[a-zA-Z0-9]+$");
		return regex.IsMatch(EJDAIKFLCCL);
	}

	// Token: 0x060257B2 RID: 153522 RVA: 0x00A685E4 File Offset: 0x00A667E4
	public static IEnumerator ENKBDIADIDE(AltTextureSet KIJPCHOHGMM, Vector2 BHIKEGFDJEI, int LKBONMAHEJO, Action<AltTextureSet> JELOLDLOAGA)
	{
		NNGFEGAEJPG.BLOEAKCEOCK.GJDMPELAFBA gjdmpelafba = new NNGFEGAEJPG.BLOEAKCEOCK.GJDMPELAFBA();
		gjdmpelafba.MEPGOLIKLOL = this;
		gjdmpelafba.JFPPGIEIMFP = new AltTextureSet();
		yield return NNGFEGAEJPG.LDHGEHBJOLM(KIJPCHOHGMM.MainTexture, BHIKEGFDJEI, LKBONMAHEJO, new Action<Texture2D>(gjdmpelafba.OJKNBNGGBEC));
		yield return NNGFEGAEJPG.LDHGEHBJOLM(KIJPCHOHGMM.AltTexture, BHIKEGFDJEI, LKBONMAHEJO, new Action<Texture2D>(gjdmpelafba.JAFGLCBFOHM));
		if (JELOLDLOAGA != null)
		{
			JELOLDLOAGA(gjdmpelafba.JFPPGIEIMFP);
		}
		yield break;
	}

	// Token: 0x060257B3 RID: 153523 RVA: 0x00A68614 File Offset: 0x00A66814
	public static IEnumerator LDHGEHBJOLM(Texture2D KIJPCHOHGMM, Vector2 BHIKEGFDJEI, int LKBONMAHEJO, Action<Texture2D> JELOLDLOAGA)
	{
		int width = KIJPCHOHGMM.width;
		int height = KIJPCHOHGMM.height;
		Texture2D texture2D = global::UnityEngine.Object.Instantiate<Texture2D>(KIJPCHOHGMM);
		int num = (int)((float)width - BHIKEGFDJEI.x) / LKBONMAHEJO;
		int num2 = (int)((float)height - BHIKEGFDJEI.y) / LKBONMAHEJO;
		for (int i = 1; i < LKBONMAHEJO - 1; i++)
		{
			PJGGFELBOAL.GAFBBDJNJIK(texture2D, width - i * num, height - i * num2);
			yield return null;
		}
		PJGGFELBOAL.GAFBBDJNJIK(texture2D, (int)BHIKEGFDJEI.x, (int)BHIKEGFDJEI.y);
		JELOLDLOAGA(texture2D);
		yield break;
	}

	// Token: 0x060257B4 RID: 153524 RVA: 0x00A68644 File Offset: 0x00A66844
	public static int BOBCLCMGBBE(this string EJDAIKFLCCL)
	{
		uint num = 2166136261U;
		for (int i = 0; i < EJDAIKFLCCL.Length; i++)
		{
			num ^= (uint)EJDAIKFLCCL[i];
			num *= 16777619U;
			num = 1664525U * num + 1013904223U;
		}
		return (int)num;
	}

	// Token: 0x060257B5 RID: 153525 RVA: 0x00A68690 File Offset: 0x00A66890
	public static IEnumerable<T> JFOBNGODCBD<T>(this IEnumerable<T> MICDNLAAKGP, int BGBGAKOFIMJ, int DJLDMFKFEFN)
	{
		if (BGBGAKOFIMJ > 0)
		{
			MICDNLAAKGP = MICDNLAAKGP.Skip(BGBGAKOFIMJ);
		}
		return MICDNLAAKGP.Take(DJLDMFKFEFN);
	}

	// Token: 0x060257B6 RID: 153526 RVA: 0x00A686AC File Offset: 0x00A668AC
	public static void ADBOBGMIDLE<T>(this Component NCOHNOPAIOG, T NOBAPCOKFIL, string NFAFJOMABOK) where T : class
	{
		if (NOBAPCOKFIL == null)
		{
			throw new NullReferenceException(NFAFJOMABOK);
		}
	}

	// Token: 0x060257B7 RID: 153527 RVA: 0x00A686C0 File Offset: 0x00A668C0
	public static void HLGPFLHHEEK(this GameObject MKMCHJFIONM, NILFAGNKNMH KCKJODPANGP)
	{
		if (!MKMCHJFIONM.CompareTag("LayerIsLocked"))
		{
			MKMCHJFIONM.layer = (int)KCKJODPANGP;
		}
		IEnumerator enumerator = MKMCHJFIONM.transform.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				object obj = enumerator.Current;
				Transform transform = (Transform)obj;
				transform.gameObject.HLGPFLHHEEK(KCKJODPANGP);
			}
		}
		finally
		{
			IDisposable disposable;
			if ((disposable = enumerator as IDisposable) != null)
			{
				disposable.Dispose();
			}
		}
	}

	// Token: 0x060257B8 RID: 153528 RVA: 0x00A68744 File Offset: 0x00A66944
	public static void OCMFPLEAONC(this GameObject MKMCHJFIONM, string KPOAMFIAODF)
	{
		MKMCHJFIONM.tag = KPOAMFIAODF;
		IEnumerator enumerator = MKMCHJFIONM.transform.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				object obj = enumerator.Current;
				Transform transform = (Transform)obj;
				transform.gameObject.OCMFPLEAONC(KPOAMFIAODF);
			}
		}
		finally
		{
			IDisposable disposable;
			if ((disposable = enumerator as IDisposable) != null)
			{
				disposable.Dispose();
			}
		}
	}

	// Token: 0x060257B9 RID: 153529 RVA: 0x00A687B8 File Offset: 0x00A669B8
	public static void PHBDKOCCIOG(this GameObject MKMCHJFIONM, bool FDKECOEFNCB)
	{
		MKMCHJFIONM.isStatic = FDKECOEFNCB;
		IEnumerator enumerator = MKMCHJFIONM.transform.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				object obj = enumerator.Current;
				Transform transform = (Transform)obj;
				transform.gameObject.PHBDKOCCIOG(FDKECOEFNCB);
			}
		}
		finally
		{
			IDisposable disposable;
			if ((disposable = enumerator as IDisposable) != null)
			{
				disposable.Dispose();
			}
		}
	}

	// Token: 0x060257BA RID: 153530 RVA: 0x00A6882C File Offset: 0x00A66A2C
	public static void LLOHMKAPBDK(this GameObject MKMCHJFIONM, NILFAGNKNMH JKKOJPNLIPC, NILFAGNKNMH FMAEBBIKIKJ)
	{
		if (MKMCHJFIONM.layer == (int)JKKOJPNLIPC && !MKMCHJFIONM.CompareTag("LayerIsLocked"))
		{
			MKMCHJFIONM.layer = (int)FMAEBBIKIKJ;
		}
		IEnumerator enumerator = MKMCHJFIONM.transform.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				object obj = enumerator.Current;
				Transform transform = (Transform)obj;
				transform.gameObject.LLOHMKAPBDK(JKKOJPNLIPC, FMAEBBIKIKJ);
			}
		}
		finally
		{
			IDisposable disposable;
			if ((disposable = enumerator as IDisposable) != null)
			{
				disposable.Dispose();
			}
		}
	}

	// Token: 0x060257BB RID: 153531 RVA: 0x00A688BC File Offset: 0x00A66ABC
	public static bool OPJBDKJDLFF(this GameObject MKMCHJFIONM, LCIGHPPLKCA FIHIEFMGDCI)
	{
		return NNGFEGAEJPG.CCAOLOGMGJF(MKMCHJFIONM.layer, (int)FIHIEFMGDCI);
	}

	// Token: 0x060257BC RID: 153532 RVA: 0x00A688CC File Offset: 0x00A66ACC
	public static bool CCAOLOGMGJF(int NOBAPCOKFIL, int HOBKFDJFIEM)
	{
		return ((1 << NOBAPCOKFIL) & HOBKFDJFIEM) != 0;
	}

	// Token: 0x060257BD RID: 153533 RVA: 0x00A688DC File Offset: 0x00A66ADC
	public static Color FNNAJBFGBAI(this Color HNOPCLEFEIG, float ELFEPDAKCDL)
	{
		return new Color(HNOPCLEFEIG.r, HNOPCLEFEIG.g, HNOPCLEFEIG.b, ELFEPDAKCDL);
	}

	// Token: 0x060257BE RID: 153534 RVA: 0x00A688FC File Offset: 0x00A66AFC
	public static int NGJMDEALIKA(this NILFAGNKNMH KCKJODPANGP)
	{
		return 1 << (int)KCKJODPANGP;
	}

	// Token: 0x060257BF RID: 153535 RVA: 0x00A68904 File Offset: 0x00A66B04
	public static void INDKEOIJENP(this Camera CENLMCHLIKM, NILFAGNKNMH KCKJODPANGP)
	{
		CENLMCHLIKM.KBNFBFGBAMM(KCKJODPANGP.NGJMDEALIKA());
	}

	// Token: 0x060257C0 RID: 153536 RVA: 0x00A68914 File Offset: 0x00A66B14
	public static void ABNNOGDFFCP(this Camera CENLMCHLIKM, NILFAGNKNMH KCKJODPANGP)
	{
		CENLMCHLIKM.AOAHMEHDHKC(KCKJODPANGP.NGJMDEALIKA());
	}

	// Token: 0x060257C1 RID: 153537 RVA: 0x00A68924 File Offset: 0x00A66B24
	public static void KBNFBFGBAMM(this Camera CENLMCHLIKM, int FIHIEFMGDCI)
	{
		CENLMCHLIKM.cullingMask &= ~FIHIEFMGDCI;
	}

	// Token: 0x060257C2 RID: 153538 RVA: 0x00A68938 File Offset: 0x00A66B38
	public static void AOAHMEHDHKC(this Camera CENLMCHLIKM, int FIHIEFMGDCI)
	{
		CENLMCHLIKM.cullingMask |= FIHIEFMGDCI;
	}

	// Token: 0x060257C3 RID: 153539 RVA: 0x00A68948 File Offset: 0x00A66B48
	public static AnimationCurve GMNHOPPHOGH()
	{
		return AnimationCurve.Linear(0f, 0f, 1f, 1f);
	}

	// Token: 0x060257C4 RID: 153540 RVA: 0x00A68964 File Offset: 0x00A66B64
	public static IEnumerator MOKPENMLOLP(this Animator FIOLBHFJENN, int ODDJBELKCAD)
	{
		float length = FIOLBHFJENN.GetCurrentAnimatorStateInfo(ODDJBELKCAD).length;
		float num = 0f;
		while (num < length)
		{
			num += Time.deltaTime;
			yield return null;
		}
		yield break;
	}

	// Token: 0x060257C5 RID: 153541 RVA: 0x00A68988 File Offset: 0x00A66B88
	public static void MBIHFMAMIBG(this Rigidbody EAEAFPMBPNL)
	{
		EAEAFPMBPNL.velocity = Vector3.zero;
		EAEAFPMBPNL.angularVelocity = Vector3.zero;
	}

	// Token: 0x060257C6 RID: 153542 RVA: 0x00A689A0 File Offset: 0x00A66BA0
	public static Vector3 POMGOGCFHKI(Vector3 ECFENKBBJOK, Plane OLNDEBNCLIJ)
	{
		return ECFENKBBJOK - Vector3.Dot(ECFENKBBJOK, OLNDEBNCLIJ.normal) * OLNDEBNCLIJ.normal;
	}

	// Token: 0x060257C7 RID: 153543 RVA: 0x00A689C4 File Offset: 0x00A66BC4
	public static Quaternion IGNMFLLDHLN(Quaternion FLKMJFAOABP, Quaternion MABKDDJKKPL)
	{
		return MABKDDJKKPL * Quaternion.Inverse(FLKMJFAOABP);
	}

	// Token: 0x060257C8 RID: 153544 RVA: 0x00A689D4 File Offset: 0x00A66BD4
	public static Quaternion HOIKNHDPMLN(Vector3 CCHAEPGJJLI)
	{
		return Quaternion.AngleAxis(CCHAEPGJJLI.magnitude * 57.29578f, CCHAEPGJJLI.normalized);
	}

	// Token: 0x060257C9 RID: 153545 RVA: 0x00A689F0 File Offset: 0x00A66BF0
	public static Vector3 PGPNGNDCJKL(Quaternion FLKMJFAOABP, Quaternion MABKDDJKKPL)
	{
		float num;
		Vector3 vector;
		NNGFEGAEJPG.IGNMFLLDHLN(FLKMJFAOABP, MABKDDJKKPL).ToAngleAxis(out num, out vector);
		if (num > 180f)
		{
			num -= 360f;
		}
		return num * vector * 0.017453292f;
	}

	// Token: 0x060257CA RID: 153546 RVA: 0x00A68A34 File Offset: 0x00A66C34
	public static Quaternion MCKNNGGGBDG(this Transform DKCNBKFJCLK, Quaternion IJGPPOIJDKO)
	{
		return Quaternion.Inverse(DKCNBKFJCLK.rotation) * IJGPPOIJDKO;
	}

	// Token: 0x060257CB RID: 153547 RVA: 0x00A68A48 File Offset: 0x00A66C48
	public static Quaternion PAFJLHMDIMO(this Transform DKCNBKFJCLK, Quaternion IJGPPOIJDKO)
	{
		return DKCNBKFJCLK.rotation * IJGPPOIJDKO;
	}

	// Token: 0x060257CC RID: 153548 RVA: 0x00A68A58 File Offset: 0x00A66C58
	public static Transform OJKEFDBGNAM(this Transform DKCNBKFJCLK, string EKKMPHMGCLB)
	{
		for (int i = 0; i < DKCNBKFJCLK.childCount; i++)
		{
			Transform child = DKCNBKFJCLK.GetChild(i);
			if (child != null)
			{
				if (child.name == EKKMPHMGCLB)
				{
					return child;
				}
				Transform transform = child.OJKEFDBGNAM(EKKMPHMGCLB);
				if (transform != null)
				{
					return transform;
				}
			}
		}
		return null;
	}

	// Token: 0x060257CD RID: 153549 RVA: 0x00A68ABC File Offset: 0x00A66CBC
	public static bool PIPKFEDEJCM(this Transform DKCNBKFJCLK, Transform EAMJGJFJPNL)
	{
		for (;;)
		{
			DKCNBKFJCLK = DKCNBKFJCLK.parent;
			if (DKCNBKFJCLK == EAMJGJFJPNL)
			{
				break;
			}
			if (!(DKCNBKFJCLK != null))
			{
				return false;
			}
		}
		return true;
	}

	// Token: 0x060257CE RID: 153550 RVA: 0x00A68AE4 File Offset: 0x00A66CE4
	public static bool OGGIHOOBPJF(this Transform DKCNBKFJCLK)
	{
		Vector3 lossyScale = DKCNBKFJCLK.lossyScale;
		float num = Mathf.Sign(DKCNBKFJCLK.lossyScale.x * DKCNBKFJCLK.lossyScale.y * DKCNBKFJCLK.lossyScale.z);
		return num < 0f;
	}

	// Token: 0x060257CF RID: 153551 RVA: 0x00A68B34 File Offset: 0x00A66D34
	public static Quaternion PAFJLHMDIMO(this Quaternion CNGOCFABIFK, Quaternion IJGPPOIJDKO)
	{
		return CNGOCFABIFK * IJGPPOIJDKO;
	}

	// Token: 0x060257D0 RID: 153552 RVA: 0x00A68B40 File Offset: 0x00A66D40
	public static Vector3 HMMMACNKENN(this Quaternion OCDHMDJIKGG)
	{
		float num;
		Vector3 vector;
		OCDHMDJIKGG.ToAngleAxis(out num, out vector);
		if (num > 180f)
		{
			num -= 360f;
		}
		return num * vector * 0.017453292f;
	}

	// Token: 0x060257D1 RID: 153553 RVA: 0x00A68B7C File Offset: 0x00A66D7C
	public static void NIACFDCMGLG<T>(this global::PLOPPLAOICD FIIFPLCNFHJ, string GPGKLIKBKDO, T HOEHLPOCEBP, T CHCNPBDOPHH)
	{
		if (FIIFPLCNFHJ != null)
		{
			FIIFPLCNFHJ.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, HOEHLPOCEBP } }, new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, CHCNPBDOPHH } }, false);
		}
	}

	// Token: 0x060257D2 RID: 153554 RVA: 0x00A68BC0 File Offset: 0x00A66DC0
	public static void NIACFDCMGLG<T>(this global::PLOPPLAOICD FIIFPLCNFHJ, string GPGKLIKBKDO, T HOEHLPOCEBP)
	{
		if (FIIFPLCNFHJ != null)
		{
			FIIFPLCNFHJ.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, HOEHLPOCEBP } }, null, false);
		}
	}

	// Token: 0x060257D3 RID: 153555 RVA: 0x00A68BF0 File Offset: 0x00A66DF0
	public static string MHALLOPCFCB(this LNJFBGIBLHA JEFGMHBLLKI, string GPGKLIKBKDO)
	{
		if (JEFGMHBLLKI != null && JEFGMHBLLKI.BAHICKLKKHB.ContainsKey(GPGKLIKBKDO))
		{
			return JEFGMHBLLKI.BAHICKLKKHB[GPGKLIKBKDO] as string;
		}
		return null;
	}

	// Token: 0x060257D4 RID: 153556 RVA: 0x00A68C1C File Offset: 0x00A66E1C
	public static void NIACFDCMGLG<T>(this LNJFBGIBLHA JEFGMHBLLKI, string GPGKLIKBKDO, T HOEHLPOCEBP, T CHCNPBDOPHH)
	{
		if (JEFGMHBLLKI != null)
		{
			JEFGMHBLLKI.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, HOEHLPOCEBP } }, new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, CHCNPBDOPHH } }, false);
		}
	}

	// Token: 0x060257D5 RID: 153557 RVA: 0x00A68C60 File Offset: 0x00A66E60
	public static void NIACFDCMGLG<T>(this LNJFBGIBLHA JEFGMHBLLKI, string GPGKLIKBKDO, T HOEHLPOCEBP)
	{
		if (JEFGMHBLLKI != null)
		{
			JEFGMHBLLKI.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, HOEHLPOCEBP } }, null, false);
		}
	}

	// Token: 0x060257D6 RID: 153558 RVA: 0x00A68C90 File Offset: 0x00A66E90
	public static void BBGLKFCJAID(this LNJFBGIBLHA JEFGMHBLLKI, string GPGKLIKBKDO)
	{
		if (JEFGMHBLLKI != null)
		{
			JEFGMHBLLKI.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, null } }, null, false);
		}
	}

	// Token: 0x060257D7 RID: 153559 RVA: 0x00A68CBC File Offset: 0x00A66EBC
	public static void BBGLKFCJAID(this global::PLOPPLAOICD FIIFPLCNFHJ, string GPGKLIKBKDO)
	{
		FIIFPLCNFHJ.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, null } }, null, false);
	}

	// Token: 0x060257D8 RID: 153560 RVA: 0x00A68CE0 File Offset: 0x00A66EE0
	public static Player JHJGDFHNBLO(this LNJFBGIBLHA GGMIDKPEEME)
	{
		return (GGMIDKPEEME == null) ? null : (GGMIDKPEEME.NIELBMEGFAH as Player);
	}

	// Token: 0x060257D9 RID: 153561 RVA: 0x00A68CFC File Offset: 0x00A66EFC
	public static T HIJBMFKBBFN<T>(this List<T> MKEOFCIGBDG)
	{
		if (MKEOFCIGBDG.Count > 0)
		{
			return MKEOFCIGBDG[global::UnityEngine.Random.Range(0, MKEOFCIGBDG.Count - 1)];
		}
		return default(T);
	}

	// Token: 0x060257DA RID: 153562 RVA: 0x00A68D34 File Offset: 0x00A66F34
	public static void DLPNNHIDILF<T>(this List<T> MKEOFCIGBDG, T OKKMGANCMGB)
	{
		if (!MKEOFCIGBDG.Contains(OKKMGANCMGB))
		{
			MKEOFCIGBDG.Add(OKKMGANCMGB);
		}
	}

	// Token: 0x060257DB RID: 153563 RVA: 0x00A68D4C File Offset: 0x00A66F4C
	public static T HIJBMFKBBFN<T>(this T[] MKEOFCIGBDG)
	{
		if (MKEOFCIGBDG.Length > 0)
		{
			return MKEOFCIGBDG[global::UnityEngine.Random.Range(0, MKEOFCIGBDG.Length - 1)];
		}
		return default(T);
	}

	// Token: 0x060257DC RID: 153564 RVA: 0x00A68D80 File Offset: 0x00A66F80
	public static void JCJAECDEILG<T>(this List<T> JDOHGLGFDEO) where T : class
	{
		JDOHGLGFDEO.RemoveAll(new Predicate<T>(NNGFEGAEJPG.AEKHOOMLIKM<T>));
	}

	// Token: 0x060257DD RID: 153565 RVA: 0x00A68D98 File Offset: 0x00A66F98
	public static void LOHNNOLPNCD<T1, T2>(this Dictionary<T1, T2> KIJPCHOHGMM, ref Dictionary<T1, T2> DJCNCPKHANK)
	{
		foreach (KeyValuePair<T1, T2> keyValuePair in KIJPCHOHGMM)
		{
			if (!DJCNCPKHANK.ContainsKey(keyValuePair.Key))
			{
				DJCNCPKHANK.Add(keyValuePair.Key, keyValuePair.Value);
			}
		}
	}

	// Token: 0x060257DE RID: 153566 RVA: 0x00A68E10 File Offset: 0x00A67010
	public static float CDGLLOMEAFJ(this PhysicMaterial EHINGKOJOFN, PhysicMaterial EMMFHBJONFM)
	{
		if (EHINGKOJOFN == null && EMMFHBJONFM == null)
		{
			return 0f;
		}
		if (EMMFHBJONFM == null)
		{
			return EHINGKOJOFN.staticFriction;
		}
		if (EHINGKOJOFN == null)
		{
			return EMMFHBJONFM.staticFriction;
		}
		return NNGFEGAEJPG.MGCJFNPJJNC(EHINGKOJOFN.staticFriction, EMMFHBJONFM.staticFriction, EHINGKOJOFN.frictionCombine);
	}

	// Token: 0x060257DF RID: 153567 RVA: 0x00A68E78 File Offset: 0x00A67078
	public static float DNHJPDHHKJI(this PhysicMaterial EHINGKOJOFN, PhysicMaterial EMMFHBJONFM)
	{
		if (EHINGKOJOFN == null && EMMFHBJONFM == null)
		{
			return 0f;
		}
		if (EMMFHBJONFM == null)
		{
			return EHINGKOJOFN.dynamicFriction;
		}
		if (EHINGKOJOFN == null)
		{
			return EMMFHBJONFM.dynamicFriction;
		}
		return NNGFEGAEJPG.MGCJFNPJJNC(EHINGKOJOFN.dynamicFriction, EMMFHBJONFM.dynamicFriction, EHINGKOJOFN.frictionCombine);
	}

	// Token: 0x060257E0 RID: 153568 RVA: 0x00A68EE0 File Offset: 0x00A670E0
	public static float AGAGLEIJFEF(this Collider NEKKGHFALPO, Collider OIDJDLBOIAD)
	{
		PhysicMaterial physicMaterial = ((!(NEKKGHFALPO == null)) ? NEKKGHFALPO.material : null);
		PhysicMaterial physicMaterial2 = ((!(OIDJDLBOIAD == null)) ? OIDJDLBOIAD.material : null);
		return physicMaterial.AGAGLEIJFEF(physicMaterial2);
	}

	// Token: 0x060257E1 RID: 153569 RVA: 0x00A68F28 File Offset: 0x00A67128
	public static float AGAGLEIJFEF(this PhysicMaterial EHINGKOJOFN, PhysicMaterial EMMFHBJONFM)
	{
		if (EHINGKOJOFN == null && EMMFHBJONFM == null)
		{
			return 1f;
		}
		if (EMMFHBJONFM == null)
		{
			return EHINGKOJOFN.bounciness;
		}
		if (EHINGKOJOFN == null)
		{
			return EMMFHBJONFM.bounciness;
		}
		return NNGFEGAEJPG.MGCJFNPJJNC(EHINGKOJOFN.bounciness, EMMFHBJONFM.bounciness, EHINGKOJOFN.bounceCombine);
	}

	// Token: 0x060257E2 RID: 153570 RVA: 0x00A68F90 File Offset: 0x00A67190
	private static float MGCJFNPJJNC(float DPIIIAGCMLK, float BDKNHBMMGPK, PhysicMaterialCombine BIAMHGOBDGB)
	{
		float num = 0f;
		switch (BIAMHGOBDGB)
		{
		case PhysicMaterialCombine.Average:
			num = (DPIIIAGCMLK + BDKNHBMMGPK) / 2f;
			break;
		case PhysicMaterialCombine.Multiply:
			num = DPIIIAGCMLK * BDKNHBMMGPK;
			break;
		case PhysicMaterialCombine.Minimum:
			num = Mathf.Min(DPIIIAGCMLK, BDKNHBMMGPK);
			break;
		case PhysicMaterialCombine.Maximum:
			num = Mathf.Max(DPIIIAGCMLK, BDKNHBMMGPK);
			break;
		}
		return num;
	}

	// Token: 0x060257E3 RID: 153571 RVA: 0x00A68FF4 File Offset: 0x00A671F4
	public static void NAGFLOBIOCK(this RaycastHit[] AJDJKDELMKL, int CEFMEFIIMIC)
	{
		if (CEFMEFIIMIC > 1)
		{
			float[] array = new float[CEFMEFIIMIC];
			for (int i = 0; i < CEFMEFIIMIC; i++)
			{
				array[i] = (AJDJKDELMKL[i].collider.transform.position - AJDJKDELMKL[i].point).sqrMagnitude;
			}
			for (int j = 1; j < CEFMEFIIMIC; j++)
			{
				int num = j;
				while (num > 0 && array[num] < array[num - 1])
				{
					AJDJKDELMKL.GBJPIAHGKGK(num, j);
					array.GBJPIAHGKGK(num, j);
					num--;
				}
			}
		}
	}

	// Token: 0x060257E4 RID: 153572 RVA: 0x00A69098 File Offset: 0x00A67298
	public static void GBJPIAHGKGK<T>(this T[] GDLLJBOEGNF, int CIMNKHDEFOH, int OJAJLHFPAIB)
	{
		T t = GDLLJBOEGNF[CIMNKHDEFOH];
		GDLLJBOEGNF[CIMNKHDEFOH] = GDLLJBOEGNF[OJAJLHFPAIB];
		GDLLJBOEGNF[OJAJLHFPAIB] = t;
	}

	// Token: 0x060257E5 RID: 153573 RVA: 0x00A690C4 File Offset: 0x00A672C4
	public static Tool OBFMDIEKHAN(this Collision PDCJEBJGFNF)
	{
		ToolCollider toolCollider = null;
		return PDCJEBJGFNF.collider.OBFMDIEKHAN(out toolCollider);
	}

	// Token: 0x060257E6 RID: 153574 RVA: 0x00A690E0 File Offset: 0x00A672E0
	public static Tool OBFMDIEKHAN(this Collider CINAFOGLFIB)
	{
		ToolCollider toolCollider = null;
		return CINAFOGLFIB.OBFMDIEKHAN(out toolCollider);
	}

	// Token: 0x060257E7 RID: 153575 RVA: 0x00A690F8 File Offset: 0x00A672F8
	public static Tool OBFMDIEKHAN(this Collider CINAFOGLFIB, out ToolCollider DDEFNDJJPPK)
	{
		DDEFNDJJPPK = CINAFOGLFIB.GetComponent<ToolCollider>();
		if (DDEFNDJJPPK == null)
		{
			return null;
		}
		return DDEFNDJJPPK.Tool;
	}

	// Token: 0x060257E8 RID: 153576 RVA: 0x00A69118 File Offset: 0x00A67318
	public static Player KAPJACICAEC(this Collision PDCJEBJGFNF, out Player.HDOICGIKKAO ACAHIJEJKLC)
	{
		return PDCJEBJGFNF.collider.KAPJACICAEC(out ACAHIJEJKLC);
	}

	// Token: 0x060257E9 RID: 153577 RVA: 0x00A69128 File Offset: 0x00A67328
	public static Player KAPJACICAEC(this Collider CINAFOGLFIB, out Player.HDOICGIKKAO ACAHIJEJKLC)
	{
		PlayerCollider component = CINAFOGLFIB.GetComponent<PlayerCollider>();
		if (component == null)
		{
			ACAHIJEJKLC = Player.HDOICGIKKAO.None;
			return null;
		}
		ACAHIJEJKLC = component.HDOICGIKKAO;
		return component.ThisPlayer;
	}

	// Token: 0x060257EA RID: 153578 RVA: 0x00A6915C File Offset: 0x00A6735C
	public static PlayerHand HLBBAALDKLM(this Collider CINAFOGLFIB)
	{
		PlayerHand playerHand = null;
		Player.HDOICGIKKAO hdoicgikkao;
		Player player = CINAFOGLFIB.KAPJACICAEC(out hdoicgikkao);
		if (player != null && hdoicgikkao.PLKCJINIPMP())
		{
			playerHand = player.GetHand(hdoicgikkao);
		}
		return playerHand;
	}

	// Token: 0x060257EB RID: 153579 RVA: 0x00A69194 File Offset: 0x00A67394
	public static Enemy AICMDAMIEBP(this Collision PDCJEBJGFNF, out MHEBDODJGOA OMPOICMBDBP)
	{
		return PDCJEBJGFNF.collider.AICMDAMIEBP(out OMPOICMBDBP);
	}

	// Token: 0x060257EC RID: 153580 RVA: 0x00A691A4 File Offset: 0x00A673A4
	public static Enemy AICMDAMIEBP(this Collider CINAFOGLFIB, out MHEBDODJGOA OMPOICMBDBP)
	{
		EnemyCollider component = CINAFOGLFIB.GetComponent<EnemyCollider>();
		if (component == null)
		{
			OMPOICMBDBP = MHEBDODJGOA.NORMAL;
			return null;
		}
		OMPOICMBDBP = component.EPOLDOJECMI;
		return component.ThisEnemy;
	}

	// Token: 0x060257ED RID: 153581 RVA: 0x00A691D8 File Offset: 0x00A673D8
	public static Trap JFFLOIPFGPE(this Collision PDCJEBJGFNF)
	{
		return PDCJEBJGFNF.collider.JFFLOIPFGPE();
	}

	// Token: 0x060257EE RID: 153582 RVA: 0x00A691E8 File Offset: 0x00A673E8
	public static Trap JFFLOIPFGPE(this Collider CINAFOGLFIB)
	{
		TrapCollider component = CINAFOGLFIB.GetComponent<TrapCollider>();
		return (!(component != null)) ? null : component.ThisTrap;
	}

	// Token: 0x060257EF RID: 153583 RVA: 0x00A69214 File Offset: 0x00A67414
	public static PhotonView DNGLEMHICPL(this Collision PDCJEBJGFNF)
	{
		return PDCJEBJGFNF.collider.DNGLEMHICPL();
	}

	// Token: 0x060257F0 RID: 153584 RVA: 0x00A69224 File Offset: 0x00A67424
	public static PhotonView DNGLEMHICPL(this Collider CINAFOGLFIB)
	{
		return CINAFOGLFIB.gameObject.GetComponentInParent<PhotonView>();
	}

	// Token: 0x060257F1 RID: 153585 RVA: 0x00A69234 File Offset: 0x00A67434
	public static Killzone ACCPNLDEPFO(this Collider CINAFOGLFIB)
	{
		return CINAFOGLFIB.gameObject.GetComponent<Killzone>();
	}

	// Token: 0x060257F2 RID: 153586 RVA: 0x00A69244 File Offset: 0x00A67444
	public static int BILCNCNIFDJ(this BoxCollider CINAFOGLFIB, int FIHIEFMGDCI, QueryTriggerInteraction NCNLFKOECLJ, Collider[] JPOEPEOCGHB)
	{
		Vector3 vector = CINAFOGLFIB.transform.TransformPoint(CINAFOGLFIB.center);
		Quaternion rotation = CINAFOGLFIB.transform.rotation;
		Vector3 vector2 = CINAFOGLFIB.size / 2f;
		return Physics.OverlapBoxNonAlloc(vector, vector2, JPOEPEOCGHB, rotation, FIHIEFMGDCI, NCNLFKOECLJ);
	}

	// Token: 0x060257F3 RID: 153587 RVA: 0x00A6928C File Offset: 0x00A6748C
	public static bool HLMMPOAOLAP(this BoxCollider CINAFOGLFIB, int FIHIEFMGDCI, QueryTriggerInteraction NCNLFKOECLJ)
	{
		Vector3 vector = CINAFOGLFIB.transform.TransformPoint(CINAFOGLFIB.center);
		Quaternion rotation = CINAFOGLFIB.transform.rotation;
		Vector3 vector2 = CINAFOGLFIB.size / 2f;
		return Physics.CheckBox(vector, vector2, rotation, FIHIEFMGDCI, NCNLFKOECLJ);
	}

	// Token: 0x060257F4 RID: 153588 RVA: 0x00A692D4 File Offset: 0x00A674D4
	public static bool FOHLEHDCHCA(this BoxCollider ANOPKHFFLNF, Vector3 FHFHOMKFHCI)
	{
		FHFHOMKFHCI = ANOPKHFFLNF.transform.InverseTransformPoint(FHFHOMKFHCI) - ANOPKHFFLNF.center;
		float num = ANOPKHFFLNF.size.x * 0.5f;
		float num2 = ANOPKHFFLNF.size.y * 0.5f;
		float num3 = ANOPKHFFLNF.size.z * 0.5f;
		return FHFHOMKFHCI.x < num && FHFHOMKFHCI.x > -num && FHFHOMKFHCI.y < num2 && FHFHOMKFHCI.y > -num2 && FHFHOMKFHCI.z < num3 && FHFHOMKFHCI.z > -num3;
	}

	// Token: 0x060257F5 RID: 153589 RVA: 0x00A69394 File Offset: 0x00A67594
	public static bool HLMMPOAOLAP(this CapsuleCollider CINAFOGLFIB, int FIHIEFMGDCI, QueryTriggerInteraction NCNLFKOECLJ)
	{
		Vector3 vector = Vector3.right;
		if (CINAFOGLFIB.direction == 1)
		{
			vector = Vector3.up;
		}
		else if (CINAFOGLFIB.direction == 2)
		{
			vector = Vector3.forward;
		}
		Vector3 normalized = CINAFOGLFIB.transform.TransformDirection(vector).normalized;
		float num = Mathf.Max(0f, CINAFOGLFIB.height - 2f * CINAFOGLFIB.radius);
		Vector3 vector2 = CINAFOGLFIB.transform.TransformPoint(CINAFOGLFIB.center);
		return Physics.CheckCapsule(vector2 - normalized * num, vector2 + normalized * num, CINAFOGLFIB.radius, FIHIEFMGDCI, NCNLFKOECLJ);
	}

	// Token: 0x060257F6 RID: 153590 RVA: 0x00A69440 File Offset: 0x00A67640
	public static Quaternion AHDFJMAJNBC(Quaternion LEAIIPBJMLG, Quaternion MMEBLCBANIL, ref Vector3 GALFDIHLNGC, float CJEDMBMEDML)
	{
		Vector3 eulerAngles = LEAIIPBJMLG.eulerAngles;
		Vector3 eulerAngles2 = MMEBLCBANIL.eulerAngles;
		eulerAngles.x = Mathf.SmoothDampAngle(eulerAngles.x, eulerAngles2.x, ref GALFDIHLNGC.x, CJEDMBMEDML);
		eulerAngles.y = Mathf.SmoothDampAngle(eulerAngles.y, eulerAngles2.y, ref GALFDIHLNGC.y, CJEDMBMEDML);
		eulerAngles.z = Mathf.SmoothDampAngle(eulerAngles.z, eulerAngles2.z, ref GALFDIHLNGC.z, CJEDMBMEDML);
		return Quaternion.Euler(eulerAngles);
	}

	// Token: 0x060257F7 RID: 153591 RVA: 0x00A694C8 File Offset: 0x00A676C8
	public static T2[] GEFFEAHKFHB<T1, T2>(this Dictionary<T1, T2>.ValueCollection MNAHFGFIDHN)
	{
		if (MNAHFGFIDHN.Count > 0)
		{
			T2[] array = new T2[MNAHFGFIDHN.Count];
			MNAHFGFIDHN.CopyTo(array, 0);
			return array;
		}
		return null;
	}

	// Token: 0x060257F8 RID: 153592 RVA: 0x00A694F8 File Offset: 0x00A676F8
	public static int CFGOGHLOALK<T>(this T[] GDLLJBOEGNF, T NOBAPCOKFIL)
	{
		for (int i = 0; i < GDLLJBOEGNF.Length; i++)
		{
			if (GDLLJBOEGNF[i].Equals(NOBAPCOKFIL))
			{
				return i;
			}
		}
		return -1;
	}

	// Token: 0x060257F9 RID: 153593 RVA: 0x00A6953C File Offset: 0x00A6773C
	public static int KDGFIHEPNFP<T>(this T[] GDLLJBOEGNF, T NOBAPCOKFIL)
	{
		int num = -1;
		for (int i = 0; i < GDLLJBOEGNF.Length; i++)
		{
			if (GDLLJBOEGNF[i].Equals(NOBAPCOKFIL))
			{
				num = i;
			}
		}
		return num;
	}

	// Token: 0x060257FA RID: 153594 RVA: 0x00A69584 File Offset: 0x00A67784
	public static Quaternion KPGAMOAKJKF(this Quaternion CHNGFKBEEHF)
	{
		return (!CHNGFKBEEHF.AJHIAHGEGDD() && !CHNGFKBEEHF.JMDMDLFCMND()) ? CHNGFKBEEHF : Quaternion.identity;
	}

	// Token: 0x060257FB RID: 153595 RVA: 0x00A695A8 File Offset: 0x00A677A8
	public static bool AJHIAHGEGDD(this Quaternion CHNGFKBEEHF)
	{
		return float.IsNaN(CHNGFKBEEHF.x) || float.IsNaN(CHNGFKBEEHF.y) || float.IsNaN(CHNGFKBEEHF.z) || float.IsNaN(CHNGFKBEEHF.w);
	}

	// Token: 0x060257FC RID: 153596 RVA: 0x00A695F8 File Offset: 0x00A677F8
	public static bool JMDMDLFCMND(this Quaternion CHNGFKBEEHF)
	{
		return float.IsInfinity(CHNGFKBEEHF.x) || float.IsInfinity(CHNGFKBEEHF.y) || float.IsInfinity(CHNGFKBEEHF.z) || float.IsInfinity(CHNGFKBEEHF.w);
	}

	// Token: 0x060257FD RID: 153597 RVA: 0x00A69648 File Offset: 0x00A67848
	public static float HCGEDPDBPBG(float BFLJBMLDMJL, float EGCFIACLGJO, float LHMELEOKNBJ)
	{
		return (EGCFIACLGJO - BFLJBMLDMJL * LHMELEOKNBJ) / (1f - LHMELEOKNBJ);
	}

	// Token: 0x060257FE RID: 153598 RVA: 0x00A69658 File Offset: 0x00A67858
	public static float NDNGIHGFNPC(float DKDPAJEBOFN, float EGCFIACLGJO, float LHMELEOKNBJ)
	{
		return (EGCFIACLGJO - DKDPAJEBOFN * (1f - LHMELEOKNBJ)) / LHMELEOKNBJ;
	}

	// Token: 0x060257FF RID: 153599 RVA: 0x00A69668 File Offset: 0x00A67868
	public static float HEIIJOEPPDH(float FKOFGIJFIKA, float GNNBOMAEBGK, float EGNBFLPNLNC)
	{
		float num;
		float num2;
		NNGFEGAEJPG.BOOANNLKMAP(FKOFGIJFIKA, GNNBOMAEBGK, EGNBFLPNLNC, out num, out num2);
		return Mathf.Max(num, num2);
	}

	// Token: 0x06025800 RID: 153600 RVA: 0x00A69688 File Offset: 0x00A67888
	public static float OPGEJJFFOII(float FKOFGIJFIKA, float GNNBOMAEBGK, float EGNBFLPNLNC)
	{
		float num;
		float num2;
		NNGFEGAEJPG.BOOANNLKMAP(FKOFGIJFIKA, GNNBOMAEBGK, EGNBFLPNLNC, out num, out num2);
		return Mathf.Min(num, num2);
	}

	// Token: 0x06025801 RID: 153601 RVA: 0x00A696A8 File Offset: 0x00A678A8
	public static void BOOANNLKMAP(float FKOFGIJFIKA, float GNNBOMAEBGK, float EGNBFLPNLNC, out float KECICANEEFK, out float GKFJNBLIIOM)
	{
		float num = Mathf.Sqrt(GNNBOMAEBGK * GNNBOMAEBGK - 4f * FKOFGIJFIKA * EGNBFLPNLNC);
		KECICANEEFK = (-GNNBOMAEBGK - num) / (2f * FKOFGIJFIKA);
		GKFJNBLIIOM = (-GNNBOMAEBGK + num) / (2f * FKOFGIJFIKA);
	}

	// Token: 0x06025802 RID: 153602 RVA: 0x00A696E8 File Offset: 0x00A678E8
	public static bool KFLBKDPEHEN<T>(this T[] GDLLJBOEGNF, T OKKMGANCMGB)
	{
		for (int i = 0; i < GDLLJBOEGNF.Length; i++)
		{
			if (object.Equals(GDLLJBOEGNF[i], OKKMGANCMGB))
			{
				return true;
			}
		}
		return false;
	}

	// Token: 0x06025803 RID: 153603 RVA: 0x00A69728 File Offset: 0x00A67928
	public static bool CCECMJEACMN(this Vector2 LCCDPOBCNCH, float NOBAPCOKFIL)
	{
		float num;
		float num2;
		if (LCCDPOBCNCH.x > LCCDPOBCNCH.y)
		{
			num = LCCDPOBCNCH.y;
			num2 = LCCDPOBCNCH.x;
		}
		else
		{
			num = LCCDPOBCNCH.x;
			num2 = LCCDPOBCNCH.y;
		}
		return NOBAPCOKFIL >= num && NOBAPCOKFIL <= num2;
	}

	// Token: 0x06025804 RID: 153604 RVA: 0x00A69780 File Offset: 0x00A67980
	public static bool PLKCJINIPMP(this Player.HDOICGIKKAO AJLJKOMBJGP)
	{
		return AJLJKOMBJGP == Player.HDOICGIKKAO.LeftHand || AJLJKOMBJGP == Player.HDOICGIKKAO.RightHand;
	}

	// Token: 0x06025805 RID: 153605 RVA: 0x00A69790 File Offset: 0x00A67990
	public static void OFFICKPKMFJ<T>(this IList<T> MKEOFCIGBDG)
	{
		int i = MKEOFCIGBDG.Count;
		global::System.Random random = new global::System.Random((int)DateTime.UtcNow.Ticks);
		while (i > 1)
		{
			int num = random.Next(0, i);
			i--;
			T t = MKEOFCIGBDG[num];
			MKEOFCIGBDG[num] = MKEOFCIGBDG[i];
			MKEOFCIGBDG[i] = t;
		}
	}

	// Token: 0x06025806 RID: 153606 RVA: 0x00A697F4 File Offset: 0x00A679F4
	public static T KDPEEIFOANI<T>(this IList<T> MKEOFCIGBDG)
	{
		return MKEOFCIGBDG[MKEOFCIGBDG.Count - 1];
	}

	// Token: 0x06025807 RID: 153607 RVA: 0x00A69804 File Offset: 0x00A67A04
	public static void GBNCHJLPJPI<T>(T[] GDLLJBOEGNF)
	{
		NNGFEGAEJPG.GBNCHJLPJPI<T>(GDLLJBOEGNF, (int)DateTime.UtcNow.Ticks);
	}

	// Token: 0x06025808 RID: 153608 RVA: 0x00A69828 File Offset: 0x00A67A28
	public static void GBNCHJLPJPI<T>(T[] GDLLJBOEGNF, int NIAMELDPIIF)
	{
		int i = GDLLJBOEGNF.Length;
		global::UnityEngine.Random.InitState(NIAMELDPIIF);
		while (i > 1)
		{
			int num = global::UnityEngine.Random.Range(0, i--);
			T t = GDLLJBOEGNF[i];
			GDLLJBOEGNF[i] = GDLLJBOEGNF[num];
			GDLLJBOEGNF[num] = t;
		}
	}

	// Token: 0x06025809 RID: 153609 RVA: 0x00A69878 File Offset: 0x00A67A78
	public static string KEPBEPDOIHJ(this GameObject FMEGPDMNPED)
	{
		Transform transform = FMEGPDMNPED.transform;
		string text = transform.name;
		transform = transform.parent;
		while (transform != null)
		{
			text = transform.name + " -> " + text;
			transform = transform.parent;
		}
		return text;
	}

	// Token: 0x0602580A RID: 153610 RVA: 0x00A698C8 File Offset: 0x00A67AC8
	public static float ELJDEEGMFHN(this float NOBAPCOKFIL, Vector2 FCKDMLHHFJJ, Vector2 IBNHADMMGBG)
	{
		float num = FCKDMLHHFJJ.y - FCKDMLHHFJJ.x;
		float num2 = (NOBAPCOKFIL - FCKDMLHHFJJ.x) / num;
		float num3 = IBNHADMMGBG.y - IBNHADMMGBG.x;
		return IBNHADMMGBG.x + num3 * num2;
	}

	// Token: 0x0602580B RID: 153611 RVA: 0x00A6990C File Offset: 0x00A67B0C
	public static string MJIIFCDDNMM(this Guid JAGNIKELELP)
	{
		return JAGNIKELELP.ToString("N");
	}

	// Token: 0x0602580C RID: 153612 RVA: 0x00A6991C File Offset: 0x00A67B1C
	public static bool KOMMBHNFFDN(List<Renderer> LLMACEFNAKG, out Bounds LCCDPOBCNCH, List<Renderer> ECILHIMDMDC = null)
	{
		bool flag = false;
		LCCDPOBCNCH = default(Bounds);
		if (ECILHIMDMDC == null)
		{
			ECILHIMDMDC = new List<Renderer>();
		}
		foreach (Renderer renderer in LLMACEFNAKG.Concat(ECILHIMDMDC))
		{
			if (!(renderer is ParticleSystemRenderer) && !(renderer is TrailRenderer))
			{
				if (!flag)
				{
					LCCDPOBCNCH = renderer.bounds;
					flag = true;
				}
				else if (renderer != null)
				{
					LCCDPOBCNCH.Encapsulate(renderer.bounds);
				}
			}
		}
		return flag;
	}

	// Token: 0x0602580D RID: 153613 RVA: 0x00A699D4 File Offset: 0x00A67BD4
	public static void GNEPMJNCMKL(this RenderTexture KPMMDGIAGPC, ref Texture2D JBGLHECEOPE)
	{
		RenderTexture active = RenderTexture.active;
		RenderTexture.active = KPMMDGIAGPC;
		if (JBGLHECEOPE == null)
		{
			JBGLHECEOPE = new Texture2D(KPMMDGIAGPC.width, KPMMDGIAGPC.height, TextureFormat.ARGB32, false);
		}
		JBGLHECEOPE.ReadPixels(new Rect(0f, 0f, (float)JBGLHECEOPE.width, (float)JBGLHECEOPE.height), 0, 0);
		JBGLHECEOPE.Apply();
		RenderTexture.active = active;
	}

	// Token: 0x0602580E RID: 153614 RVA: 0x00A69A44 File Offset: 0x00A67C44
	public static string PPKOEKKHJAG(this float FOEOKCHPILL)
	{
		int num = Mathf.RoundToInt(FOEOKCHPILL);
		return (num / 60).ToString("D2") + ":" + (num % 60).ToString("D2");
	}

	// Token: 0x0602580F RID: 153615 RVA: 0x00A69A84 File Offset: 0x00A67C84
	public static void BMPDLKPAPGK(this Renderer IFEDGEGIPFC, float ELFEPDAKCDL)
	{
		Color color = IFEDGEGIPFC.material.color;
		color.a = ELFEPDAKCDL;
		IFEDGEGIPFC.material.color = color;
	}

	// Token: 0x06025810 RID: 153616 RVA: 0x00A69AB4 File Offset: 0x00A67CB4
	public static int MLAKEDFEFGM(this TextAnchor MKINBKJIKOC)
	{
		switch (MKINBKJIKOC)
		{
		case TextAnchor.UpperLeft:
		case TextAnchor.UpperCenter:
		case TextAnchor.UpperRight:
			return 1;
		case TextAnchor.LowerLeft:
		case TextAnchor.LowerCenter:
		case TextAnchor.LowerRight:
			return -1;
		}
		return 0;
	}

	// Token: 0x06025811 RID: 153617 RVA: 0x00A69AEC File Offset: 0x00A67CEC
	public static float MOEHLAHMPFE(this Vector2 FLKMJFAOABP, Vector2 MABKDDJKKPL)
	{
		Vector3 vector = FLKMJFAOABP;
		Vector3 vector2 = MABKDDJKKPL;
		return vector.PJBALLOOEOF(vector2, new Vector3?(Vector3.forward));
	}

	// Token: 0x06025812 RID: 153618 RVA: 0x00A69B18 File Offset: 0x00A67D18
	public static bool DFFGNHPIPJB(string CCBDPEIAHMM)
	{
		Regex regex = new Regex("^[\\w!#$%&'*+\\-/=?\\^_`{|}~]+(\\.[\\w!#$%&'*+\\-/=?\\^_`{|}~]+)*@((([\\-\\w]+\\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\\.){3}[0-9]{1,3}))$");
		Match match = regex.Match(CCBDPEIAHMM);
		return match.Success;
	}

	// Token: 0x06025813 RID: 153619 RVA: 0x00A69B40 File Offset: 0x00A67D40
	public static string HDDFDDFHEHB(this string NOBAPCOKFIL, int NPKFFOECKCN, string MMCEMOILEBI = "")
	{
		if (string.IsNullOrEmpty(NOBAPCOKFIL))
		{
			return NOBAPCOKFIL;
		}
		return (NOBAPCOKFIL.Length > NPKFFOECKCN) ? (NOBAPCOKFIL.Substring(0, NPKFFOECKCN) + MMCEMOILEBI) : NOBAPCOKFIL;
	}

	// Token: 0x06025814 RID: 153620 RVA: 0x00A69B70 File Offset: 0x00A67D70
	public static Color OACAENEBKNN(this Color HNOPCLEFEIG, float POHIMKLKLHK)
	{
		Color color = HNOPCLEFEIG;
		color.a = POHIMKLKLHK;
		return color;
	}

	// Token: 0x06025815 RID: 153621 RVA: 0x00A69B88 File Offset: 0x00A67D88
	public static V LCPJBBBPLEH<T, V>(this T LHMELEOKNBJ, Func<T, V> ENCDNMEMIIF, V FJIHPPGEJCF = default(V)) where T : class
	{
		if (LHMELEOKNBJ != null)
		{
			return ENCDNMEMIIF(LHMELEOKNBJ);
		}
		return FJIHPPGEJCF;
	}

	// Token: 0x06025816 RID: 153622 RVA: 0x00A69BA0 File Offset: 0x00A67DA0
	public static void LAMMJKLHNOL<T>(this T LHMELEOKNBJ, Action<T> ENCDNMEMIIF) where T : class
	{
		if (LHMELEOKNBJ != null)
		{
			ENCDNMEMIIF(LHMELEOKNBJ);
		}
	}

	// Token: 0x06025817 RID: 153623 RVA: 0x00A69BB4 File Offset: 0x00A67DB4
	public static float PEKFJINKCPD()
	{
		return (global::UnityEngine.Random.Range(0, 2) != 0) ? 1f : (-1f);
	}

	// Token: 0x06025818 RID: 153624 RVA: 0x00A69BD4 File Offset: 0x00A67DD4
	public static bool GECFBNNMHCE(float LNDKODPHOCP)
	{
		return global::UnityEngine.Random.value <= LNDKODPHOCP;
	}

	// Token: 0x06025819 RID: 153625 RVA: 0x00A69BE4 File Offset: 0x00A67DE4
	public static bool NMKGGNNEIDC(this EEBPLECPEGD HPMPJMIOMCK)
	{
		AGFCGHIFLIK agfcghiflik = ((HPMPJMIOMCK == null) ? null : GLGMPGPNNBP.CPIBGJLHLBL(ObscuredLong.EDHNDLCFIOL(HPMPJMIOMCK.PKJFPDJKJAH)));
		return agfcghiflik == null || (agfcghiflik.EEAOGJHMFII == AGFCGHIFLIK.AHHAANFJKJA.None && agfcghiflik.KBOBNFHLABB == AGFCGHIFLIK.DKDCJMEPHCJ.None);
	}

	// Token: 0x0602581A RID: 153626 RVA: 0x00A69C30 File Offset: 0x00A67E30
	public static bool OJOCDJLADNI(this EEBPLECPEGD HPMPJMIOMCK)
	{
		if (HPMPJMIOMCK == null || HPMPJMIOMCK.HPLFAJMJKGO)
		{
			return false;
		}
		bool flag = ObscuredInt.EDHNDLCFIOL(HPMPJMIOMCK.EFHLFMMGAGP) >= 3;
		bool flag2 = HPMPJMIOMCK.NBBBIJDAFCF() <= 0;
		return flag && flag2;
	}

	// Token: 0x0602581B RID: 153627 RVA: 0x00A69C7C File Offset: 0x00A67E7C
	public static TValue IFIIFGLDHJK<TKey, TValue>(this IDictionary<TKey, TValue> NILLMCJCHJH, TKey ANOFFEKMECJ) where TValue : new()
	{
		TValue tvalue;
		if (!NILLMCJCHJH.TryGetValue(ANOFFEKMECJ, out tvalue))
		{
			tvalue = new TValue();
			NILLMCJCHJH.Add(ANOFFEKMECJ, tvalue);
		}
		return tvalue;
	}

	// Token: 0x0602581C RID: 153628 RVA: 0x00A69CA8 File Offset: 0x00A67EA8
	public static Texture2D PGDCDGKDMBE(this Texture2D MOLHGDEPNKN, Vector2 BHIKEGFDJEI, int PKKMPHIOBNB = 2)
	{
		int width = MOLHGDEPNKN.width;
		int height = MOLHGDEPNKN.height;
		Texture2D texture2D = global::UnityEngine.Object.Instantiate<Texture2D>(MOLHGDEPNKN);
		int num = (int)((float)width - BHIKEGFDJEI.x) / PKKMPHIOBNB;
		int num2 = (int)((float)height - BHIKEGFDJEI.y) / PKKMPHIOBNB;
		for (int i = 1; i < PKKMPHIOBNB - 1; i++)
		{
			PJGGFELBOAL.GAFBBDJNJIK(texture2D, width - i * num, height - i * num2);
		}
		PJGGFELBOAL.GAFBBDJNJIK(texture2D, (int)BHIKEGFDJEI.x, (int)BHIKEGFDJEI.y);
		return texture2D;
	}

	// Token: 0x0602581D RID: 153629 RVA: 0x00A69D2C File Offset: 0x00A67F2C
	public static void MOFFLDPKFHI(this Material PNPJBLJGEAM, string FDOPLANONDH, bool KELIMOCDMOD)
	{
		if (KELIMOCDMOD)
		{
			PNPJBLJGEAM.EnableKeyword(FDOPLANONDH);
		}
		else
		{
			PNPJBLJGEAM.DisableKeyword(FDOPLANONDH);
		}
	}

	// Token: 0x0602581E RID: 153630 RVA: 0x00A69D48 File Offset: 0x00A67F48
	public static void MMEHIAJOEHA(this Animator FIOLBHFJENN, int HPCOKMAPCHB, bool NOBAPCOKFIL)
	{
		if (FIOLBHFJENN.gameObject.activeInHierarchy)
		{
			FIOLBHFJENN.SetBool(HPCOKMAPCHB, NOBAPCOKFIL);
		}
	}

	// Token: 0x0602581F RID: 153631 RVA: 0x00A69D64 File Offset: 0x00A67F64
	public static void MMEHIAJOEHA(this Animator FIOLBHFJENN, string EKKMPHMGCLB, bool NOBAPCOKFIL)
	{
		if (FIOLBHFJENN.gameObject.activeInHierarchy)
		{
			FIOLBHFJENN.SetBool(EKKMPHMGCLB, NOBAPCOKFIL);
		}
	}

	// Token: 0x06025820 RID: 153632 RVA: 0x00A69D80 File Offset: 0x00A67F80
	public static void HPAOJHHCBNG(this Animator FIOLBHFJENN, string EKKMPHMGCLB, float NOBAPCOKFIL)
	{
		if (FIOLBHFJENN.gameObject.activeInHierarchy)
		{
			FIOLBHFJENN.SetFloat(EKKMPHMGCLB, NOBAPCOKFIL);
		}
	}

	// Token: 0x06025821 RID: 153633 RVA: 0x00A69D9C File Offset: 0x00A67F9C
	public static void HPAOJHHCBNG(this Animator FIOLBHFJENN, int HPCOKMAPCHB, float NOBAPCOKFIL)
	{
		if (FIOLBHFJENN.gameObject.activeInHierarchy)
		{
			FIOLBHFJENN.SetFloat(HPCOKMAPCHB, NOBAPCOKFIL);
		}
	}

	// Token: 0x06025822 RID: 153634 RVA: 0x00A69DB8 File Offset: 0x00A67FB8
	public static void HPAOJHHCBNG(this Animator FIOLBHFJENN, string EKKMPHMGCLB, float NOBAPCOKFIL, float APOAFCDCHIO, float KGNAMMELBPH)
	{
		if (FIOLBHFJENN.gameObject.activeInHierarchy)
		{
			FIOLBHFJENN.SetFloat(EKKMPHMGCLB, NOBAPCOKFIL, APOAFCDCHIO, KGNAMMELBPH);
		}
	}

	// Token: 0x06025823 RID: 153635 RVA: 0x00A69DD8 File Offset: 0x00A67FD8
	public static void HPAOJHHCBNG(this Animator FIOLBHFJENN, int HPCOKMAPCHB, float NOBAPCOKFIL, float APOAFCDCHIO, float KGNAMMELBPH)
	{
		if (FIOLBHFJENN.gameObject.activeInHierarchy)
		{
			FIOLBHFJENN.SetFloat(HPCOKMAPCHB, NOBAPCOKFIL, APOAFCDCHIO, KGNAMMELBPH);
		}
	}

	// Token: 0x06025824 RID: 153636 RVA: 0x00A69DF8 File Offset: 0x00A67FF8
	public static void EGCMHABOLCA(this Animator FIOLBHFJENN, int HPCOKMAPCHB, int NOBAPCOKFIL)
	{
		if (FIOLBHFJENN.gameObject.activeInHierarchy)
		{
			FIOLBHFJENN.SetInteger(HPCOKMAPCHB, NOBAPCOKFIL);
		}
	}

	// Token: 0x06025825 RID: 153637 RVA: 0x00A69E14 File Offset: 0x00A68014
	public static void EGCMHABOLCA(this Animator FIOLBHFJENN, string EKKMPHMGCLB, int NOBAPCOKFIL)
	{
		if (FIOLBHFJENN.gameObject.activeInHierarchy)
		{
			FIOLBHFJENN.SetInteger(EKKMPHMGCLB, NOBAPCOKFIL);
		}
	}

	// Token: 0x06025826 RID: 153638 RVA: 0x00A69E30 File Offset: 0x00A68030
	public static string IJBOOEEOOFO(this FileInfo JEPOCDGJGDP, string FOJIAJNLIPA, string MBKKEHIEELJ)
	{
		string text = string.Empty;
		if (JEPOCDGJGDP != null && JEPOCDGJGDP.Exists)
		{
			using (StreamReader streamReader = JEPOCDGJGDP.OpenText())
			{
				bool flag = false;
				string text2 = string.Empty;
				while ((text2 = streamReader.ReadLine()) != null)
				{
					if (flag)
					{
						if (!string.IsNullOrEmpty(MBKKEHIEELJ) && text2.Contains(MBKKEHIEELJ))
						{
							break;
						}
						text = text + text2 + Environment.NewLine;
					}
					else if (!string.IsNullOrEmpty(FOJIAJNLIPA) && text2.Contains(FOJIAJNLIPA))
					{
						flag = true;
					}
				}
			}
		}
		return text.Trim();
	}

	// Token: 0x06025827 RID: 153639 RVA: 0x00A69EEC File Offset: 0x00A680EC
	public static string IJBOOEEOOFO(this FileInfo JEPOCDGJGDP, int CONHODCIPKD, int IDDLEKGOAEM)
	{
		string text = string.Empty;
		if (JEPOCDGJGDP != null && JEPOCDGJGDP.Exists)
		{
			using (StreamReader streamReader = JEPOCDGJGDP.OpenText())
			{
				int num = 0;
				string text2 = string.Empty;
				while ((text2 = streamReader.ReadLine()) != null)
				{
					if (num >= CONHODCIPKD + IDDLEKGOAEM)
					{
						break;
					}
					if (num >= CONHODCIPKD)
					{
						text = text + text2 + Environment.NewLine;
					}
					num++;
				}
			}
		}
		return text.Trim();
	}

	// Token: 0x06025828 RID: 153640 RVA: 0x00A69F80 File Offset: 0x00A68180
	public static void CILPLBJMEMP(string NFAFJOMABOK, global::UnityEngine.Object CGMIJJGJJLH = null)
	{
		Debug.Log(NFAFJOMABOK, CGMIJJGJJLH);
		Console.WriteLine(NFAFJOMABOK);
	}

	// Token: 0x0602582A RID: 153642 RVA: 0x00A69FA8 File Offset: 0x00A681A8
	[CompilerGenerated]
	private static bool AEKHOOMLIKM<T>(T ILFEPFCLLFJ) where T : class
	{
		return ILFEPFCLLFJ == null;
	}

	// Token: 0x04005EC7 RID: 24263
	public static float JBAKMBLDAHC = 0.0001f;

	// Token: 0x04005EC8 RID: 24264
	public static float LFKLNKJBNEI = 1f;
}