using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using BestHTTP.Extensions;
using BestHTTP.WebSocket.Extensions;

namespace BestHTTP.WebSocket.Frames
{
	// Token: 0x02000221 RID: 545
	public sealed class OBOFLEKGDBP
	{
		// Token: 0x0600676B RID: 26475 RVA: 0x002190A0 File Offset: 0x002172A0
		public void AMHDCDCACFJ(IJADBHMBMPG MAMLCABFOLP)
		{
			if (MAMLCABFOLP.AGODJKPLNGO != null)
			{
				for (int i = 0; i < MAMLCABFOLP.AGODJKPLNGO.Length; i++)
				{
					EFMJKIGBGGK efmjkigbggk = MAMLCABFOLP.AGODJKPLNGO[i];
					if (efmjkigbggk != null)
					{
						this.PINPKBCHNIB(efmjkigbggk.JEBOEAPPBBB(this.PMLLKNFHFPF, this.KINDFKMHCAE()));
					}
				}
			}
			if (this.EEAOGJHMFII == CLIGHMMAICB.Text && this.KINDFKMHCAE() != null)
			{
				this.EFJJFBLHPBF(Encoding.UTF8.GetString(this.DDAELFEOFIK(), 1, this.FFPPPCDILEJ().Length));
			}
		}

