using System;
using System.IO;

namespace BestHTTP.Decompression.Zlib
{
	// Token: 0x020001CE RID: 462
	internal class ONOAPGBMNOC : Stream
	{
		// Token: 0x06005BBF RID: 23487 RVA: 0x001C8798 File Offset: 0x001C6998
		public JOKHMHLCOEO GKBPENMKJPN()
		{
			return this.DBFLFNFMFIH.ALPGBDOIGMH;
		}

		// Token: 0x06005BC0 RID: 23488 RVA: 0x001C87A8 File Offset: 0x001C69A8
		public virtual long EPBHDEOLPKP()
		{
			if (this.DBFLFNFMFIH.HIGHLCOJBFD == NIFAPEOJGMA.CBLIBPFLGPK.Writer)
			{
				return this.DBFLFNFMFIH.LOABHNKMLHO.HIJPFAIOBNP;
			}
			if (this.DBFLFNFMFIH.HIGHLCOJBFD == NIFAPEOJGMA.CBLIBPFLGPK.Writer)
			{
				return this.DBFLFNFMFIH.LOABHNKMLHO.CIPIMHCHODI;
			}
			return 1L;
		}

		// Token: 0x06005BC1 RID: 23489 RVA: 0x001C87FC File Offset: 0x001C69FC
		public virtual long LKMFDBNDPAK()
		{
			if (this.DBFLFNFMFIH.HIGHLCOJBFD == NIFAPEOJGMA.CBLIBPFLGPK.Writer)
			{
				return this.DBFLFNFMFIH.LOABHNKMLHO.HIJPFAIOBNP;
			}
			if (this.DBFLFNFMFIH.HIGHLCOJBFD == NIFAPEOJGMA.CBLIBPFLGPK.Writer)
			{
				return this.DBFLFNFMFIH.LOABHNKMLHO.CIPIMHCHODI;
			}
			return 1L;
		}

		// Token: 0x06005BC2 RID: 23490 RVA: 0x001C8850 File Offset: 0x001C6A50
		public ONOAPGBMNOC(Stream JAGHIAOIDOC, JDICOHEACCI AOFANJEIKLO, bool KEKLNOJHHML)
			: this(JAGHIAOIDOC, AOFANJEIKLO, LIGALFADMHC.Default, KEKLNOJHHML)
		{
		}

