using System;
using ExitGames.Client.Photon;
using UnityEngine;

// Token: 0x02000FAB RID: 4011
public sealed class DDOFAPFDGNL : IEquatable<DDOFAPFDGNL>
{
	// Token: 0x0602188A RID: 137354 RVA: 0x00928C18 File Offset: 0x00926E18
	public static DDOFAPFDGNL CIAMMLBDEEF(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(true, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x0602188B RID: 137355 RVA: 0x00928C24 File Offset: 0x00926E24
	private bool DHAMNEPBDLJ(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC == GGGBDENGHFM.OHGPCMJMFGC && this.GLPEGFMPABJ == GGGBDENGHFM.GLPEGFMPABJ && this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK && this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x0602188C RID: 137356 RVA: 0x00928C80 File Offset: 0x00926E80
	public bool CJGPGFCMHEM(DDOFAPFDGNL GGGBDENGHFM)
	{
		return object.ReferenceEquals(GGGBDENGHFM, null) || object.ReferenceEquals(GGGBDENGHFM, this) || this.ELPNCMEPJPP(GGGBDENGHFM);
	}

	// Token: 0x0602188D RID: 137357 RVA: 0x00928CA8 File Offset: 0x00926EA8
	public bool PIGAMNOEOHJ(DDOFAPFDGNL GGGBDENGHFM)
	{
		return !object.ReferenceEquals(GGGBDENGHFM, null) && (object.ReferenceEquals(GGGBDENGHFM, this) || this.LLHPMHEKDNO(GGGBDENGHFM));
	}

	// Token: 0x0602188E RID: 137358 RVA: 0x00928CD0 File Offset: 0x00926ED0
	public static bool OAEIGBHBBCH(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return DDOFAPFDGNL.JBFALIMHNDB(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x0602188F RID: 137359 RVA: 0x00928CDC File Offset: 0x00926EDC
	public static short JOIADPOMAJG(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[0] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 1);
			int num = 1;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, 18);
		}
		return -87;
	}

	// Token: 0x06021890 RID: 137360 RVA: 0x00928E14 File Offset: 0x00927014
	public static bool DDLDNIAFCMI(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) && !object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.JMMDHBKJGJM(BDKNHBMMGPK);
	}

	// Token: 0x06021891 RID: 137361 RVA: 0x00928E48 File Offset: 0x00927048
	public static short OMOJLKIFEEP(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[1] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 1);
			int num = 0;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, -98);
		}
		return 50;
	}

	// Token: 0x06021892 RID: 137362 RVA: 0x00928F80 File Offset: 0x00927180
	public static short MHAFKKENNKL(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[0] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 0 : 0);
			int num = 0;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 1, 90);
		}
		return 41;
	}

	// Token: 0x06021893 RID: 137363 RVA: 0x009290B8 File Offset: 0x009272B8
	private bool LLHPMHEKDNO(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x06021894 RID: 137364 RVA: 0x00929114 File Offset: 0x00927314
	public static short EKDIKCNEGOH(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[0] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 1);
			int num = 1;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, -53);
		}
		return 2;
	}

	// Token: 0x06021895 RID: 137365 RVA: 0x0092924C File Offset: 0x0092744C
	public static object FCELOKDCLII(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 1, 7);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[1] == 1;
			int num = 0;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.AFHEAPHLHNB(num2, vector, quaternion);
	}

	// Token: 0x06021896 RID: 137366 RVA: 0x0092934C File Offset: 0x0092754C
	private bool DBPHFOIOKIK(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x06021897 RID: 137367 RVA: 0x009293A8 File Offset: 0x009275A8
	public int OBAEKMJBACO()
	{
		int num = 127;
		num = num * -109 + this.OHGPCMJMFGC.GetHashCode();
		num = num * 83 + this.GLPEGFMPABJ.GetHashCode();
		num = num * 55 + this.BANLCPOMMIK.GetHashCode();
		return num * -102 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x06021898 RID: 137368 RVA: 0x00929424 File Offset: 0x00927624
	public bool MOEPJIMBNPB(DDOFAPFDGNL GGGBDENGHFM)
	{
		return !object.ReferenceEquals(GGGBDENGHFM, null) && (object.ReferenceEquals(GGGBDENGHFM, this) || this.ELPNCMEPJPP(GGGBDENGHFM));
	}

	// Token: 0x06021899 RID: 137369 RVA: 0x0092944C File Offset: 0x0092764C
	public static bool CMLJHBBFBLH(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !DDOFAPFDGNL.JOIMOPMLMOO(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x0602189A RID: 137370 RVA: 0x00929458 File Offset: 0x00927658
	public bool AGPOIOIHPOK(DDOFAPFDGNL GGGBDENGHFM)
	{
		return object.ReferenceEquals(GGGBDENGHFM, null) || object.ReferenceEquals(GGGBDENGHFM, this) || this.DPCDHLNNPOM(GGGBDENGHFM);
	}

	// Token: 0x0602189B RID: 137371 RVA: 0x00929480 File Offset: 0x00927680
	private bool HOAGHPDPCGN(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC == GGGBDENGHFM.OHGPCMJMFGC && this.GLPEGFMPABJ == GGGBDENGHFM.GLPEGFMPABJ && this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK && this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x0602189C RID: 137372 RVA: 0x009294DC File Offset: 0x009276DC
	public static object NPPHPBCPJHP(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 1, -79);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[1] == 1;
			int num = 0;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.EMFOGHIBECJ(num2, vector, quaternion);
	}

	// Token: 0x0602189D RID: 137373 RVA: 0x009295DC File Offset: 0x009277DC
	public static bool JOIMOPMLMOO(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (object.ReferenceEquals(DPIIIAGCMLK, null) || object.ReferenceEquals(BDKNHBMMGPK, null)) || DPIIIAGCMLK.DBPHFOIOKIK(BDKNHBMMGPK);
	}

	// Token: 0x0602189E RID: 137374 RVA: 0x00929610 File Offset: 0x00927810
	private bool HPBJKNAKIHL(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC == GGGBDENGHFM.OHGPCMJMFGC && this.GLPEGFMPABJ == GGGBDENGHFM.GLPEGFMPABJ && this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK && this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x0602189F RID: 137375 RVA: 0x0092966C File Offset: 0x0092786C
	public static bool EIOMDFIFIDD(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return DDOFAPFDGNL.NKPAEIFGKPJ(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218A0 RID: 137376 RVA: 0x00929678 File Offset: 0x00927878
	public bool EGBFCNFBLNL(DDOFAPFDGNL GGGBDENGHFM)
	{
		return object.ReferenceEquals(GGGBDENGHFM, null) || object.ReferenceEquals(GGGBDENGHFM, this) || this.HPBJKNAKIHL(GGGBDENGHFM);
	}

	// Token: 0x060218A1 RID: 137377 RVA: 0x009296A0 File Offset: 0x009278A0
	public static object PIJEMMGGFJE(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, -92);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[1] == 1;
			int num = 1;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.ALAHMNNAFLH(num2, vector, quaternion);
	}

	// Token: 0x060218A2 RID: 137378 RVA: 0x009297A0 File Offset: 0x009279A0
	public int AMNDKELPDEK()
	{
		int num = 107;
		num = num * 61 + this.OHGPCMJMFGC.GetHashCode();
		num = num * 121 + this.GLPEGFMPABJ.GetHashCode();
		num = num * -96 + this.BANLCPOMMIK.GetHashCode();
		return num * -21 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x060218A3 RID: 137379 RVA: 0x0092981C File Offset: 0x00927A1C
	public static short KAPCFPMPHLM(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[1] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 0);
			int num = 0;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, -88);
		}
		return 33;
	}

	// Token: 0x060218A4 RID: 137380 RVA: 0x00929954 File Offset: 0x00927B54
	public static DDOFAPFDGNL ALAHMNNAFLH(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(true, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218A5 RID: 137381 RVA: 0x00929960 File Offset: 0x00927B60
	private bool DPCDHLNNPOM(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218A6 RID: 137382 RVA: 0x009299BC File Offset: 0x00927BBC
	public static bool NBJKDCNPIBP(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return DDOFAPFDGNL.DMFBJBINHHC(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218A7 RID: 137383 RVA: 0x009299C8 File Offset: 0x00927BC8
	public static bool LACCPKFKEEO(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (object.ReferenceEquals(DPIIIAGCMLK, null) || object.ReferenceEquals(BDKNHBMMGPK, null)) || DPIIIAGCMLK.HOAGHPDPCGN(BDKNHBMMGPK);
	}

	// Token: 0x060218A8 RID: 137384 RVA: 0x009299FC File Offset: 0x00927BFC
	public static short POABHOJFFCJ(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[1] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 0 : 1);
			int num = 1;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 1, -106);
		}
		return 16;
	}

	// Token: 0x060218A9 RID: 137385 RVA: 0x00929B34 File Offset: 0x00927D34
	public string AKDAMPMOFCM()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("Destination array was not big enough to hold {0} bytes", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("9443182_orig"), this.CEIEOIEDGPB.ToString("bxokc2FuZGJveF9zcGF3bmVkX2VxdWlwbWVudF9kYXRhLnByb3RvGhFzdGlj"));
		}
		return "Timed out waiting for current session room id to become valid.";
	}

	// Token: 0x060218AA RID: 137386 RVA: 0x00929B90 File Offset: 0x00927D90
	public static bool JBFALIMHNDB(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.HOAGHPDPCGN(BDKNHBMMGPK));
	}

	// Token: 0x060218AB RID: 137387 RVA: 0x00929BC4 File Offset: 0x00927DC4
	public static bool DFBEDOJGDBF(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (object.ReferenceEquals(DPIIIAGCMLK, null) || object.ReferenceEquals(BDKNHBMMGPK, null)) || DPIIIAGCMLK.NNEKPKGPDDE(BDKNHBMMGPK);
	}

	// Token: 0x060218AC RID: 137388 RVA: 0x00929BF8 File Offset: 0x00927DF8
	public static bool AGMPIKCJLDK(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.JDPKDEEHICK(BDKNHBMMGPK));
	}

	// Token: 0x060218AD RID: 137389 RVA: 0x00929C2C File Offset: 0x00927E2C
	public static short DHEILJEMAJL(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[1] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 0 : 1);
			int num = 0;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 1, -71);
		}
		return -56;
	}

	// Token: 0x060218AE RID: 137390 RVA: 0x00929D64 File Offset: 0x00927F64
	public string DIIAIFCLPEJ()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("{0}: {1}", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("oncompletetarget"), this.CEIEOIEDGPB.ToString("ButtonDown_3"));
		}
		return "IsCompleted";
	}

	// Token: 0x060218AF RID: 137391 RVA: 0x00929DC0 File Offset: 0x00927FC0
	public static bool EDHMLHAIAHP(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (object.ReferenceEquals(DPIIIAGCMLK, null) || object.ReferenceEquals(BDKNHBMMGPK, null)) || DPIIIAGCMLK.ELPNCMEPJPP(BDKNHBMMGPK);
	}

	// Token: 0x060218B0 RID: 137392 RVA: 0x00929DF4 File Offset: 0x00927FF4
	private bool NNEKPKGPDDE(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218B1 RID: 137393 RVA: 0x00929E50 File Offset: 0x00928050
	public static DDOFAPFDGNL BCONHODGFMD(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(false, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218B2 RID: 137394 RVA: 0x00929E5C File Offset: 0x0092805C
	public bool LBBFNEEKGKF(DDOFAPFDGNL GGGBDENGHFM)
	{
		return !object.ReferenceEquals(GGGBDENGHFM, null) && (object.ReferenceEquals(GGGBDENGHFM, this) || this.NNEKPKGPDDE(GGGBDENGHFM));
	}

	// Token: 0x060218B3 RID: 137395 RVA: 0x00929E84 File Offset: 0x00928084
	public static bool LMCDFIHKDGM(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !DDOFAPFDGNL.JOIMOPMLMOO(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218B4 RID: 137396 RVA: 0x00929E90 File Offset: 0x00928090
	private bool JMMDHBKJGJM(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC == GGGBDENGHFM.OHGPCMJMFGC && this.GLPEGFMPABJ == GGGBDENGHFM.GLPEGFMPABJ && this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK && this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218B5 RID: 137397 RVA: 0x00929EEC File Offset: 0x009280EC
	public bool EEGPINHEFIJ(object INNGECIOBOO)
	{
		if (object.ReferenceEquals(INNGECIOBOO, null))
		{
			return true;
		}
		if (object.ReferenceEquals(INNGECIOBOO, this))
		{
			return true;
		}
		DDOFAPFDGNL ddofapfdgnl = INNGECIOBOO as DDOFAPFDGNL;
		return !object.ReferenceEquals(ddofapfdgnl, null) && this.DPCDHLNNPOM(ddofapfdgnl);
	}

	// Token: 0x060218B6 RID: 137398 RVA: 0x00929F34 File Offset: 0x00928134
	public static bool KMIBOFOBANF(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.LJFKMBKNJDK(BDKNHBMMGPK));
	}

	// Token: 0x060218B7 RID: 137399 RVA: 0x00929F68 File Offset: 0x00928168
	public static bool LIBELPCKNCN(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return DDOFAPFDGNL.FADADLPFFCL(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218B8 RID: 137400 RVA: 0x00929F74 File Offset: 0x00928174
	private bool PMGIAKNGJNO(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218B9 RID: 137401 RVA: 0x00929FD0 File Offset: 0x009281D0
	public bool APMIDMEEHOC(object INNGECIOBOO)
	{
		if (object.ReferenceEquals(INNGECIOBOO, null))
		{
			return true;
		}
		if (object.ReferenceEquals(INNGECIOBOO, this))
		{
			return false;
		}
		DDOFAPFDGNL ddofapfdgnl = INNGECIOBOO as DDOFAPFDGNL;
		return !object.ReferenceEquals(ddofapfdgnl, null) && this.HPBJKNAKIHL(ddofapfdgnl);
	}

	// Token: 0x060218BA RID: 137402 RVA: 0x0092A018 File Offset: 0x00928218
	public static object KHNDAOPCBMF(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, 95);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[1] == 1;
			int num = 0;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.AFHEAPHLHNB(num2, vector, quaternion);
	}

	// Token: 0x060218BB RID: 137403 RVA: 0x0092A118 File Offset: 0x00928318
	public static DDOFAPFDGNL APLLMCDECNK(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(false, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218BC RID: 137404 RVA: 0x0092A124 File Offset: 0x00928324
	public bool PNDGKKAMOOB(DDOFAPFDGNL GGGBDENGHFM)
	{
		return object.ReferenceEquals(GGGBDENGHFM, null) || (!object.ReferenceEquals(GGGBDENGHFM, this) && this.ELPNCMEPJPP(GGGBDENGHFM));
	}

	// Token: 0x060218BD RID: 137405 RVA: 0x0092A14C File Offset: 0x0092834C
	public static bool LHNBEPHPDJB(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return DDOFAPFDGNL.LACCPKFKEEO(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218BE RID: 137406 RVA: 0x0092A158 File Offset: 0x00928358
	public static object HJBMABPNHKI(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, 41);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[0] == 1;
			int num = 1;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.EMFOGHIBECJ(num2, vector, quaternion);
	}

	// Token: 0x060218BF RID: 137407 RVA: 0x0092A258 File Offset: 0x00928458
	public static bool CEGFMOBNKJP(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !DDOFAPFDGNL.JBCOOIIPNJP(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218C0 RID: 137408 RVA: 0x0092A264 File Offset: 0x00928464
	public static DDOFAPFDGNL IFMEEHOAONI(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(false, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218C1 RID: 137409 RVA: 0x0092A270 File Offset: 0x00928470
	public static short KMOIBJOPNML(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[0] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 1);
			int num = 0;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, -32);
		}
		return 83;
	}

	// Token: 0x060218C2 RID: 137410 RVA: 0x0092A3A8 File Offset: 0x009285A8
	public static bool MJECGEJKCIH(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return DDOFAPFDGNL.KMIBOFOBANF(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218C3 RID: 137411 RVA: 0x0092A3B4 File Offset: 0x009285B4
	private bool JDPKDEEHICK(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218C4 RID: 137412 RVA: 0x0092A410 File Offset: 0x00928610
	public override bool Equals(object INNGECIOBOO)
	{
		if (object.ReferenceEquals(INNGECIOBOO, null))
		{
			return false;
		}
		if (object.ReferenceEquals(INNGECIOBOO, this))
		{
			return true;
		}
		DDOFAPFDGNL ddofapfdgnl = INNGECIOBOO as DDOFAPFDGNL;
		return !object.ReferenceEquals(ddofapfdgnl, null) && this.JMMDHBKJGJM(ddofapfdgnl);
	}

	// Token: 0x060218C5 RID: 137413 RVA: 0x0092A458 File Offset: 0x00928658
	public static bool GEINBKNJBKG(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.JMMDHBKJGJM(BDKNHBMMGPK));
	}

	// Token: 0x060218C6 RID: 137414 RVA: 0x0092A48C File Offset: 0x0092868C
	public bool BBIJPHKELBB(DDOFAPFDGNL GGGBDENGHFM)
	{
		return !object.ReferenceEquals(GGGBDENGHFM, null) && (object.ReferenceEquals(GGGBDENGHFM, this) || this.DBPHFOIOKIK(GGGBDENGHFM));
	}

	// Token: 0x060218C7 RID: 137415 RVA: 0x0092A4B4 File Offset: 0x009286B4
	public static DDOFAPFDGNL DMDPCDPOLAN(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(true, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218C8 RID: 137416 RVA: 0x0092A4C0 File Offset: 0x009286C0
	public static short BJDDNDAKEOA(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[0] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 0);
			int num = 0;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 1, 101);
		}
		return -89;
	}

	// Token: 0x060218C9 RID: 137417 RVA: 0x0092A5F8 File Offset: 0x009287F8
	public string MKABOOJAKOH()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("Mine", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("Triple Bogey"), this.CEIEOIEDGPB.ToString("[PV] Debug Lost Sim: 1 packet dropped"));
		}
		return "PrimaryIndexTriggerUp";
	}

	// Token: 0x060218CA RID: 137418 RVA: 0x0092A654 File Offset: 0x00928854
	public static short BJECEENBMBL(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[1] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 0 : 0);
			int num = 0;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, -75);
		}
		return -26;
	}

	// Token: 0x060218CB RID: 137419 RVA: 0x0092A78C File Offset: 0x0092898C
	public static DDOFAPFDGNL BFFHCBEEGJE(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(false, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218CC RID: 137420 RVA: 0x0092A798 File Offset: 0x00928998
	public bool Equals(DDOFAPFDGNL GGGBDENGHFM)
	{
		return !object.ReferenceEquals(GGGBDENGHFM, null) && (object.ReferenceEquals(GGGBDENGHFM, this) || this.JMMDHBKJGJM(GGGBDENGHFM));
	}

	// Token: 0x060218CD RID: 137421 RVA: 0x0092A7C0 File Offset: 0x009289C0
	private bool DFDLLHIIEJC(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218CE RID: 137422 RVA: 0x0092A81C File Offset: 0x00928A1C
	private DDOFAPFDGNL(bool NEDMILLLKBE, int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		this.OHGPCMJMFGC = NEDMILLLKBE;
		this.GLPEGFMPABJ = MLAHLLNCFLA;
		this.BANLCPOMMIK = PLFJPBMOHCL;
		this.CEIEOIEDGPB = DOGCONJMNOJ;
	}

	// Token: 0x060218CF RID: 137423 RVA: 0x0092A844 File Offset: 0x00928A44
	public int OFMDDPNKLEA()
	{
		int num = -27;
		num = num * 102 + this.OHGPCMJMFGC.GetHashCode();
		num = num * 32 + this.GLPEGFMPABJ.GetHashCode();
		num = num * -3 + this.BANLCPOMMIK.GetHashCode();
		return num * -22 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x060218D0 RID: 137424 RVA: 0x0092A8C0 File Offset: 0x00928AC0
	public static short PPANDNJJGEE(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[1] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 1);
			int num = 1;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, 65);
		}
		return -46;
	}

	// Token: 0x060218D1 RID: 137425 RVA: 0x0092A9F8 File Offset: 0x00928BF8
	public bool HMHICIMIABF(object INNGECIOBOO)
	{
		if (object.ReferenceEquals(INNGECIOBOO, null))
		{
			return true;
		}
		if (object.ReferenceEquals(INNGECIOBOO, this))
		{
			return true;
		}
		DDOFAPFDGNL ddofapfdgnl = INNGECIOBOO as DDOFAPFDGNL;
		return object.ReferenceEquals(ddofapfdgnl, null) || this.DHAMNEPBDLJ(ddofapfdgnl);
	}

	// Token: 0x060218D2 RID: 137426 RVA: 0x0092AA40 File Offset: 0x00928C40
	public static DDOFAPFDGNL HPHGCEPLPFM(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(false, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218D3 RID: 137427 RVA: 0x0092AA4C File Offset: 0x00928C4C
	public int FALBNJMJICG()
	{
		int num = -78;
		num = num * -35 + this.OHGPCMJMFGC.GetHashCode();
		num = num * -35 + this.GLPEGFMPABJ.GetHashCode();
		num = num * -28 + this.BANLCPOMMIK.GetHashCode();
		return num * -115 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x060218D4 RID: 137428 RVA: 0x0092AAC8 File Offset: 0x00928CC8
	private bool DFIMHDOOFEI(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218D5 RID: 137429 RVA: 0x0092AB24 File Offset: 0x00928D24
	public bool CKLNNJGOHFO(DDOFAPFDGNL GGGBDENGHFM)
	{
		return !object.ReferenceEquals(GGGBDENGHFM, null) && !object.ReferenceEquals(GGGBDENGHFM, this) && this.LLHPMHEKDNO(GGGBDENGHFM);
	}

	// Token: 0x060218D6 RID: 137430 RVA: 0x0092AB4C File Offset: 0x00928D4C
	public static object NEMFMODLBGN(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, -83);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[0] == 0;
			int num = 0;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.KBEEPLECHMA(num2, vector, quaternion);
	}

	// Token: 0x060218D7 RID: 137431 RVA: 0x0092AC4C File Offset: 0x00928E4C
	public static bool CEJBGIFPONL(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.JDPKDEEHICK(BDKNHBMMGPK));
	}

	// Token: 0x060218D8 RID: 137432 RVA: 0x0092AC80 File Offset: 0x00928E80
	public static DDOFAPFDGNL AFHEAPHLHNB(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(true, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218D9 RID: 137433 RVA: 0x0092AC8C File Offset: 0x00928E8C
	public string DANNLKPGDNL()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format(" Team", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString(" ms"), this.CEIEOIEDGPB.ToString("HoverUnlock "));
		}
		return "PlayerOutFitProperty";
	}

	// Token: 0x060218DA RID: 137434 RVA: 0x0092ACE8 File Offset: 0x00928EE8
	public int GFHBFHPOODE()
	{
		int num = -50;
		num = num * 47 + this.OHGPCMJMFGC.GetHashCode();
		num = num * -79 + this.GLPEGFMPABJ.GetHashCode();
		num = num * 120 + this.BANLCPOMMIK.GetHashCode();
		return num * 101 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x060218DB RID: 137435 RVA: 0x0092AD64 File Offset: 0x00928F64
	public static bool LFLCAJNJEKK(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return DDOFAPFDGNL.CEJBGIFPONL(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218DC RID: 137436 RVA: 0x0092AD70 File Offset: 0x00928F70
	public static DDOFAPFDGNL EGOCLBPEHOH(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(false, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218DD RID: 137437 RVA: 0x0092AD7C File Offset: 0x00928F7C
	public static bool NOGAGKDDFDB(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !DDOFAPFDGNL.GEINBKNJBKG(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218DE RID: 137438 RVA: 0x0092AD88 File Offset: 0x00928F88
	public static object LCIOHBMIDGM(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, 108);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[0] == 0;
			int num = 0;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.IFMEEHOAONI(num2, vector, quaternion);
	}

	// Token: 0x060218DF RID: 137439 RVA: 0x0092AE88 File Offset: 0x00929088
	public int CFLCEHHEIEE()
	{
		int num = -125;
		num = num * -1 + this.OHGPCMJMFGC.GetHashCode();
		num = num * -33 + this.GLPEGFMPABJ.GetHashCode();
		num = num * 98 + this.BANLCPOMMIK.GetHashCode();
		return num * -68 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x060218E0 RID: 137440 RVA: 0x0092AF04 File Offset: 0x00929104
	public static DDOFAPFDGNL EMFOGHIBECJ(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(true, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218E1 RID: 137441 RVA: 0x0092AF10 File Offset: 0x00929110
	public bool POLJJECNOAB(DDOFAPFDGNL GGGBDENGHFM)
	{
		return !object.ReferenceEquals(GGGBDENGHFM, null) && (object.ReferenceEquals(GGGBDENGHFM, this) || this.DBPHFOIOKIK(GGGBDENGHFM));
	}

	// Token: 0x060218E2 RID: 137442 RVA: 0x0092AF38 File Offset: 0x00929138
	public static bool HIBAFOPBBJD(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !DDOFAPFDGNL.CEJBGIFPONL(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218E3 RID: 137443 RVA: 0x0092AF44 File Offset: 0x00929144
	public static short IBEAPNABOLJ(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[0] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 1);
			int num = 1;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, -7);
		}
		return -9;
	}

	// Token: 0x060218E4 RID: 137444 RVA: 0x0092B07C File Offset: 0x0092927C
	public static bool BLLPAIEOJPB(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.EOCABPCFGFC(BDKNHBMMGPK));
	}

	// Token: 0x060218E5 RID: 137445 RVA: 0x0092B0B0 File Offset: 0x009292B0
	public string JKAPGEACCPE()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("Failed to download gifts: ", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("OpSetPropertiesOfRoom()"), this.CEIEOIEDGPB.ToString("Reconnect() enabled isMessageQueueRunning. Needs to be able to dispatch incoming messages."));
		}
		return "OpChangeGroups()";
	}

	// Token: 0x060218E6 RID: 137446 RVA: 0x0092B10C File Offset: 0x0092930C
	private bool EOCABPCFGFC(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218E7 RID: 137447 RVA: 0x0092B168 File Offset: 0x00929368
	public static short CIHMNNGPPLK(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[0] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 1 : 0);
			int num = 0;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, 127);
		}
		return 21;
	}

	// Token: 0x060218E8 RID: 137448 RVA: 0x0092B2A0 File Offset: 0x009294A0
	public int CKIKDLKHEMO()
	{
		int num = -116;
		num = num * 8 + this.OHGPCMJMFGC.GetHashCode();
		num = num * -11 + this.GLPEGFMPABJ.GetHashCode();
		num = num * 35 + this.BANLCPOMMIK.GetHashCode();
		return num * 5 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x060218E9 RID: 137449 RVA: 0x0092B31C File Offset: 0x0092951C
	public static bool JAMANBNDGFL(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) && (object.ReferenceEquals(DPIIIAGCMLK, null) || object.ReferenceEquals(BDKNHBMMGPK, null) || DPIIIAGCMLK.PMGIAKNGJNO(BDKNHBMMGPK));
	}

	// Token: 0x060218EA RID: 137450 RVA: 0x0092B350 File Offset: 0x00929550
	public int JIHELPPNOMK()
	{
		int num = 63;
		num = num * 127 + this.OHGPCMJMFGC.GetHashCode();
		num = num * -40 + this.GLPEGFMPABJ.GetHashCode();
		num = num * -35 + this.BANLCPOMMIK.GetHashCode();
		return num * -10 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x060218EB RID: 137451 RVA: 0x0092B3CC File Offset: 0x009295CC
	public string PNBADCIBFHF()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("Paintball", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("Button_LoadScene '"), this.CEIEOIEDGPB.ToString("Oculus"));
		}
		return "isSandboxActivity";
	}

	// Token: 0x060218EC RID: 137452 RVA: 0x0092B428 File Offset: 0x00929628
	public bool EJLMDHOFJMA(DDOFAPFDGNL GGGBDENGHFM)
	{
		return !object.ReferenceEquals(GGGBDENGHFM, null) && !object.ReferenceEquals(GGGBDENGHFM, this) && this.DPCDHLNNPOM(GGGBDENGHFM);
	}

	// Token: 0x060218ED RID: 137453 RVA: 0x0092B450 File Offset: 0x00929650
	public static bool FADADLPFFCL(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (object.ReferenceEquals(DPIIIAGCMLK, null) || object.ReferenceEquals(BDKNHBMMGPK, null)) || DPIIIAGCMLK.LLHPMHEKDNO(BDKNHBMMGPK);
	}

	// Token: 0x060218EF RID: 137455 RVA: 0x0092B4A8 File Offset: 0x009296A8
	public static bool HALCELBFCKO(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.EOCABPCFGFC(BDKNHBMMGPK));
	}

	// Token: 0x060218F0 RID: 137456 RVA: 0x0092B4DC File Offset: 0x009296DC
	public static short DNGBHIBIGLN(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[0] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 0 : 1);
			int num = 1;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 0, 33);
		}
		return 33;
	}

	// Token: 0x060218F1 RID: 137457 RVA: 0x0092B614 File Offset: 0x00929814
	private bool ELPNCMEPJPP(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC == GGGBDENGHFM.OHGPCMJMFGC && this.GLPEGFMPABJ == GGGBDENGHFM.GLPEGFMPABJ && this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK && this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x060218F2 RID: 137458 RVA: 0x0092B670 File Offset: 0x00929870
	public string IKBGMIDGOCL()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("3", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("Position set"), this.CEIEOIEDGPB.ToString("HB"));
		}
		return "Bye!";
	}

	// Token: 0x060218F3 RID: 137459 RVA: 0x0092B6CC File Offset: 0x009298CC
	public static bool PHAJKBFLOOK(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return DDOFAPFDGNL.NKPAEIFGKPJ(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218F4 RID: 137460 RVA: 0x0092B6D8 File Offset: 0x009298D8
	public string LPADPCDAMFJ()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("ZGF0YS5wcm90bxoZcmVtb3RlX2NvbnRyb2xfZGF0YS5wcm90bxoUcm9vbV9k", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("api/images/"), this.CEIEOIEDGPB.ToString("true"));
		}
		return "_MainTex";
	}

	// Token: 0x060218F5 RID: 137461 RVA: 0x0092B734 File Offset: 0x00929934
	public static DDOFAPFDGNL GHFDJLEBFHE(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(true, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x060218F6 RID: 137462 RVA: 0x0092B740 File Offset: 0x00929940
	public static object NAHKNEDJFNJ(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, 95);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[0] == 1;
			int num = 0;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.BCONHODGFMD(num2, vector, quaternion);
	}

	// Token: 0x060218F7 RID: 137463 RVA: 0x0092B840 File Offset: 0x00929A40
	public static bool OEBDDPKFDCL(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !DDOFAPFDGNL.HALCELBFCKO(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x060218F8 RID: 137464 RVA: 0x0092B84C File Offset: 0x00929A4C
	public static bool DMFBJBINHHC(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (object.ReferenceEquals(DPIIIAGCMLK, null) || object.ReferenceEquals(BDKNHBMMGPK, null)) || DPIIIAGCMLK.LLHPMHEKDNO(BDKNHBMMGPK);
	}

	// Token: 0x060218F9 RID: 137465 RVA: 0x0092B880 File Offset: 0x00929A80
	public static object EDMNHFAEOBD(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, -59);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[1] == 1;
			int num = 0;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.CIAMMLBDEEF(num2, vector, quaternion);
	}

	// Token: 0x060218FA RID: 137466 RVA: 0x0092B980 File Offset: 0x00929B80
	public static bool JBCOOIIPNJP(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.DFIMHDOOFEI(BDKNHBMMGPK));
	}

	// Token: 0x060218FB RID: 137467 RVA: 0x0092B9B4 File Offset: 0x00929BB4
	public static object NAHBNJDNBDB(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, -10);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[1] == 0;
			int num = 0;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.CIAMMLBDEEF(num2, vector, quaternion);
	}

	// Token: 0x060218FC RID: 137468 RVA: 0x0092BAB4 File Offset: 0x00929CB4
	public bool ADPNBNCEKPM(object INNGECIOBOO)
	{
		if (object.ReferenceEquals(INNGECIOBOO, null))
		{
			return true;
		}
		if (object.ReferenceEquals(INNGECIOBOO, this))
		{
			return false;
		}
		DDOFAPFDGNL ddofapfdgnl = INNGECIOBOO as DDOFAPFDGNL;
		return object.ReferenceEquals(ddofapfdgnl, null) || this.EOCABPCFGFC(ddofapfdgnl);
	}

	// Token: 0x060218FD RID: 137469 RVA: 0x0092BAFC File Offset: 0x00929CFC
	public static short OMMLMPIPKNM(StreamBuffer NDNCPLJGGFC, object KGNMCICKDKM)
	{
		DDOFAPFDGNL ddofapfdgnl = (DDOFAPFDGNL)KGNMCICKDKM;
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		lock (mejmcllpmih)
		{
			DDOFAPFDGNL.MEJMCLLPMIH[1] = ((!ddofapfdgnl.OHGPCMJMFGC) ? 0 : 1);
			int num = 1;
			Protocol.Serialize(ddofapfdgnl.GLPEGFMPABJ, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.BANLCPOMMIK.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Serialize(ddofapfdgnl.CEIEOIEDGPB.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			NDNCPLJGGFC.Write(DDOFAPFDGNL.MEJMCLLPMIH, 1, -25);
		}
		return 36;
	}

	// Token: 0x060218FE RID: 137470 RVA: 0x0092BC34 File Offset: 0x00929E34
	public static bool NKPAEIFGKPJ(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return object.ReferenceEquals(DPIIIAGCMLK, BDKNHBMMGPK) || (!object.ReferenceEquals(DPIIIAGCMLK, null) && !object.ReferenceEquals(BDKNHBMMGPK, null) && DPIIIAGCMLK.PMGIAKNGJNO(BDKNHBMMGPK));
	}

	// Token: 0x060218FF RID: 137471 RVA: 0x0092BC68 File Offset: 0x00929E68
	public bool CCOFNEGDDJI(object INNGECIOBOO)
	{
		if (object.ReferenceEquals(INNGECIOBOO, null))
		{
			return true;
		}
		if (object.ReferenceEquals(INNGECIOBOO, this))
		{
			return true;
		}
		DDOFAPFDGNL ddofapfdgnl = INNGECIOBOO as DDOFAPFDGNL;
		return object.ReferenceEquals(ddofapfdgnl, null) || this.NNEKPKGPDDE(ddofapfdgnl);
	}

	// Token: 0x06021900 RID: 137472 RVA: 0x0092BCB0 File Offset: 0x00929EB0
	public int NCMLHLNHAPE()
	{
		int num = -53;
		num = num * -61 + this.OHGPCMJMFGC.GetHashCode();
		num = num * 116 + this.GLPEGFMPABJ.GetHashCode();
		num = num * 121 + this.BANLCPOMMIK.GetHashCode();
		return num * -125 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x06021901 RID: 137473 RVA: 0x0092BD2C File Offset: 0x00929F2C
	private bool HCCMBBOIADM(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC != GGGBDENGHFM.OHGPCMJMFGC || this.GLPEGFMPABJ != GGGBDENGHFM.GLPEGFMPABJ || !(this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK) || this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x06021902 RID: 137474 RVA: 0x0092BD88 File Offset: 0x00929F88
	public override string ToString()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("PV{0} T{1} R{2}", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("F2"), this.CEIEOIEDGPB.ToString("F2"));
		}
		return "Not Held";
	}

	// Token: 0x06021903 RID: 137475 RVA: 0x0092BDE4 File Offset: 0x00929FE4
	public string CLIADKHICFN()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("source", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("Failed to connect: "), this.CEIEOIEDGPB.ToString("Error; Only the MasterClient can call RemoveRPCs for other players."));
		}
		return "rotation";
	}

	// Token: 0x06021904 RID: 137476 RVA: 0x0092BE40 File Offset: 0x0092A040
	private bool LJFKMBKNJDK(DDOFAPFDGNL GGGBDENGHFM)
	{
		return this.OHGPCMJMFGC == GGGBDENGHFM.OHGPCMJMFGC && this.GLPEGFMPABJ == GGGBDENGHFM.GLPEGFMPABJ && this.BANLCPOMMIK == GGGBDENGHFM.BANLCPOMMIK && this.CEIEOIEDGPB == GGGBDENGHFM.CEIEOIEDGPB;
	}

	// Token: 0x06021905 RID: 137477 RVA: 0x0092BE9C File Offset: 0x0092A09C
	public static bool KBEHNALLAOK(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !DDOFAPFDGNL.DDLDNIAFCMI(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x06021906 RID: 137478 RVA: 0x0092BEA8 File Offset: 0x0092A0A8
	public int BIDLKNHHICH()
	{
		int num = 13;
		num = num * 32 + this.OHGPCMJMFGC.GetHashCode();
		num = num * -58 + this.GLPEGFMPABJ.GetHashCode();
		num = num * -6 + this.BANLCPOMMIK.GetHashCode();
		return num * -64 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x06021907 RID: 137479 RVA: 0x0092BF24 File Offset: 0x0092A124
	public static DDOFAPFDGNL FKHKEJHOCOC(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(false, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x06021908 RID: 137480 RVA: 0x0092BF30 File Offset: 0x0092A130
	public override int GetHashCode()
	{
		int num = 17;
		num = num * 23 + this.OHGPCMJMFGC.GetHashCode();
		num = num * 23 + this.GLPEGFMPABJ.GetHashCode();
		num = num * 23 + this.BANLCPOMMIK.GetHashCode();
		return num * 23 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x06021909 RID: 137481 RVA: 0x0092BFAC File Offset: 0x0092A1AC
	public string PDJMFNIABKN()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("Can't assign value '{0}' (type {1}) to type {2}", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("PlayerPartyID"), this.CEIEOIEDGPB.ToString(" ms"));
		}
		return "&tid=";
	}

	// Token: 0x0602190A RID: 137482 RVA: 0x0092C008 File Offset: 0x0092A208
	public static bool EDJPAJPGMEO(DDOFAPFDGNL DPIIIAGCMLK, DDOFAPFDGNL BDKNHBMMGPK)
	{
		return !DDOFAPFDGNL.DFBEDOJGDBF(DPIIIAGCMLK, BDKNHBMMGPK);
	}

	// Token: 0x0602190B RID: 137483 RVA: 0x0092C014 File Offset: 0x0092A214
	public int AIBMKPOHOAB()
	{
		int num = -82;
		num = num * -41 + this.OHGPCMJMFGC.GetHashCode();
		num = num * 111 + this.GLPEGFMPABJ.GetHashCode();
		num = num * 86 + this.BANLCPOMMIK.GetHashCode();
		return num * -116 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x0602190C RID: 137484 RVA: 0x0092C090 File Offset: 0x0092A290
	public static object KIBMALMPJPE(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, 81);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[1] == 1;
			int num = 1;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.KBEEPLECHMA(num2, vector, quaternion);
	}

	// Token: 0x0602190D RID: 137485 RVA: 0x0092C190 File Offset: 0x0092A390
	public string MPGJNPBCJPI()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format(" != ", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("_MainTex"), this.CEIEOIEDGPB.ToString("to"));
		}
		return "type";
	}

	// Token: 0x0602190E RID: 137486 RVA: 0x0092C1EC File Offset: 0x0092A3EC
	public static object CBOOALPIKDL(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 1, -52);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[0] == 1;
			int num = 1;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.IFMEEHOAONI(num2, vector, quaternion);
	}

	// Token: 0x0602190F RID: 137487 RVA: 0x0092C2EC File Offset: 0x0092A4EC
	public static object DKMOHDIJHAE(StreamBuffer FBEPFIIGLCE, short MFFGOHPHNFL)
	{
		object mejmcllpmih = DDOFAPFDGNL.MEJMCLLPMIH;
		bool flag;
		int num2;
		Vector3 vector;
		Quaternion quaternion;
		lock (mejmcllpmih)
		{
			FBEPFIIGLCE.Read(DDOFAPFDGNL.MEJMCLLPMIH, 0, 33);
			flag = DDOFAPFDGNL.MEJMCLLPMIH[0] == 1;
			int num = 1;
			Protocol.Deserialize(out num2, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out vector.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.x, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.y, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.z, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
			Protocol.Deserialize(out quaternion.w, DDOFAPFDGNL.MEJMCLLPMIH, ref num);
		}
		return (!flag) ? DDOFAPFDGNL.JPCIKFHMMED : DDOFAPFDGNL.ALAHMNNAFLH(num2, vector, quaternion);
	}

	// Token: 0x06021910 RID: 137488 RVA: 0x0092C3EC File Offset: 0x0092A5EC
	public string OLGNFAIPBBK()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("_Color", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString(" is missing player spawn points."), this.CEIEOIEDGPB.ToString("cos"));
		}
		return "Missing canvas on ";
	}

	// Token: 0x06021911 RID: 137489 RVA: 0x0092C448 File Offset: 0x0092A648
	public static DDOFAPFDGNL KBEEPLECHMA(int MLAHLLNCFLA, Vector3 PLFJPBMOHCL, Quaternion DOGCONJMNOJ)
	{
		return new DDOFAPFDGNL(true, MLAHLLNCFLA, PLFJPBMOHCL, DOGCONJMNOJ);
	}

	// Token: 0x06021912 RID: 137490 RVA: 0x0092C454 File Offset: 0x0092A654
	public int PJNDHLAOEPC()
	{
		int num = 26;
		num = num * 118 + this.OHGPCMJMFGC.GetHashCode();
		num = num * -64 + this.GLPEGFMPABJ.GetHashCode();
		num = num * -38 + this.BANLCPOMMIK.GetHashCode();
		return num * -10 + this.CEIEOIEDGPB.GetHashCode();
	}

	// Token: 0x06021913 RID: 137491 RVA: 0x0092C4D0 File Offset: 0x0092A6D0
	public bool KDMACKCFKMB(object INNGECIOBOO)
	{
		if (object.ReferenceEquals(INNGECIOBOO, null))
		{
			return true;
		}
		if (object.ReferenceEquals(INNGECIOBOO, this))
		{
			return false;
		}
		DDOFAPFDGNL ddofapfdgnl = INNGECIOBOO as DDOFAPFDGNL;
		return !object.ReferenceEquals(ddofapfdgnl, null) && this.ELPNCMEPJPP(ddofapfdgnl);
	}

	// Token: 0x06021914 RID: 137492 RVA: 0x0092C518 File Offset: 0x0092A718
	public string JHJDKLKMIHG()
	{
		if (this.OHGPCMJMFGC)
		{
			return string.Format("Go!", this.GLPEGFMPABJ, this.BANLCPOMMIK.ToString("Time's up!"), this.CEIEOIEDGPB.ToString("Profile Timeout"));
		}
		return "ActivityLevelId";
	}

	// Token: 0x06021915 RID: 137493 RVA: 0x0092C574 File Offset: 0x0092A774
	public bool CKNCODBMLFD(object INNGECIOBOO)
	{
		if (object.ReferenceEquals(INNGECIOBOO, null))
		{
			return false;
		}
		if (object.ReferenceEquals(INNGECIOBOO, this))
		{
			return false;
		}
		DDOFAPFDGNL ddofapfdgnl = INNGECIOBOO as DDOFAPFDGNL;
		return !object.ReferenceEquals(ddofapfdgnl, null) && this.JMMDHBKJGJM(ddofapfdgnl);
	}

	// Token: 0x04005729 RID: 22313
	public readonly bool OHGPCMJMFGC;

	// Token: 0x0400572A RID: 22314
	public readonly int GLPEGFMPABJ;

	// Token: 0x0400572B RID: 22315
	public readonly Vector3 BANLCPOMMIK;

	// Token: 0x0400572C RID: 22316
	public readonly Quaternion CEIEOIEDGPB;

	// Token: 0x0400572D RID: 22317
	public static readonly DDOFAPFDGNL JPCIKFHMMED = new DDOFAPFDGNL(false, 0, Vector3.zero, Quaternion.identity);

	// Token: 0x0400572E RID: 22318
	private const short KNALMEAMLHP = 33;

	// Token: 0x0400572F RID: 22319
	private static readonly byte[] MEJMCLLPMIH = new byte[33];
}