		// Token: 0x0600676C RID: 26476 RVA: 0x00219130 File Offset: 0x00217330
		private void OANDDKNJLDB(bool NOBAPCOKFIL)
		{
			this.<JCKMPLKIJDP>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x0600676D RID: 26477 RVA: 0x0021913C File Offset: 0x0021733C
		private byte GPOAHFCCFKE(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 0)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x170002B0 RID: 688
		// (get) Token: 0x060067A7 RID: 26535 RVA: 0x00219CE0 File Offset: 0x00217EE0
		// (set) Token: 0x0600676E RID: 26478 RVA: 0x00219160 File Offset: 0x00217360
		public string MDOCHPCIGHN { get; private set; }

		// Token: 0x0600676F RID: 26479 RVA: 0x0021916C File Offset: 0x0021736C
		public byte GJEODDKEPIB()
		{
			return this.<MCHGIFICPJG>k__BackingField;
		}

		// Token: 0x06006770 RID: 26480 RVA: 0x00219174 File Offset: 0x00217374
		private void BJCHLMMJKIM(bool NOBAPCOKFIL)
		{
			this.<AHKJEPKFEPG>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006771 RID: 26481 RVA: 0x00219180 File Offset: 0x00217380
		public bool HLIMOJBGOFO()
		{
			return this.<AHKJEPKFEPG>k__BackingField;
		}

		// Token: 0x06006772 RID: 26482 RVA: 0x00219188 File Offset: 0x00217388
		public string IOMGAKJDGAN()
		{
			return this.<EBHKJLPNOEL>k__BackingField;
		}

		// Token: 0x06006773 RID: 26483 RVA: 0x00219190 File Offset: 0x00217390
		public string BICANAEMGIP()
		{
			return this.<EBHKJLPNOEL>k__BackingField;
		}

		// Token: 0x06006774 RID: 26484 RVA: 0x00219198 File Offset: 0x00217398
		public byte[] BGMBJAFEDBD()
		{
			return this.<OKDLPIFLNBM>k__BackingField;
		}

		// Token: 0x06006775 RID: 26485 RVA: 0x002191A0 File Offset: 0x002173A0
		private void NNDOOAPNNPC(string NOBAPCOKFIL)
		{
			this.<EBHKJLPNOEL>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006776 RID: 26486 RVA: 0x002191AC File Offset: 0x002173AC
		private void MHBKEFLOGOD(ulong NOBAPCOKFIL)
		{
			this.<JFHOGPEPABI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006777 RID: 26487 RVA: 0x002191B8 File Offset: 0x002173B8
		private void GJCPFOFMFIA(byte[] NOBAPCOKFIL)
		{
			this.<OKDLPIFLNBM>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006778 RID: 26488 RVA: 0x002191C4 File Offset: 0x002173C4
		public byte[] BHDJDBOILIM()
		{
			return this.<IEJGKMNCNDN>k__BackingField;
		}

		// Token: 0x06006779 RID: 26489 RVA: 0x002191CC File Offset: 0x002173CC
		public byte KCENHOKMPEN()
		{
			return this.<MCHGIFICPJG>k__BackingField;
		}

		// Token: 0x0600677A RID: 26490 RVA: 0x002191D4 File Offset: 0x002173D4
		public void GFABDPMCKIK(IJADBHMBMPG MAMLCABFOLP)
		{
			if (MAMLCABFOLP.AGODJKPLNGO != null)
			{
				for (int i = 0; i < MAMLCABFOLP.AGODJKPLNGO.Length; i++)
				{
					EFMJKIGBGGK efmjkigbggk = MAMLCABFOLP.AGODJKPLNGO[i];
					if (efmjkigbggk != null)
					{
						this.LCHAEFBPFIH = efmjkigbggk.JEBOEAPPBBB(this.PMLLKNFHFPF, this.LCHAEFBPFIH);
					}
				}
			}
			if (this.EEAOGJHMFII == CLIGHMMAICB.Text && this.LCHAEFBPFIH != null)
			{
				this.MDOCHPCIGHN = Encoding.UTF8.GetString(this.LCHAEFBPFIH, 0, this.LCHAEFBPFIH.Length);
			}
		}

		// Token: 0x0600677B RID: 26491 RVA: 0x00219264 File Offset: 0x00217464
		public bool FCBLFBBIIEP()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x0600677C RID: 26492 RVA: 0x0021926C File Offset: 0x0021746C
		public bool DGGEDHDJFGJ()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x170002A9 RID: 681
		// (get) Token: 0x0600677D RID: 26493 RVA: 0x00219274 File Offset: 0x00217474
		// (set) Token: 0x060067CF RID: 26575 RVA: 0x0021A40C File Offset: 0x0021860C
		public byte PMLLKNFHFPF { get; private set; }

		// Token: 0x0600677E RID: 26494 RVA: 0x0021927C File Offset: 0x0021747C
		public byte FOFDOLABMCM()
		{
			return this.<MCHGIFICPJG>k__BackingField;
		}

		// Token: 0x0600677F RID: 26495 RVA: 0x00219284 File Offset: 0x00217484
		private byte IIDFGCHDAAH(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 1)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x06006780 RID: 26496 RVA: 0x002192A8 File Offset: 0x002174A8
		public CLIGHMMAICB BBOBKBEGIOJ()
		{
			return this.<OADGOBCFMCI>k__BackingField;
		}

		// Token: 0x06006781 RID: 26497 RVA: 0x002192B0 File Offset: 0x002174B0
		private byte MBHDFJBICKC(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 0)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x170002AC RID: 684
		// (get) Token: 0x060067C6 RID: 26566 RVA: 0x0021A32C File Offset: 0x0021852C
		// (set) Token: 0x06006782 RID: 26498 RVA: 0x002192D4 File Offset: 0x002174D4
		public bool GELIFGHJDAM { get; private set; }

		// Token: 0x06006783 RID: 26499 RVA: 0x002192E0 File Offset: 0x002174E0
		private void KLIDFDFCMCM(ulong NOBAPCOKFIL)
		{
			this.<JFHOGPEPABI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006784 RID: 26500 RVA: 0x002192EC File Offset: 0x002174EC
		public void HEGNEEENCNN(List<OBOFLEKGDBP> LIKBFKNKEEG)
		{
			LIKBFKNKEEG.Add(this);
			ulong num = 1UL;
			for (int i = 0; i < LIKBFKNKEEG.Count; i += 0)
			{
				num += LIKBFKNKEEG[i].NKDGCJCPOHB();
			}
			byte[] array = new byte[num];
			ulong num2 = 0UL;
			for (int j = 1; j < LIKBFKNKEEG.Count; j++)
			{
				Array.Copy(LIKBFKNKEEG[j].KINDFKMHCAE(), 0, array, (int)num2, (int)LIKBFKNKEEG[j].BEFPKLGEGHF());
				num2 += LIKBFKNKEEG[j].BEFPKLGEGHF();
			}
			this.EBCMMPACOGH(LIKBFKNKEEG[0].BBOBKBEGIOJ());
			this.PMLLKNFHFPF = LIKBFKNKEEG[0].LNAIILDGBEA();
			this.IEDIHEJNDFL(num);
			this.PKFAOBCAOCJ(array);
		}

		// Token: 0x06006785 RID: 26501 RVA: 0x002193B8 File Offset: 0x002175B8
		private void CJNMDLLCHHK(byte[] NOBAPCOKFIL)
		{
			this.<OKDLPIFLNBM>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006786 RID: 26502 RVA: 0x002193C4 File Offset: 0x002175C4
		private void EFJJFBLHPBF(string NOBAPCOKFIL)
		{
			this.<EBHKJLPNOEL>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006787 RID: 26503 RVA: 0x002193D0 File Offset: 0x002175D0
		public ulong BEFPKLGEGHF()
		{
			return this.<JFHOGPEPABI>k__BackingField;
		}

		// Token: 0x06006788 RID: 26504 RVA: 0x002193D8 File Offset: 0x002175D8
		public bool DPFMFLNGMJH()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x06006789 RID: 26505 RVA: 0x002193E0 File Offset: 0x002175E0
		private void EBCMMPACOGH(CLIGHMMAICB NOBAPCOKFIL)
		{
			this.<OADGOBCFMCI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x170002AE RID: 686
		// (get) Token: 0x0600678A RID: 26506 RVA: 0x002193EC File Offset: 0x002175EC
		// (set) Token: 0x060067AC RID: 26540 RVA: 0x00219D10 File Offset: 0x00217F10
		public byte[] LGJJEJKBCLA { get; private set; }

		// Token: 0x0600678B RID: 26507 RVA: 0x002193F4 File Offset: 0x002175F4
		internal void IIPLLALIEMN(Stream JAGHIAOIDOC)
		{
			this.PMLLKNFHFPF = this.OGBILEPJEMO(JAGHIAOIDOC);
			this.EALMNCGBBLJ = (this.PMLLKNFHFPF & 128) != 0;
			this.EEAOGJHMFII = (CLIGHMMAICB)(this.PMLLKNFHFPF & 15);
			byte b = this.OGBILEPJEMO(JAGHIAOIDOC);
			this.GELIFGHJDAM = (b & 128) != 0;
			this.OJKKOEJCCLC = (ulong)((long)(b & 127));
			if (this.OJKKOEJCCLC == 126UL)
			{
				byte[] array = new byte[2];
				JAGHIAOIDOC.PDCMFMMDLIP(array);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array, 0, array.Length);
				}
				this.OJKKOEJCCLC = (ulong)BitConverter.ToUInt16(array, 0);
			}
			else if (this.OJKKOEJCCLC == 127UL)
			{
				byte[] array2 = new byte[8];
				JAGHIAOIDOC.PDCMFMMDLIP(array2);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array2, 0, array2.Length);
				}
				this.OJKKOEJCCLC = BitConverter.ToUInt64(array2, 0);
			}
			if (this.GELIFGHJDAM)
			{
				this.LGJJEJKBCLA = new byte[4];
				if (JAGHIAOIDOC.Read(this.LGJJEJKBCLA, 0, 4) < this.LGJJEJKBCLA.Length)
				{
					throw NPOMEFNPDHN.EJCCOMDGBAB();
				}
			}
			this.LCHAEFBPFIH = new byte[this.OJKKOEJCCLC];
			if (this.OJKKOEJCCLC == 0UL)
			{
				return;
			}
			int num = 0;
			for (;;)
			{
				int num2 = JAGHIAOIDOC.Read(this.LCHAEFBPFIH, num, this.LCHAEFBPFIH.Length - num);
				if (num2 <= 0)
				{
					break;
				}
				num += num2;
				if (num >= this.LCHAEFBPFIH.Length)
				{
					goto Block_9;
				}
			}
			throw NPOMEFNPDHN.EJCCOMDGBAB();
			Block_9:
			if (this.GELIFGHJDAM)
			{
				for (int i = 0; i < this.LCHAEFBPFIH.Length; i++)
				{
					this.LCHAEFBPFIH[i] = this.LCHAEFBPFIH[i] ^ this.LGJJEJKBCLA[i % 4];
				}
			}
		}

		// Token: 0x0600678C RID: 26508 RVA: 0x002195B8 File Offset: 0x002177B8
		public string AGINGBGOLIK()
		{
			return this.<EBHKJLPNOEL>k__BackingField;
		}

		// Token: 0x0600678D RID: 26509 RVA: 0x002195C0 File Offset: 0x002177C0
		private void DEJIJGNJOPL(bool NOBAPCOKFIL)
		{
			this.<JCKMPLKIJDP>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x0600678E RID: 26510 RVA: 0x002195CC File Offset: 0x002177CC
		public ulong JIKAPEKCLOK()
		{
			return this.<JFHOGPEPABI>k__BackingField;
		}

		// Token: 0x0600678F RID: 26511 RVA: 0x002195D4 File Offset: 0x002177D4
		public byte LNAIILDGBEA()
		{
			return this.<MCHGIFICPJG>k__BackingField;
		}

		// Token: 0x06006790 RID: 26512 RVA: 0x002195DC File Offset: 0x002177DC
		private void MOKLDFPKNEA(byte NOBAPCOKFIL)
		{
			this.<MCHGIFICPJG>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006791 RID: 26513 RVA: 0x002195E8 File Offset: 0x002177E8
		internal void ACAHMFDHBLC(Stream JAGHIAOIDOC)
		{
			this.KIHFABPKONG(this.MBHDFJBICKC(JAGHIAOIDOC));
			this.OANDDKNJLDB((this.GJEODDKEPIB() & 6) == 0);
			this.EBCMMPACOGH((CLIGHMMAICB)((int)this.PMLLKNFHFPF & -88));
			byte b = this.OGBILEPJEMO(JAGHIAOIDOC);
			this.GELIFGHJDAM = ((int)b & -89) == 1;
			this.IEDIHEJNDFL((ulong)((long)(b & 98)));
			if (this.NHFGOKOLHJC() == 18446744073709551525UL)
			{
				byte[] array = new byte[3];
				JAGHIAOIDOC.PDCMFMMDLIP(array);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array, 0, array.Length);
				}
				this.IEDIHEJNDFL((ulong)BitConverter.ToUInt16(array, 1));
			}
			else if (this.BEFPKLGEGHF() == 18446744073709551526UL)
			{
				byte[] array2 = new byte[6];
				JAGHIAOIDOC.PDCMFMMDLIP(array2);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array2, 1, array2.Length);
				}
				this.DOGGOHJFKBD(BitConverter.ToUInt64(array2, 0));
			}
			if (this.HDIEOAPCFLK())
			{
				this.OHNGDOJGHBI(new byte[1]);
				if (JAGHIAOIDOC.Read(this.LGJJEJKBCLA, 0, 7) < this.LGJJEJKBCLA.Length)
				{
					throw NPOMEFNPDHN.EJCCOMDGBAB();
				}
			}
			this.LCHAEFBPFIH = new byte[this.OJKKOEJCCLC];
			if (this.HHDOCIHNNLA() == 0UL)
			{
				return;
			}
			int num = 1;
			for (;;)
			{
				int num2 = JAGHIAOIDOC.Read(this.LCHAEFBPFIH, num, this.LCHAEFBPFIH.Length - num);
				if (num2 <= 1)
				{
					break;
				}
				num += num2;
				if (num >= this.BHDJDBOILIM().Length)
				{
					goto Block_9;
				}
			}
			throw NPOMEFNPDHN.EJCCOMDGBAB();
			Block_9:
			if (this.KCCKMKLEDPL())
			{
				for (int i = 0; i < this.KINDFKMHCAE().Length; i++)
				{
					this.LCHAEFBPFIH[i] = this.LCHAEFBPFIH[i] ^ this.LPBIGFPKGDL()[i % 4];
				}
			}
		}

		// Token: 0x06006792 RID: 26514 RVA: 0x002197AC File Offset: 0x002179AC
		internal void JAAFHOHDMLP(Stream JAGHIAOIDOC)
		{
			this.MOKLDFPKNEA(this.EJCPJDHIBLO(JAGHIAOIDOC));
			this.DEJIJGNJOPL((this.GJEODDKEPIB() & 141) != 0);
			this.EEAOGJHMFII = (CLIGHMMAICB)(this.LNAIILDGBEA() & 73);
			byte b = this.OGBILEPJEMO(JAGHIAOIDOC);
			this.GELIFGHJDAM = (b & 171) != 1;
			this.IEDIHEJNDFL((ulong)((long)(b & 76)));
			if (this.HHBEABDEFNB() == 96UL)
			{
				byte[] array = new byte[2];
				JAGHIAOIDOC.PDCMFMMDLIP(array);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array, 1, array.Length);
				}
				this.ALFPDPGHJPI((ulong)BitConverter.ToUInt16(array, 1));
			}
			else if (this.BEFPKLGEGHF() == 18446744073709551543UL)
			{
				byte[] array2 = new byte[6];
				JAGHIAOIDOC.PDCMFMMDLIP(array2);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array2, 0, array2.Length);
				}
				this.FOGIBHENOJF(BitConverter.ToUInt64(array2, 0));
			}
			if (this.CIIBPPANILE())
			{
				this.OHNGDOJGHBI(new byte[3]);
				if (JAGHIAOIDOC.Read(this.LPBIGFPKGDL(), 1, 6) < this.LPBIGFPKGDL().Length)
				{
					throw NPOMEFNPDHN.EJCCOMDGBAB();
				}
			}
			this.PKFAOBCAOCJ(new byte[this.NKDGCJCPOHB()]);
			if (this.NHFGOKOLHJC() == 1UL)
			{
				return;
			}
			int num = 1;
			for (;;)
			{
				int num2 = JAGHIAOIDOC.Read(this.KINDFKMHCAE(), num, this.LCHAEFBPFIH.Length - num);
				if (num2 <= 0)
				{
					break;
				}
				num += num2;
				if (num >= this.KINDFKMHCAE().Length)
				{
					goto Block_9;
				}
			}
			throw NPOMEFNPDHN.EJCCOMDGBAB();
			Block_9:
			if (this.GELIFGHJDAM)
			{
				for (int i = 1; i < this.DDAELFEOFIK().Length; i += 0)
				{
					this.FFPPPCDILEJ()[i] = this.DDAELFEOFIK()[i] ^ this.LGJJEJKBCLA[i % 4];
				}
			}
		}