		// Token: 0x06005BC3 RID: 23491 RVA: 0x001C885C File Offset: 0x001C6A5C
		public static byte[] AGNEHMJAMHB(byte[] GNNBOMAEBGK)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress, LIGALFADMHC.BestCompression);
				NIFAPEOJGMA.AGNEHMJAMHB(GNNBOMAEBGK, stream);
				array = memoryStream.ToArray();
			}
			return array;
		}

		// Token: 0x06005BC4 RID: 23492 RVA: 0x001C88AC File Offset: 0x001C6AAC
		public virtual void MKCMMJBHMAM(long NOBAPCOKFIL)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005BC5 RID: 23493 RVA: 0x001C88B4 File Offset: 0x001C6AB4
		public virtual void PDHBHHDFDBL(long NOBAPCOKFIL)
		{
			this.DBFLFNFMFIH.SetLength(NOBAPCOKFIL);
		}

		// Token: 0x06005BC6 RID: 23494 RVA: 0x001C88C4 File Offset: 0x001C6AC4
		public void JAGKDGJNJEB(int NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("Oculus.Platform.CallbackRunner");
			}
			if (this.DBFLFNFMFIH.LLDDIGGKEKM != null)
			{
				throw new KOJICFCHIEG("team");
			}
			if (NOBAPCOKFIL < -193)
			{
				throw new KOJICFCHIEG(string.Format("Play", NOBAPCOKFIL, 93));
			}
			this.DBFLFNFMFIH.OCDAFILHNAH = NOBAPCOKFIL;
		}

		// Token: 0x170001E4 RID: 484
		// (get) Token: 0x06005C11 RID: 23569 RVA: 0x001C9580 File Offset: 0x001C7780
		// (set) Token: 0x06005BC7 RID: 23495 RVA: 0x001C893C File Offset: 0x001C6B3C
		public JOKHMHLCOEO ALPGBDOIGMH
		{
			get
			{
				return this.DBFLFNFMFIH.ALPGBDOIGMH;
			}
			set
			{
				if (this.DGNFEACJJHN)
				{
					throw new ObjectDisposedException("DeflateStream");
				}
				this.DBFLFNFMFIH.ALPGBDOIGMH = value;
			}
		}

		// Token: 0x06005BC8 RID: 23496 RVA: 0x001C8960 File Offset: 0x001C6B60
		public virtual void GFLGHDJCIHO(long NOBAPCOKFIL)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005BC9 RID: 23497 RVA: 0x001C8968 File Offset: 0x001C6B68
		public virtual BLDHMCOMMIC HHMGFBCPGJP()
		{
			return this.DBFLFNFMFIH.KKMKMBPCLIK;
		}

		// Token: 0x06005BCA RID: 23498 RVA: 0x001C8978 File Offset: 0x001C6B78
		public override int Read(byte[] PIJMJBDFBJB, int COHGEHOALPI, int CEFMEFIIMIC)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("DeflateStream");
			}
			return this.DBFLFNFMFIH.Read(PIJMJBDFBJB, COHGEHOALPI, CEFMEFIIMIC);
		}

		// Token: 0x06005BCB RID: 23499 RVA: 0x001C89A0 File Offset: 0x001C6BA0
		public virtual void NGCGLBPAMPD(byte[] PIJMJBDFBJB, int COHGEHOALPI, int CEFMEFIIMIC)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("quest");
			}
			this.DBFLFNFMFIH.Write(PIJMJBDFBJB, COHGEHOALPI, CEFMEFIIMIC);
		}

		// Token: 0x06005BCC RID: 23500 RVA: 0x001C89C8 File Offset: 0x001C6BC8
		public virtual bool HCEANGOICEO()
		{
			return true;
		}

		// Token: 0x06005BCD RID: 23501 RVA: 0x001C89CC File Offset: 0x001C6BCC
		public static byte[] GPHICHAJENK(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress);
				array = NIFAPEOJGMA.JDLJOPEHKAI(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x170001E6 RID: 486
		// (get) Token: 0x06005BCE RID: 23502 RVA: 0x001C8A14 File Offset: 0x001C6C14
		public virtual long BOIPIABMEND
		{
			get
			{
				return this.DBFLFNFMFIH.LOABHNKMLHO.HIJPFAIOBNP;
			}
		}

		// Token: 0x06005BCF RID: 23503 RVA: 0x001C8A28 File Offset: 0x001C6C28
		public static byte[] INPDLMOAKJO(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress);
				array = NIFAPEOJGMA.IEAJDGGBLNJ(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005BD0 RID: 23504 RVA: 0x001C8A70 File Offset: 0x001C6C70
		public virtual long DKKOJFNFIFE()
		{
			throw new NotImplementedException();
		}

		// Token: 0x170001E8 RID: 488
		// (get) Token: 0x06005BD1 RID: 23505 RVA: 0x001C8A78 File Offset: 0x001C6C78
		public override bool IIEGECHCMIE
		{
			get
			{
				return false;
			}
		}

		// Token: 0x06005BD2 RID: 23506 RVA: 0x001C8A7C File Offset: 0x001C6C7C
		public virtual void JNIOGNLOCPH(long NOBAPCOKFIL)
		{
			this.DBFLFNFMFIH.SetLength(NOBAPCOKFIL);
		}

		// Token: 0x06005BD3 RID: 23507 RVA: 0x001C8A8C File Offset: 0x001C6C8C
		public static byte[] ILAGJGHLFNF(byte[] GNNBOMAEBGK)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress, (LIGALFADMHC)122);
				NIFAPEOJGMA.KAMEPAAEOGE(GNNBOMAEBGK, stream);
				array = memoryStream.ToArray();
			}
			return array;
		}

		// Token: 0x06005BD4 RID: 23508 RVA: 0x001C8ADC File Offset: 0x001C6CDC
		public static byte[] JDLJOPEHKAI(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress);
				array = NIFAPEOJGMA.JDLJOPEHKAI(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005BD5 RID: 23509 RVA: 0x001C8B24 File Offset: 0x001C6D24
		public ONOAPGBMNOC(Stream JAGHIAOIDOC, JDICOHEACCI AOFANJEIKLO)
			: this(JAGHIAOIDOC, AOFANJEIKLO, LIGALFADMHC.Default, false)
		{
		}

		// Token: 0x06005BD6 RID: 23510 RVA: 0x001C8B30 File Offset: 0x001C6D30
		public static string ECGNCFPLINN(byte[] MPBFJKEOHCE)
		{
			string text;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress);
				text = NIFAPEOJGMA.NDGHIGIONMK(MPBFJKEOHCE, stream);
			}
			return text;
		}

		// Token: 0x06005BD7 RID: 23511 RVA: 0x001C8B78 File Offset: 0x001C6D78
		public static byte[] JGHKBGCNEEO(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress);
				array = NIFAPEOJGMA.BIKPGKKKCCD(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005BD8 RID: 23512 RVA: 0x001C8BC0 File Offset: 0x001C6DC0
		public static string KHJJEPJIJAJ(byte[] MPBFJKEOHCE)
		{
			string text;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress);
				text = NIFAPEOJGMA.NDGHIGIONMK(MPBFJKEOHCE, stream);
			}
			return text;
		}

		// Token: 0x06005BD9 RID: 23513 RVA: 0x001C8C08 File Offset: 0x001C6E08
		protected override void Dispose(bool PGLBLOEGIOF)
		{
			try
			{
				if (!this.DGNFEACJJHN)
				{
					if (PGLBLOEGIOF && this.DBFLFNFMFIH != null)
					{
						this.DBFLFNFMFIH.Close();
					}
					this.DGNFEACJJHN = true;
				}
			}
			finally
			{
				base.Dispose(PGLBLOEGIOF);
			}
		}

		// Token: 0x06005BDA RID: 23514 RVA: 0x001C8C60 File Offset: 0x001C6E60
		public void HFGGJPNLPDB(int NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("method");
			}
			if (this.DBFLFNFMFIH.LLDDIGGKEKM != null)
			{
				throw new KOJICFCHIEG("audioclip");
			}
			if (NOBAPCOKFIL < -161)
			{
				throw new KOJICFCHIEG(string.Format("Null arguments passed to ActionEvent.Invoke()", NOBAPCOKFIL, -91));
			}
			this.DBFLFNFMFIH.OCDAFILHNAH = NOBAPCOKFIL;
		}

		// Token: 0x06005BDB RID: 23515 RVA: 0x001C8CD8 File Offset: 0x001C6ED8
		public void JNANKDCHLBE(int NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("SystemInfo");
			}
			if (this.DBFLFNFMFIH.LLDDIGGKEKM != null)
			{
				throw new KOJICFCHIEG("∞");
			}
			if (NOBAPCOKFIL < 17)
			{
				throw new KOJICFCHIEG(string.Format("RpcOnOutOfBoundsHitPlayer", NOBAPCOKFIL, 83));
			}
			this.DBFLFNFMFIH.OCDAFILHNAH = NOBAPCOKFIL;
		}

		// Token: 0x170001EA RID: 490
		// (get) Token: 0x06005BDC RID: 23516 RVA: 0x001C8D50 File Offset: 0x001C6F50
		public override long OJKKOEJCCLC
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		// Token: 0x06005BDD RID: 23517 RVA: 0x001C8D58 File Offset: 0x001C6F58
		public static byte[] JJDJIIDBHCF(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress);
				array = NIFAPEOJGMA.BIKPGKKKCCD(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005BDE RID: 23518 RVA: 0x001C8DA0 File Offset: 0x001C6FA0
		public void KPDAKGEFDAE(int NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("your cube map center offset's magnitude is greater than 1, which will cause some cube map pixel always invisible .");
			}
			if (this.DBFLFNFMFIH.LLDDIGGKEKM != null)
			{
				throw new KOJICFCHIEG("api/config/");
			}
			if (NOBAPCOKFIL < 36)
			{
				throw new KOJICFCHIEG(string.Format("BalanceUpdates", NOBAPCOKFIL, 129));
			}
			this.DBFLFNFMFIH.OCDAFILHNAH = NOBAPCOKFIL;
		}

		// Token: 0x06005BDF RID: 23519 RVA: 0x001C8E18 File Offset: 0x001C7018
		public virtual long COMDJELIICB(long COHGEHOALPI, SeekOrigin MIKPIBIENPH)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005BE0 RID: 23520 RVA: 0x001C8E20 File Offset: 0x001C7020
		public void HAPGNKBGBLE(int NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("\n");
			}
			if (this.DBFLFNFMFIH.LLDDIGGKEKM != null)
			{
				throw new KOJICFCHIEG("SteamVR_ExternalCamera");
			}
			if (NOBAPCOKFIL < -63)
			{
				throw new KOJICFCHIEG(string.Format("] Render model does not support components, falling back to single mesh.", NOBAPCOKFIL, -29));
			}
			this.DBFLFNFMFIH.OCDAFILHNAH = NOBAPCOKFIL;
		}

		// Token: 0x06005BE1 RID: 23521 RVA: 0x001C8E98 File Offset: 0x001C7098
		public static byte[] KIODKMOJEED(string EJDAIKFLCCL)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress, LIGALFADMHC.BestCompression);
				NIFAPEOJGMA.KIODKMOJEED(EJDAIKFLCCL, stream);
				array = memoryStream.ToArray();
			}
			return array;
		}

		// Token: 0x06005BE2 RID: 23522 RVA: 0x001C8EE8 File Offset: 0x001C70E8
		public virtual BLDHMCOMMIC BJJFPLABKKI()
		{
			return this.DBFLFNFMFIH.KKMKMBPCLIK;
		}

		// Token: 0x06005BE3 RID: 23523 RVA: 0x001C8EF8 File Offset: 0x001C70F8
		public virtual long IIPMLJPKGOP()
		{
			return this.DBFLFNFMFIH.LOABHNKMLHO.HIJPFAIOBNP;
		}

		// Token: 0x06005BE4 RID: 23524 RVA: 0x001C8F0C File Offset: 0x001C710C
		public override void SetLength(long NOBAPCOKFIL)
		{
			this.DBFLFNFMFIH.SetLength(NOBAPCOKFIL);
		}

		// Token: 0x06005BE5 RID: 23525 RVA: 0x001C8F1C File Offset: 0x001C711C
		public virtual void CGDPELIOCNF(long NOBAPCOKFIL)
		{
			this.DBFLFNFMFIH.SetLength(NOBAPCOKFIL);
		}

		// Token: 0x06005BE6 RID: 23526 RVA: 0x001C8F2C File Offset: 0x001C712C
		public virtual long NKDMEBPHLIM(long COHGEHOALPI, SeekOrigin MIKPIBIENPH)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005BE7 RID: 23527 RVA: 0x001C8F34 File Offset: 0x001C7134
		public static string MCKBBFLLJBD(byte[] MPBFJKEOHCE)
		{
			string text;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress);
				text = NIFAPEOJGMA.AJMPHAKCOLH(MPBFJKEOHCE, stream);
			}
			return text;
		}

		// Token: 0x06005BE8 RID: 23528 RVA: 0x001C8F7C File Offset: 0x001C717C
		public virtual long CIJHNJGOMPH()
		{
			return this.DBFLFNFMFIH.LOABHNKMLHO.HIJPFAIOBNP;
		}

		// Token: 0x06005BE9 RID: 23529 RVA: 0x001C8F90 File Offset: 0x001C7190
		public virtual void NDIAEMHHEAF(long NOBAPCOKFIL)
		{
			this.DBFLFNFMFIH.SetLength(NOBAPCOKFIL);
		}

		// Token: 0x06005BEA RID: 23530 RVA: 0x001C8FA0 File Offset: 0x001C71A0
		public ONOAPGBMNOC(Stream JAGHIAOIDOC, JDICOHEACCI AOFANJEIKLO, LIGALFADMHC JOPHNBFKLCM)
			: this(JAGHIAOIDOC, AOFANJEIKLO, JOPHNBFKLCM, false)
		{
		}

		// Token: 0x06005BEB RID: 23531 RVA: 0x001C8FAC File Offset: 0x001C71AC
		public JOKHMHLCOEO OLONJJNOBFH()
		{
			return this.DBFLFNFMFIH.ALPGBDOIGMH;
		}

		// Token: 0x06005BEC RID: 23532 RVA: 0x001C8FBC File Offset: 0x001C71BC
		public virtual long JIKAPEKCLOK()
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005BED RID: 23533 RVA: 0x001C8FC4 File Offset: 0x001C71C4
		public override void Write(byte[] PIJMJBDFBJB, int COHGEHOALPI, int CEFMEFIIMIC)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("DeflateStream");
			}
			this.DBFLFNFMFIH.Write(PIJMJBDFBJB, COHGEHOALPI, CEFMEFIIMIC);
		}

		// Token: 0x06005BEE RID: 23534 RVA: 0x001C8FEC File Offset: 0x001C71EC
		public virtual long DMBOLLNLBMI()
		{
			if (this.DBFLFNFMFIH.HIGHLCOJBFD == NIFAPEOJGMA.CBLIBPFLGPK.Writer)
			{
				return this.DBFLFNFMFIH.LOABHNKMLHO.HIJPFAIOBNP;
			}
			if (this.DBFLFNFMFIH.HIGHLCOJBFD == NIFAPEOJGMA.CBLIBPFLGPK.Reader)
			{
				return this.DBFLFNFMFIH.LOABHNKMLHO.CIPIMHCHODI;
			}
			return 0L;
		}

		// Token: 0x06005BEF RID: 23535 RVA: 0x001C9040 File Offset: 0x001C7240
		public virtual long FOGJEGOIFIB()
		{
			return this.DBFLFNFMFIH.LOABHNKMLHO.CIPIMHCHODI;
		}

		// Token: 0x170001E9 RID: 489
		// (get) Token: 0x06005BF0 RID: 23536 RVA: 0x001C9054 File Offset: 0x001C7254
		public override bool CFPIPLFFHDD
		{
			get
			{
				if (this.DGNFEACJJHN)
				{
					throw new ObjectDisposedException("DeflateStream");
				}
				return this.DBFLFNFMFIH.EOHFKDMAJPP.CanWrite;
			}
		}

		// Token: 0x06005BF1 RID: 23537 RVA: 0x001C907C File Offset: 0x001C727C
		public int EOICGPGKIFP()
		{
			return this.DBFLFNFMFIH.OCDAFILHNAH;
		}

		// Token: 0x06005BF2 RID: 23538 RVA: 0x001C908C File Offset: 0x001C728C
		public static byte[] BFJDLEPNEFA(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress);
				array = NIFAPEOJGMA.OFCANJNLALF(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005BF3 RID: 23539 RVA: 0x001C90D4 File Offset: 0x001C72D4
		public virtual long EOIIABIEOEG()
		{
			return this.DBFLFNFMFIH.LOABHNKMLHO.HIJPFAIOBNP;
		}

		// Token: 0x06005BF4 RID: 23540 RVA: 0x001C90E8 File Offset: 0x001C72E8
		public override long Seek(long COHGEHOALPI, SeekOrigin MIKPIBIENPH)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005BF5 RID: 23541 RVA: 0x001C90F0 File Offset: 0x001C72F0
		public virtual void GCLODELODML(long NOBAPCOKFIL)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005BF6 RID: 23542 RVA: 0x001C90F8 File Offset: 0x001C72F8
		public override void Flush()
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("DeflateStream");
			}
			this.DBFLFNFMFIH.Flush();
		}

		// Token: 0x170001E3 RID: 483
		// (get) Token: 0x06005BF7 RID: 23543 RVA: 0x001C911C File Offset: 0x001C731C
		// (set) Token: 0x06005BFE RID: 23550 RVA: 0x001C9260 File Offset: 0x001C7460
		public int HHNGBMBGMME
		{
			get
			{
				return this.DBFLFNFMFIH.OCDAFILHNAH;
			}
			set
			{
				if (this.DGNFEACJJHN)
				{
					throw new ObjectDisposedException("DeflateStream");
				}
				if (this.DBFLFNFMFIH.LLDDIGGKEKM != null)
				{
					throw new KOJICFCHIEG("The working buffer is already set.");
				}
				if (value < 1024)
				{
					throw new KOJICFCHIEG(string.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, 1024));
				}
				this.DBFLFNFMFIH.OCDAFILHNAH = value;
			}
		}

		// Token: 0x06005BF8 RID: 23544 RVA: 0x001C912C File Offset: 0x001C732C
		public static byte[] MCBBPKBPABP(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress);
				array = NIFAPEOJGMA.ICHMFILFENG(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005BF9 RID: 23545 RVA: 0x001C9174 File Offset: 0x001C7374
		public virtual bool KJLEPBPOKPN()
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("SystemInfo");
			}
			return this.DBFLFNFMFIH.EOHFKDMAJPP.CanRead;
		}

		// Token: 0x06005BFA RID: 23546 RVA: 0x001C919C File Offset: 0x001C739C
		public virtual void PDPNPPILKBB(BLDHMCOMMIC NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("[ACTk] ");
			}
			this.DBFLFNFMFIH.KKMKMBPCLIK = NOBAPCOKFIL;
		}

		// Token: 0x06005BFB RID: 23547 RVA: 0x001C91C0 File Offset: 0x001C73C0
		public virtual BLDHMCOMMIC CIKNCAAFOEO()
		{
			return this.DBFLFNFMFIH.KKMKMBPCLIK;
		}

		// Token: 0x06005BFC RID: 23548 RVA: 0x001C91D0 File Offset: 0x001C73D0
		public static byte[] OOMIFPHDCEH(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress);
				array = NIFAPEOJGMA.OFCANJNLALF(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005BFD RID: 23549 RVA: 0x001C9218 File Offset: 0x001C7418
		public static byte[] CLAGKJCPEEP(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress);
				array = NIFAPEOJGMA.JDLJOPEHKAI(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x170001E2 RID: 482
		// (get) Token: 0x06005BFF RID: 23551 RVA: 0x001C92D8 File Offset: 0x001C74D8
		// (set) Token: 0x06005C00 RID: 23552 RVA: 0x001C92E8 File Offset: 0x001C74E8
		public virtual BLDHMCOMMIC LBPBHHJGNPG
		{
			get
			{
				return this.DBFLFNFMFIH.KKMKMBPCLIK;
			}
			set
			{
				if (this.DGNFEACJJHN)
				{
					throw new ObjectDisposedException("DeflateStream");
				}
				this.DBFLFNFMFIH.KKMKMBPCLIK = value;
			}
		}

		// Token: 0x06005C01 RID: 23553 RVA: 0x001C930C File Offset: 0x001C750C
		public virtual void CBBLJDLGFPC(long NOBAPCOKFIL)
		{
			this.DBFLFNFMFIH.SetLength(NOBAPCOKFIL);
		}

		// Token: 0x06005C02 RID: 23554 RVA: 0x001C931C File Offset: 0x001C751C
		protected virtual void LJPMBCLIJDI(bool PGLBLOEGIOF)
		{
			try
			{
				if (!this.DGNFEACJJHN)
				{
					if (PGLBLOEGIOF && this.DBFLFNFMFIH != null)
					{
						this.DBFLFNFMFIH.Close();
					}
					this.DGNFEACJJHN = true;
				}
			}
			finally
			{
				base.Dispose(PGLBLOEGIOF);
			}
		}

		// Token: 0x06005C03 RID: 23555 RVA: 0x001C9374 File Offset: 0x001C7574
		public virtual void ONALIGOKPMG(BLDHMCOMMIC NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("LAST_USE_TIME");
			}
			this.DBFLFNFMFIH.KKMKMBPCLIK = NOBAPCOKFIL;
		}

		// Token: 0x06005C04 RID: 23556 RVA: 0x001C9398 File Offset: 0x001C7598
		public virtual void ODDNKHOHNOE(BLDHMCOMMIC NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("Adding data to a closed hasher.");
			}
			this.DBFLFNFMFIH.KKMKMBPCLIK = NOBAPCOKFIL;
		}

		// Token: 0x06005C05 RID: 23557 RVA: 0x001C93BC File Offset: 0x001C75BC
		public virtual void EBBBOPDKFPP(long NOBAPCOKFIL)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005C06 RID: 23558 RVA: 0x001C93C4 File Offset: 0x001C75C4
		public ONOAPGBMNOC(Stream JAGHIAOIDOC, JDICOHEACCI AOFANJEIKLO, LIGALFADMHC JOPHNBFKLCM, bool KEKLNOJHHML)
		{
			this.JMAPMFDJNBO = JAGHIAOIDOC;
			this.DBFLFNFMFIH = new NIFAPEOJGMA(JAGHIAOIDOC, AOFANJEIKLO, JOPHNBFKLCM, ENEBFDIKJOE.DEFLATE, KEKLNOJHHML);
		}

		// Token: 0x06005C07 RID: 23559 RVA: 0x001C93E8 File Offset: 0x001C75E8
		public virtual BLDHMCOMMIC EPJLHIAMJBO()
		{
			return this.DBFLFNFMFIH.KKMKMBPCLIK;
		}

		// Token: 0x06005C08 RID: 23560 RVA: 0x001C93F8 File Offset: 0x001C75F8
		public static byte[] KNOBJOHDANO(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress);
				array = NIFAPEOJGMA.IEAJDGGBLNJ(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005C09 RID: 23561 RVA: 0x001C9440 File Offset: 0x001C7640
		public virtual bool KBAGHEDDINF()
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("Max Connection/Server: ");
			}
			return this.DBFLFNFMFIH.EOHFKDMAJPP.CanWrite;
		}

		// Token: 0x06005C0A RID: 23562 RVA: 0x001C9468 File Offset: 0x001C7668
		public virtual BLDHMCOMMIC KBLOCPIKPNN()
		{
			return this.DBFLFNFMFIH.KKMKMBPCLIK;
		}

		// Token: 0x06005C0B RID: 23563 RVA: 0x001C9478 File Offset: 0x001C7678
		public static byte[] BPBAGKAMDCM(string EJDAIKFLCCL)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress, (LIGALFADMHC)(-114));
				NIFAPEOJGMA.EJDJEHFFFEI(EJDAIKFLCCL, stream);
				array = memoryStream.ToArray();
			}
			return array;
		}

		// Token: 0x06005C0C RID: 23564 RVA: 0x001C94C8 File Offset: 0x001C76C8
		public void EGMNDFIMEOJ(JOKHMHLCOEO NOBAPCOKFIL)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("startXform");
			}
			this.DBFLFNFMFIH.ALPGBDOIGMH = NOBAPCOKFIL;
		}

		// Token: 0x06005C0D RID: 23565 RVA: 0x001C94EC File Offset: 0x001C76EC
		public virtual long KCLLEEDAPFP()
		{
			throw new NotImplementedException();
		}

		// Token: 0x170001E7 RID: 487
		// (get) Token: 0x06005C0E RID: 23566 RVA: 0x001C94F4 File Offset: 0x001C76F4
		public override bool ABKEFMDOLKF
		{
			get
			{
				if (this.DGNFEACJJHN)
				{
					throw new ObjectDisposedException("DeflateStream");
				}
				return this.DBFLFNFMFIH.EOHFKDMAJPP.CanRead;
			}
		}

		// Token: 0x170001E5 RID: 485
		// (get) Token: 0x06005C0F RID: 23567 RVA: 0x001C951C File Offset: 0x001C771C
		public virtual long NJIFDCOIJDB
		{
			get
			{
				return this.DBFLFNFMFIH.LOABHNKMLHO.CIPIMHCHODI;
			}
		}

		// Token: 0x06005C10 RID: 23568 RVA: 0x001C9530 File Offset: 0x001C7730
		public static byte[] NELHOFGIIKA(byte[] GNNBOMAEBGK)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Compress, (LIGALFADMHC)(-7));
				NIFAPEOJGMA.LNOKDDCKJGC(GNNBOMAEBGK, stream);
				array = memoryStream.ToArray();
			}
			return array;
		}

		// Token: 0x06005C12 RID: 23570 RVA: 0x001C9590 File Offset: 0x001C7790
		public virtual long DBHEFGOBBPF(long COHGEHOALPI, SeekOrigin MIKPIBIENPH)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005C13 RID: 23571 RVA: 0x001C9598 File Offset: 0x001C7798
		public static byte[] BCFBIAGPFCM(byte[] MPBFJKEOHCE)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress);
				array = NIFAPEOJGMA.BIKPGKKKCCD(MPBFJKEOHCE, stream);
			}
			return array;
		}

		// Token: 0x06005C14 RID: 23572 RVA: 0x001C95E0 File Offset: 0x001C77E0
		public virtual long PBJJHMBCMHB(long COHGEHOALPI, SeekOrigin MIKPIBIENPH)
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005C15 RID: 23573 RVA: 0x001C95E8 File Offset: 0x001C77E8
		public ONOAPGBMNOC(Stream JAGHIAOIDOC, JDICOHEACCI AOFANJEIKLO, LIGALFADMHC JOPHNBFKLCM, bool KEKLNOJHHML, int DENGFEBINFP)
		{
			this.JMAPMFDJNBO = JAGHIAOIDOC;
			this.DBFLFNFMFIH = new NIFAPEOJGMA(JAGHIAOIDOC, AOFANJEIKLO, JOPHNBFKLCM, ENEBFDIKJOE.DEFLATE, KEKLNOJHHML, DENGFEBINFP);
		}

		// Token: 0x06005C16 RID: 23574 RVA: 0x001C9610 File Offset: 0x001C7810
		public virtual void HDMPCODGKLG(byte[] PIJMJBDFBJB, int COHGEHOALPI, int CEFMEFIIMIC)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("DownloadLength");
			}
			this.DBFLFNFMFIH.Write(PIJMJBDFBJB, COHGEHOALPI, CEFMEFIIMIC);
		}

		// Token: 0x06005C17 RID: 23575 RVA: 0x001C9638 File Offset: 0x001C7838
		public static string AJMPHAKCOLH(byte[] MPBFJKEOHCE)
		{
			string text;
			using (MemoryStream memoryStream = new MemoryStream(MPBFJKEOHCE))
			{
				Stream stream = new ONOAPGBMNOC(memoryStream, JDICOHEACCI.Decompress);
				text = NIFAPEOJGMA.AJMPHAKCOLH(MPBFJKEOHCE, stream);
			}
			return text;
		}

		// Token: 0x170001EB RID: 491
		// (get) Token: 0x06005C19 RID: 23577 RVA: 0x001C9688 File Offset: 0x001C7888
		// (set) Token: 0x06005C18 RID: 23576 RVA: 0x001C9680 File Offset: 0x001C7880
		public override long GMOJLKHOBGG
		{
			get
			{
				if (this.DBFLFNFMFIH.HIGHLCOJBFD == NIFAPEOJGMA.CBLIBPFLGPK.Writer)
				{
					return this.DBFLFNFMFIH.LOABHNKMLHO.HIJPFAIOBNP;
				}
				if (this.DBFLFNFMFIH.HIGHLCOJBFD == NIFAPEOJGMA.CBLIBPFLGPK.Reader)
				{
					return this.DBFLFNFMFIH.LOABHNKMLHO.CIPIMHCHODI;
				}
				return 0L;
			}
			set
			{
				throw new NotImplementedException();
			}
		}

		// Token: 0x06005C1A RID: 23578 RVA: 0x001C96DC File Offset: 0x001C78DC
		public virtual bool HEPEHOIMDHO()
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("count");
			}
			return this.DBFLFNFMFIH.EOHFKDMAJPP.CanWrite;
		}

		// Token: 0x06005C1B RID: 23579 RVA: 0x001C9704 File Offset: 0x001C7904
		public virtual long NKDGCJCPOHB()
		{
			throw new NotImplementedException();
		}

		// Token: 0x06005C1C RID: 23580 RVA: 0x001C970C File Offset: 0x001C790C
		public virtual void EIIIDLDHJPL(byte[] PIJMJBDFBJB, int COHGEHOALPI, int CEFMEFIIMIC)
		{
			if (this.DGNFEACJJHN)
			{
				throw new ObjectDisposedException("Can't assign null to an instance of type {0}");
			}
			this.DBFLFNFMFIH.Write(PIJMJBDFBJB, COHGEHOALPI, CEFMEFIIMIC);
		}

		// Token: 0x04000BB8 RID: 3000
		internal NIFAPEOJGMA DBFLFNFMFIH;

		// Token: 0x04000BB9 RID: 3001
		internal Stream JMAPMFDJNBO;

		// Token: 0x04000BBA RID: 3002
		private bool DGNFEACJJHN;
	}
}