static unsafe Compression()
{
int index1 = 0;
Compression.m_Tree = new UnpackLeaf(index1);
UnpackLeaf[] unpackLeafArray = Compression.m_Leaves;
int index2 = index1;
int num1 = 1;
int index3 = index2 + num1;
UnpackLeaf unpackLeaf1 = Compression.m_Tree;
unpackLeafArray[index2] = unpackLeaf1;
fixed(short *numPtr1 = Compression._sourceTable)
{
short *numPtr2 = numPtr1;
for (short index4 = 0; (int)index4 <= 256; ++index4)
{
UnpackLeaf unpackLeaf2 = Compression.m_Tree;
int num2 = (int)*numPtr2++;
int num3 = num2 & 15;
int num4 = num2 >> 4;
while (--num3 >= 0)
{
switch (num4 & 1)
{
case 0:
if (unpackLeaf2.m_Left == null)
{
unpackLeaf2.m_Left = new UnpackLeaf(index3);
Compression.m_Leaves[index3++] = unpackLeaf2.m_Left;
}
unpackLeaf2 = unpackLeaf2.m_Left;
break;
case 1:
if (unpackLeaf2.m_Right == null)
{
unpackLeaf2.m_Right = new UnpackLeaf(index3);
Compression.m_Leaves[index3++] = unpackLeaf2.m_Right;
}
unpackLeaf2 = unpackLeaf2.m_Right;
break;
}
num4 >>= 1;
}
unpackLeaf2.m_Value = index4;
}
}
Compression._sourceTable = (short[])null;
}
public override unsafe int Decrypt(byte[] input, int inputStart, int count, byte[] output, int outputStart)
{
fixed(byte *numPtr1 = output)
{
byte *numPtr2 = numPtr1 + outputStart;
byte *numPtr3 = numPtr1 + output.Length;
fixed(UnpackCacheEntry *unpackCacheEntryPtr = Compression.m_CacheEntries)
fixed(byte *numPtr4 = Compression.m_OutputBuffer)
fixed(byte *numPtr5 = input)
{
UnpackLeaf unpackLeaf = this.m_Leaf;
UnpackLeaf[] unpackLeafArray = Compression.m_Leaves;
byte * numPtr6 = numPtr5;
byte * numPtr7 = numPtr6 + count;
while (numPtr6 < numPtr7)
{
UnpackCacheEntry unpackCacheEntry = unpackCacheEntryPtr[unpackLeaf.m_Cache[(int)*numPtr6++]];
byte * numPtr8 = numPtr4 + unpackCacheEntry.m_ByteIndex;
byte * numPtr9 = numPtr2 + unpackCacheEntry.m_ByteCount;
if (numPtr9 > numPtr3)
{
throw new InternalBufferOverflowException("Network::Decompress(): Buffer overflow.");
}
while (numPtr2 < numPtr9)
{
*numPtr2++ = *numPtr8++;
}
unpackLeaf = unpackLeafArray[unpackCacheEntry.m_NextIndex];
}
this.m_Leaf = unpackLeaf;
}
return((int)(numPtr2 - outputStart - numPtr1));
}
}
public static unsafe void LoadUnpackCache()
{
Compression.m_OutputBuffer = new byte[100725];
Compression.m_CacheEntries = new UnpackCacheEntry[65536];
fixed(UnpackCacheEntry *unpackCacheEntryPtr1 = Compression.m_CacheEntries)
{
UnpackCacheEntry *unpackCacheEntryPtr2 = unpackCacheEntryPtr1;
fixed(byte *numPtr1 = Compression.m_OutputBuffer)
{
Stack <UnpackLeaf> unpackLeafStack = new Stack <UnpackLeaf>();
unpackLeafStack.Push(Compression.m_Tree);
while (unpackLeafStack.Count > 0)
{
UnpackLeaf unpackLeaf1 = unpackLeafStack.Pop();
if (unpackLeaf1.m_Left != null)
{
unpackLeafStack.Push(unpackLeaf1.m_Left);
}
if (unpackLeaf1.m_Right != null)
{
unpackLeafStack.Push(unpackLeaf1.m_Right);
}
int[] numArray = new int[256];
label_21:
for (int index = 0; index < 256; ++index)
{
byte * numPtr2 = numPtr1 + Compression.m_OutputIndex;
UnpackLeaf unpackLeaf2 = unpackLeaf1;
int num1 = 0;
int num2 = 8;
while (--num2 >= 0)
{
switch (index >> num2 & 1)
{
case 0:
unpackLeaf2 = unpackLeaf2.m_Left;
break;
case 1:
unpackLeaf2 = unpackLeaf2.m_Right;
break;
}
if (unpackLeaf2 != null)
{
if ((int)unpackLeaf2.m_Value != -1)
{
switch ((int)unpackLeaf2.m_Value >> 8)
{
case 0:
numPtr2[num1++] = (byte)unpackLeaf2.m_Value;
break;
case 1:
num2 = 0;
break;
}
unpackLeaf2 = Compression.m_Tree;
}
}
else
{
goto label_21;
}
}
unpackCacheEntryPtr2->m_NextIndex = (int)unpackLeaf2.m_Index;
unpackCacheEntryPtr2->m_ByteIndex = Compression.m_OutputIndex;
unpackCacheEntryPtr2->m_ByteCount = num1;
numArray[index] = (int)(unpackCacheEntryPtr2 - unpackCacheEntryPtr1);
++unpackCacheEntryPtr2;
Compression.m_OutputIndex += num1;
}
unpackLeaf1.m_Cache = numArray;
}
}
}
}
protected override void InitKeys(uint seed)
{
this.m_Leaf = Compression.m_Tree;
}