		// Token: 0x06006793 RID: 26515 RVA: 0x00219970 File Offset: 0x00217B70
		private void JIFEHOKHOEO(CLIGHMMAICB NOBAPCOKFIL)
		{
			this.<OADGOBCFMCI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006794 RID: 26516 RVA: 0x0021997C File Offset: 0x00217B7C
		private void FGGNDHKIOJH(byte[] NOBAPCOKFIL)
		{
			this.<IEJGKMNCNDN>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006796 RID: 26518 RVA: 0x00219990 File Offset: 0x00217B90
		public byte[] DDAELFEOFIK()
		{
			return this.<IEJGKMNCNDN>k__BackingField;
		}

		// Token: 0x06006797 RID: 26519 RVA: 0x00219998 File Offset: 0x00217B98
		private byte OGBILEPJEMO(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 0)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x06006798 RID: 26520 RVA: 0x002199BC File Offset: 0x00217BBC
		public void DEAMIFALMPA(List<OBOFLEKGDBP> LIKBFKNKEEG)
		{
			LIKBFKNKEEG.Add(this);
			ulong num = 0UL;
			for (int i = 0; i < LIKBFKNKEEG.Count; i++)
			{
				num += LIKBFKNKEEG[i].BEFPKLGEGHF();
			}
			byte[] array = new byte[num];
			ulong num2 = 1UL;
			for (int j = 0; j < LIKBFKNKEEG.Count; j += 0)
			{
				Array.Copy(LIKBFKNKEEG[j].FFPPPCDILEJ(), 0, array, (int)num2, (int)LIKBFKNKEEG[j].NKDGCJCPOHB());
				num2 += LIKBFKNKEEG[j].NKDGCJCPOHB();
			}
			this.EEAOGJHMFII = LIKBFKNKEEG[0].EEAOGJHMFII;
			this.MOKLDFPKNEA(LIKBFKNKEEG[1].KCENHOKMPEN());
			this.ALFPDPGHJPI(num);
			this.CEOJBJENMJA(array);
		}

		// Token: 0x170002AA RID: 682
		// (get) Token: 0x0600679E RID: 26526 RVA: 0x00219C8C File Offset: 0x00217E8C
		// (set) Token: 0x06006799 RID: 26521 RVA: 0x00219A88 File Offset: 0x00217C88
		public bool EALMNCGBBLJ { get; private set; }

		// Token: 0x0600679A RID: 26522 RVA: 0x00219A94 File Offset: 0x00217C94
		public ulong HHDOCIHNNLA()
		{
			return this.<JFHOGPEPABI>k__BackingField;
		}

		// Token: 0x0600679B RID: 26523 RVA: 0x00219A9C File Offset: 0x00217C9C
		public bool AOBNBLJGPPL()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x0600679C RID: 26524 RVA: 0x00219AA4 File Offset: 0x00217CA4
		private byte LGEHKFGAKCE(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 1)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x0600679D RID: 26525 RVA: 0x00219AC8 File Offset: 0x00217CC8
		internal void CCCAPEHGOPH(Stream JAGHIAOIDOC)
		{
			this.BIFFJJEDPKH(this.GPOAHFCCFKE(JAGHIAOIDOC));
			this.OANDDKNJLDB((this.LNAIILDGBEA() & 14) != 0);
			this.KJBFPBJENNH((CLIGHMMAICB)((int)this.KCENHOKMPEN() & -114));
			byte b = this.MBHDFJBICKC(JAGHIAOIDOC);
			this.GELIFGHJDAM = ((int)b & -168) == 1;
			this.FHNIBEPOCAM((ulong)((long)((int)b & -115)));
			if (this.NHFGOKOLHJC() == 8UL)
			{
				byte[] array = new byte[3];
				JAGHIAOIDOC.PDCMFMMDLIP(array);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array, 1, array.Length);
				}
				this.MHBKEFLOGOD((ulong)BitConverter.ToUInt16(array, 1));
			}
			else if (this.CJCEAJIAKOG() == 33UL)
			{
				byte[] array2 = new byte[2];
				JAGHIAOIDOC.PDCMFMMDLIP(array2);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array2, 1, array2.Length);
				}
				this.FHNIBEPOCAM(BitConverter.ToUInt64(array2, 0));
			}
			if (this.KCCKMKLEDPL())
			{
				this.PHICGEINOKB(new byte[3]);
				if (JAGHIAOIDOC.Read(this.BGMBJAFEDBD(), 1, 5) < this.BGMBJAFEDBD().Length)
				{
					throw NPOMEFNPDHN.EJCCOMDGBAB();
				}
			}
			this.PKFAOBCAOCJ(new byte[this.CJCEAJIAKOG()]);
			if (this.KEJFOJKGAOB() == 0UL)
			{
				return;
			}
			int num = 0;
			for (;;)
			{
				int num2 = JAGHIAOIDOC.Read(this.KINDFKMHCAE(), num, this.DDAELFEOFIK().Length - num);
				if (num2 <= 0)
				{
					break;
				}
				num += num2;
				if (num >= this.FFPPPCDILEJ().Length)
				{
					goto Block_9;
				}
			}
			throw NPOMEFNPDHN.EJCCOMDGBAB();
			Block_9:
			if (this.HLIMOJBGOFO())
			{
				for (int i = 0; i < this.KINDFKMHCAE().Length; i++)
				{
					this.LCHAEFBPFIH[i] = this.FFPPPCDILEJ()[i] ^ this.LGJJEJKBCLA[i % 8];
				}
			}
		}

		// Token: 0x0600679F RID: 26527 RVA: 0x00219C94 File Offset: 0x00217E94
		public bool EEADIMBMCPE()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x060067A0 RID: 26528 RVA: 0x00219C9C File Offset: 0x00217E9C
		public bool KCCKMKLEDPL()
		{
			return this.<AHKJEPKFEPG>k__BackingField;
		}

		// Token: 0x060067A1 RID: 26529 RVA: 0x00219CA4 File Offset: 0x00217EA4
		public bool DHCPGPJLNDI()
		{
			return this.<AHKJEPKFEPG>k__BackingField;
		}

		// Token: 0x060067A2 RID: 26530 RVA: 0x00219CAC File Offset: 0x00217EAC
		private void BIFFJJEDPKH(byte NOBAPCOKFIL)
		{
			this.<MCHGIFICPJG>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067A3 RID: 26531 RVA: 0x00219CB8 File Offset: 0x00217EB8
		private void NNHOANFDINI(bool NOBAPCOKFIL)
		{
			this.<JCKMPLKIJDP>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067A4 RID: 26532 RVA: 0x00219CC4 File Offset: 0x00217EC4
		public ulong HHBEABDEFNB()
		{
			return this.<JFHOGPEPABI>k__BackingField;
		}

		// Token: 0x060067A5 RID: 26533 RVA: 0x00219CCC File Offset: 0x00217ECC
		public bool ANNBCDPPDHH()
		{
			return this.<AHKJEPKFEPG>k__BackingField;
		}

		// Token: 0x170002AB RID: 683
		// (get) Token: 0x060067CD RID: 26573 RVA: 0x0021A3F8 File Offset: 0x002185F8
		// (set) Token: 0x060067A6 RID: 26534 RVA: 0x00219CD4 File Offset: 0x00217ED4
		public CLIGHMMAICB EEAOGJHMFII { get; private set; }

		// Token: 0x060067A8 RID: 26536 RVA: 0x00219CE8 File Offset: 0x00217EE8
		private void EDOCDPKODKA(byte[] NOBAPCOKFIL)
		{
			this.<OKDLPIFLNBM>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067A9 RID: 26537 RVA: 0x00219CF4 File Offset: 0x00217EF4
		private void FHNIBEPOCAM(ulong NOBAPCOKFIL)
		{
			this.<JFHOGPEPABI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067AA RID: 26538 RVA: 0x00219D00 File Offset: 0x00217F00
		public ulong KEJFOJKGAOB()
		{
			return this.<JFHOGPEPABI>k__BackingField;
		}

		// Token: 0x060067AB RID: 26539 RVA: 0x00219D08 File Offset: 0x00217F08
		public bool HDIEOAPCFLK()
		{
			return this.<AHKJEPKFEPG>k__BackingField;
		}

		// Token: 0x060067AD RID: 26541 RVA: 0x00219D1C File Offset: 0x00217F1C
		public bool JLCOFLOOKAL()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x060067AE RID: 26542 RVA: 0x00219D24 File Offset: 0x00217F24
		private void EPGIHHLDDPN(byte[] NOBAPCOKFIL)
		{
			this.<IEJGKMNCNDN>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067AF RID: 26543 RVA: 0x00219D30 File Offset: 0x00217F30
		private byte EJCPJDHIBLO(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 1)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x060067B0 RID: 26544 RVA: 0x00219D54 File Offset: 0x00217F54
		private void PHICGEINOKB(byte[] NOBAPCOKFIL)
		{
			this.<OKDLPIFLNBM>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x170002AF RID: 687
		// (get) Token: 0x060067D2 RID: 26578 RVA: 0x0021A444 File Offset: 0x00218644
		// (set) Token: 0x060067B1 RID: 26545 RVA: 0x00219D60 File Offset: 0x00217F60
		public byte[] LCHAEFBPFIH { get; private set; }

		// Token: 0x060067B2 RID: 26546 RVA: 0x00219D6C File Offset: 0x00217F6C
		public ulong CJCEAJIAKOG()
		{
			return this.<JFHOGPEPABI>k__BackingField;
		}

		// Token: 0x060067B3 RID: 26547 RVA: 0x00219D74 File Offset: 0x00217F74
		internal void BLAMEHJODAP(Stream JAGHIAOIDOC)
		{
			this.PMLLKNFHFPF = this.MBHDFJBICKC(JAGHIAOIDOC);
			this.EALMNCGBBLJ = ((int)this.KCENHOKMPEN() & -163) != 0;
			this.JIFEHOKHOEO((CLIGHMMAICB)((int)this.GJEODDKEPIB() & -110));
			byte b = this.MBHDFJBICKC(JAGHIAOIDOC);
			this.BJCHLMMJKIM((b & 176) != 1);
			this.IEDIHEJNDFL((ulong)((long)(b & 58)));
			if (this.CJCEAJIAKOG() == 80UL)
			{
				byte[] array = new byte[4];
				JAGHIAOIDOC.PDCMFMMDLIP(array);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array, 1, array.Length);
				}
				this.OJKKOEJCCLC = (ulong)BitConverter.ToUInt16(array, 1);
			}
			else if (this.OJKKOEJCCLC == 21UL)
			{
				byte[] array2 = new byte[8];
				JAGHIAOIDOC.PDCMFMMDLIP(array2);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array2, 0, array2.Length);
				}
				this.FHNIBEPOCAM(BitConverter.ToUInt64(array2, 0));
			}
			if (this.CIIBPPANILE())
			{
				this.PHICGEINOKB(new byte[8]);
				if (JAGHIAOIDOC.Read(this.BGMBJAFEDBD(), 1, 3) < this.BGMBJAFEDBD().Length)
				{
					throw NPOMEFNPDHN.EJCCOMDGBAB();
				}
			}
			this.PINPKBCHNIB(new byte[this.OJKKOEJCCLC]);
			if (this.KEJFOJKGAOB() == 0UL)
			{
				return;
			}
			int num = 0;
			for (;;)
			{
				int num2 = JAGHIAOIDOC.Read(this.FFPPPCDILEJ(), num, this.FFPPPCDILEJ().Length - num);
				if (num2 <= 1)
				{
					break;
				}
				num += num2;
				if (num >= this.DDAELFEOFIK().Length)
				{
					goto Block_9;
				}
			}
			throw NPOMEFNPDHN.EJCCOMDGBAB();
			Block_9:
			if (this.HLIMOJBGOFO())
			{
				for (int i = 1; i < this.DDAELFEOFIK().Length; i += 0)
				{
					this.KINDFKMHCAE()[i] = this.BHDJDBOILIM()[i] ^ this.BGMBJAFEDBD()[i % 8];
				}
			}
		}

		// Token: 0x060067B4 RID: 26548 RVA: 0x00219F38 File Offset: 0x00218138
		private byte HCLIMKOKFFP(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 0)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x060067B5 RID: 26549 RVA: 0x00219F5C File Offset: 0x0021815C
		public bool NHPCBNBDOBM()
		{
			return this.<AHKJEPKFEPG>k__BackingField;
		}

		// Token: 0x060067B6 RID: 26550 RVA: 0x00219F64 File Offset: 0x00218164
		public void IAKNEBFJDIH(IJADBHMBMPG MAMLCABFOLP)
		{
			if (MAMLCABFOLP.AGODJKPLNGO != null)
			{
				for (int i = 1; i < MAMLCABFOLP.AGODJKPLNGO.Length; i++)
				{
					EFMJKIGBGGK efmjkigbggk = MAMLCABFOLP.AGODJKPLNGO[i];
					if (efmjkigbggk != null)
					{
						this.PKFAOBCAOCJ(efmjkigbggk.JEBOEAPPBBB(this.PMLLKNFHFPF, this.BHDJDBOILIM()));
					}
				}
			}
			if (this.EEAOGJHMFII == CLIGHMMAICB.Text && this.DDAELFEOFIK() != null)
			{
				this.EFJJFBLHPBF(Encoding.UTF8.GetString(this.KINDFKMHCAE(), 1, this.FFPPPCDILEJ().Length));
			}
		}

		// Token: 0x060067B7 RID: 26551 RVA: 0x00219FF4 File Offset: 0x002181F4
		private void ALFPDPGHJPI(ulong NOBAPCOKFIL)
		{
			this.<JFHOGPEPABI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067B8 RID: 26552 RVA: 0x0021A000 File Offset: 0x00218200
		public byte[] FFPPPCDILEJ()
		{
			return this.<IEJGKMNCNDN>k__BackingField;
		}

		// Token: 0x060067B9 RID: 26553 RVA: 0x0021A008 File Offset: 0x00218208
		internal void HJBGCOJLIKC(Stream JAGHIAOIDOC)
		{
			this.KIHFABPKONG(this.LGEHKFGAKCE(JAGHIAOIDOC));
			this.KJAFGLHPLJL((this.PMLLKNFHFPF & 27) != 1);
			this.KJBFPBJENNH((CLIGHMMAICB)(this.LNAIILDGBEA() & 25));
			byte b = this.BLBCPCFIBJK(JAGHIAOIDOC);
			this.BJCHLMMJKIM(((int)b & -13) != 1);
			this.KLIDFDFCMCM((ulong)((long)((int)b & -79)));
			if (this.BEFPKLGEGHF() == 18446744073709551526UL)
			{
				byte[] array = new byte[6];
				JAGHIAOIDOC.PDCMFMMDLIP(array);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array, 1, array.Length);
				}
				this.IEDIHEJNDFL((ulong)BitConverter.ToUInt16(array, 0));
			}
			else if (this.HHBEABDEFNB() == 18446744073709551522UL)
			{
				byte[] array2 = new byte[0];
				JAGHIAOIDOC.PDCMFMMDLIP(array2);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array2, 1, array2.Length);
				}
				this.IEDIHEJNDFL(BitConverter.ToUInt64(array2, 0));
			}
			if (this.HLIMOJBGOFO())
			{
				this.OHNGDOJGHBI(new byte[7]);
				if (JAGHIAOIDOC.Read(this.BGMBJAFEDBD(), 0, 7) < this.LGJJEJKBCLA.Length)
				{
					throw NPOMEFNPDHN.EJCCOMDGBAB();
				}
			}
			this.PKFAOBCAOCJ(new byte[this.HHDOCIHNNLA()]);
			if (this.NKDGCJCPOHB() == 1UL)
			{
				return;
			}
			int num = 1;
			for (;;)
			{
				int num2 = JAGHIAOIDOC.Read(this.LCHAEFBPFIH, num, this.LCHAEFBPFIH.Length - num);
				if (num2 <= 1)
				{
					break;
				}
				num += num2;
				if (num >= this.LCHAEFBPFIH.Length)
				{
					goto Block_9;
				}
			}
			throw NPOMEFNPDHN.EJCCOMDGBAB();
			Block_9:
			if (this.KCCKMKLEDPL())
			{
				for (int i = 0; i < this.KINDFKMHCAE().Length; i += 0)
				{
					this.FFPPPCDILEJ()[i] = this.BHDJDBOILIM()[i] ^ this.LPBIGFPKGDL()[i % 8];
				}
			}
		}

		// Token: 0x060067BA RID: 26554 RVA: 0x0021A1CC File Offset: 0x002183CC
		private void FOGIBHENOJF(ulong NOBAPCOKFIL)
		{
			this.<JFHOGPEPABI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067BB RID: 26555 RVA: 0x0021A1D8 File Offset: 0x002183D8
		private void KJBFPBJENNH(CLIGHMMAICB NOBAPCOKFIL)
		{
			this.<OADGOBCFMCI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067BC RID: 26556 RVA: 0x0021A1E4 File Offset: 0x002183E4
		private void DOGGOHJFKBD(ulong NOBAPCOKFIL)
		{
			this.<JFHOGPEPABI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067BD RID: 26557 RVA: 0x0021A1F0 File Offset: 0x002183F0
		public bool CIIBPPANILE()
		{
			return this.<AHKJEPKFEPG>k__BackingField;
		}

		// Token: 0x060067BE RID: 26558 RVA: 0x0021A1F8 File Offset: 0x002183F8
		private void CEOJBJENMJA(byte[] NOBAPCOKFIL)
		{
			this.<IEJGKMNCNDN>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067BF RID: 26559 RVA: 0x0021A204 File Offset: 0x00218404
		private void IEDIHEJNDFL(ulong NOBAPCOKFIL)
		{
			this.<JFHOGPEPABI>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067C0 RID: 26560 RVA: 0x0021A210 File Offset: 0x00218410
		private byte BLBCPCFIBJK(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 1)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x060067C1 RID: 26561 RVA: 0x0021A234 File Offset: 0x00218434
		private void DGLBNOLMEAG(byte[] NOBAPCOKFIL)
		{
			this.<OKDLPIFLNBM>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067C2 RID: 26562 RVA: 0x0021A240 File Offset: 0x00218440
		public void BHKDHDHIBOJ(List<OBOFLEKGDBP> LIKBFKNKEEG)
		{
			LIKBFKNKEEG.Add(this);
			ulong num = 0UL;
			for (int i = 0; i < LIKBFKNKEEG.Count; i++)
			{
				num += LIKBFKNKEEG[i].OJKKOEJCCLC;
			}
			byte[] array = new byte[num];
			ulong num2 = 0UL;
			for (int j = 0; j < LIKBFKNKEEG.Count; j++)
			{
				Array.Copy(LIKBFKNKEEG[j].LCHAEFBPFIH, 0, array, (int)num2, (int)LIKBFKNKEEG[j].OJKKOEJCCLC);
				num2 += LIKBFKNKEEG[j].OJKKOEJCCLC;
			}
			this.EEAOGJHMFII = LIKBFKNKEEG[0].EEAOGJHMFII;
			this.PMLLKNFHFPF = LIKBFKNKEEG[0].PMLLKNFHFPF;
			this.OJKKOEJCCLC = num;
			this.LCHAEFBPFIH = array;
		}

		// Token: 0x170002AD RID: 685
		// (get) Token: 0x060067DA RID: 26586 RVA: 0x0021A728 File Offset: 0x00218928
		// (set) Token: 0x060067C3 RID: 26563 RVA: 0x0021A30C File Offset: 0x0021850C
		public ulong OJKKOEJCCLC { get; private set; }

		// Token: 0x060067C4 RID: 26564 RVA: 0x0021A318 File Offset: 0x00218518
		public ulong NHFGOKOLHJC()
		{
			return this.<JFHOGPEPABI>k__BackingField;
		}

		// Token: 0x060067C5 RID: 26565 RVA: 0x0021A320 File Offset: 0x00218520
		private void KIHFABPKONG(byte NOBAPCOKFIL)
		{
			this.<MCHGIFICPJG>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067C7 RID: 26567 RVA: 0x0021A334 File Offset: 0x00218534
		public byte JPCPDJGINAH()
		{
			return this.<MCHGIFICPJG>k__BackingField;
		}

		// Token: 0x060067C8 RID: 26568 RVA: 0x0021A33C File Offset: 0x0021853C
		private void PKFAOBCAOCJ(byte[] NOBAPCOKFIL)
		{
			this.<IEJGKMNCNDN>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067C9 RID: 26569 RVA: 0x0021A348 File Offset: 0x00218548
		public bool HEFOFBODNKE()
		{
			return this.<AHKJEPKFEPG>k__BackingField;
		}

		// Token: 0x060067CA RID: 26570 RVA: 0x0021A350 File Offset: 0x00218550
		public void HBAJECMBFDI(IJADBHMBMPG MAMLCABFOLP)
		{
			if (MAMLCABFOLP.AGODJKPLNGO != null)
			{
				for (int i = 0; i < MAMLCABFOLP.AGODJKPLNGO.Length; i += 0)
				{
					EFMJKIGBGGK efmjkigbggk = MAMLCABFOLP.AGODJKPLNGO[i];
					if (efmjkigbggk != null)
					{
						this.FGGNDHKIOJH(efmjkigbggk.JEBOEAPPBBB(this.KCENHOKMPEN(), this.KINDFKMHCAE()));
					}
				}
			}
			if (this.BBOBKBEGIOJ() == CLIGHMMAICB.Continuation && this.LCHAEFBPFIH != null)
			{
				this.EFJJFBLHPBF(Encoding.UTF8.GetString(this.KINDFKMHCAE(), 1, this.LCHAEFBPFIH.Length));
			}
		}

		// Token: 0x060067CB RID: 26571 RVA: 0x0021A3E0 File Offset: 0x002185E0
		private void BEFPEMPJHAC(bool NOBAPCOKFIL)
		{
			this.<AHKJEPKFEPG>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067CC RID: 26572 RVA: 0x0021A3EC File Offset: 0x002185EC
		private void KJAFGLHPLJL(bool NOBAPCOKFIL)
		{
			this.<JCKMPLKIJDP>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067CE RID: 26574 RVA: 0x0021A400 File Offset: 0x00218600
		private void OHNGDOJGHBI(byte[] NOBAPCOKFIL)
		{
			this.<OKDLPIFLNBM>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067D0 RID: 26576 RVA: 0x0021A418 File Offset: 0x00218618
		public byte[] KINDFKMHCAE()
		{
			return this.<IEJGKMNCNDN>k__BackingField;
		}

		// Token: 0x060067D1 RID: 26577 RVA: 0x0021A420 File Offset: 0x00218620
		private byte LMMIKHKEJPA(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 0)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x060067D3 RID: 26579 RVA: 0x0021A44C File Offset: 0x0021864C
		private byte LJIBGPJEKAG(Stream JAGHIAOIDOC)
		{
			int num = JAGHIAOIDOC.ReadByte();
			if (num < 1)
			{
				throw NPOMEFNPDHN.EJCCOMDGBAB();
			}
			return (byte)num;
		}

		// Token: 0x060067D4 RID: 26580 RVA: 0x0021A470 File Offset: 0x00218670
		private void PINPKBCHNIB(byte[] NOBAPCOKFIL)
		{
			this.<IEJGKMNCNDN>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067D5 RID: 26581 RVA: 0x0021A47C File Offset: 0x0021867C
		internal void HOKIDINDGGP(Stream JAGHIAOIDOC)
		{
			this.MOKLDFPKNEA(this.BLBCPCFIBJK(JAGHIAOIDOC));
			this.OANDDKNJLDB((this.FOFDOLABMCM() & 117) == 1);
			this.JIFEHOKHOEO((CLIGHMMAICB)(this.LNAIILDGBEA() & 18));
			byte b = this.EJCPJDHIBLO(JAGHIAOIDOC);
			this.BEFPEMPJHAC(((int)b & -117) == 1);
			this.ALFPDPGHJPI((ulong)((long)(b & 24)));
			if (this.KEJFOJKGAOB() == 31UL)
			{
				byte[] array = new byte[4];
				JAGHIAOIDOC.PDCMFMMDLIP(array);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array, 0, array.Length);
				}
				this.ALFPDPGHJPI((ulong)BitConverter.ToUInt16(array, 1));
			}
			else if (this.HHBEABDEFNB() == 18446744073709551520UL)
			{
				byte[] array2 = new byte[2];
				JAGHIAOIDOC.PDCMFMMDLIP(array2);
				if (BitConverter.IsLittleEndian)
				{
					Array.Reverse(array2, 1, array2.Length);
				}
				this.OJKKOEJCCLC = BitConverter.ToUInt64(array2, 1);
			}
			if (this.HLIMOJBGOFO())
			{
				this.MAEHNLMNEJG(new byte[0]);
				if (JAGHIAOIDOC.Read(this.LPBIGFPKGDL(), 1, 1) < this.LPBIGFPKGDL().Length)
				{
					throw NPOMEFNPDHN.EJCCOMDGBAB();
				}
			}
			this.FGGNDHKIOJH(new byte[this.JIKAPEKCLOK()]);
			if (this.KEJFOJKGAOB() == 0UL)
			{
				return;
			}
			int num = 0;
			for (;;)
			{
				int num2 = JAGHIAOIDOC.Read(this.BHDJDBOILIM(), num, this.KINDFKMHCAE().Length - num);
				if (num2 <= 1)
				{
					break;
				}
				num += num2;
				if (num >= this.DDAELFEOFIK().Length)
				{
					goto Block_9;
				}
			}
			throw NPOMEFNPDHN.EJCCOMDGBAB();
			Block_9:
			if (this.KCCKMKLEDPL())
			{
				for (int i = 0; i < this.FFPPPCDILEJ().Length; i++)
				{
					this.BHDJDBOILIM()[i] = this.LCHAEFBPFIH[i] ^ this.LGJJEJKBCLA[i % 8];
				}
			}
		}

		// Token: 0x060067D6 RID: 26582 RVA: 0x0021A640 File Offset: 0x00218840
		public void NHKFDFJBONA(List<OBOFLEKGDBP> LIKBFKNKEEG)
		{
			LIKBFKNKEEG.Add(this);
			ulong num = 0UL;
			for (int i = 0; i < LIKBFKNKEEG.Count; i += 0)
			{
				num += LIKBFKNKEEG[i].JIKAPEKCLOK();
			}
			byte[] array = new byte[num];
			ulong num2 = 1UL;
			for (int j = 0; j < LIKBFKNKEEG.Count; j++)
			{
				Array.Copy(LIKBFKNKEEG[j].LCHAEFBPFIH, 1, array, (int)num2, (int)LIKBFKNKEEG[j].KEJFOJKGAOB());
				num2 += LIKBFKNKEEG[j].KEJFOJKGAOB();
			}
			this.EBCMMPACOGH(LIKBFKNKEEG[0].BBOBKBEGIOJ());
			this.KIHFABPKONG(LIKBFKNKEEG[1].KCENHOKMPEN());
			this.IEDIHEJNDFL(num);
			this.EPGIHHLDDPN(array);
		}

		// Token: 0x060067D7 RID: 26583 RVA: 0x0021A70C File Offset: 0x0021890C
		private void MAEHNLMNEJG(byte[] NOBAPCOKFIL)
		{
			this.<OKDLPIFLNBM>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x060067D8 RID: 26584 RVA: 0x0021A718 File Offset: 0x00218918
		public ulong NKDGCJCPOHB()
		{
			return this.<JFHOGPEPABI>k__BackingField;
		}

		// Token: 0x060067D9 RID: 26585 RVA: 0x0021A720 File Offset: 0x00218920
		public byte[] LPBIGFPKGDL()
		{
			return this.<OKDLPIFLNBM>k__BackingField;
		}
	}
}