niko
1221 lines
34 KiB
C#
1221 lines
34 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|