// Token: 0x06002ABD RID: 10941 RVA: 0x00013EDE File Offset: 0x000120DE
private unsafe static uint smethod_7(byte *input, byte s1, byte s2, byte s3)
{
return(Class478.smethod_6(input + 1, s2, s3) << (int)s1 ^ (uint)(*input));
}
// Token: 0x06002AB6 RID: 10934 RVA: 0x000A4E00 File Offset: 0x000A3000
public unsafe static void smethod_0(byte[] src, out byte[] dst)
{
uint num = (uint)(src.Length + src.Length / 16 + 64 + 3);
dst = new byte[num];
uint num2;
if ((long)src.Length <= 13L)
{
num2 = (uint)src.Length;
num = 0U;
}
else
{
byte[] array = new byte[65539];
byte[] array2;
byte * ptr;
if ((array2 = array) != null && array2.Length != 0)
{
fixed(byte *ptr = &array2[0])
{
}
}
else
{
ptr = null;
}
byte *ptr2;
if (src != null && src.Length != 0)
{
fixed(byte *ptr2 = &src[0])
{
}
}
else
{
ptr2 = null;
}
byte[] array3;
byte * ptr3;
if ((array3 = dst) != null && array3.Length != 0)
{
fixed(byte *ptr3 = &array3[0])
{
}
}
else
{
ptr3 = null;
}
byte **ptr4 = (byte **)ptr;
byte * ptr5 = ptr2 + src.Length;
byte * ptr6 = ptr2 + src.Length - 8 - 5;
byte * ptr7 = ptr2;
byte * ptr8 = ptr2 + 4;
byte * ptr9 = ptr3;
bool flag = false;
bool flag2 = false;
for (;;)
{
uint num3 = 0U;
uint num4 = Class478.smethod_2(ptr8);
byte *ptr10 = ptr8 - (ptr8 - *(IntPtr *)(ptr4 + (ulong)num4 * (ulong)((long)sizeof(byte *)) / (ulong)sizeof(byte *))) / 1;
if (ptr10 >= ptr2 && (num3 = (uint)((long)(ptr8 - ptr10))) > 0U && num3 <= 49151U)
{
if (num3 > 2048U && ptr10[3] != ptr8[3])
{
num4 = Class478.smethod_3(num4);
ptr10 = ptr8 - (ptr8 - *(IntPtr *)(ptr4 + (ulong)num4 * (ulong)((long)sizeof(byte *)) / (ulong)sizeof(byte *))) / 1;
if (ptr10 >= ptr2 && (num3 = (uint)((long)(ptr8 - ptr10))) > 0U && num3 <= 49151U)
{
if (num3 > 2048U && ptr10[3] != ptr8[3])
{
flag = true;
}
}
else
{
flag = true;
}
}
}
else
{
flag = true;
}
if (!flag && *(ushort *)ptr10 == *(ushort *)ptr8 && ptr10[2] == ptr8[2])
{
flag2 = true;
}
flag = false;
if (!flag2)
{
*(IntPtr *)(ptr4 + (ulong)num4 * (ulong)((long)sizeof(byte *)) / (ulong)sizeof(byte *)) = ptr8;
ptr8++;
if (ptr8 >= ptr6)
{
break;
}
}
else
{
flag2 = false;
*(IntPtr *)(ptr4 + (ulong)num4 * (ulong)((long)sizeof(byte *)) / (ulong)sizeof(byte *)) = ptr8;
if ((long)(ptr8 - ptr7) > 0L)
{
uint num5 = (uint)((long)(ptr8 - ptr7));
if (num5 <= 3U)
{
byte *ptr11 = ptr9 + -2;
* ptr11 |= (byte)num5;
}
else if (num5 <= 18U)
{
*(ptr9++) = (byte)(num5 - 3U);
}
else
{
uint num6 = num5 - 18U;
*(ptr9++) = 0;
while (num6 > 255U)
{
num6 -= 255U;
*(ptr9++) = 0;
}
*(ptr9++) = (byte)num6;
}
do
{
*(ptr9++) = *(ptr7++);
}while ((num5 -= 1U) > 0U);
}
ptr8 += 3;
if (ptr10[3] != *(ptr8++) || ptr10[4] != *(ptr8++) || ptr10[5] != *(ptr8++) || ptr10[6] != *(ptr8++) || ptr10[7] != *(ptr8++))
{
goto IL_38F;
}
if (ptr10[8] != *(ptr8++))
{
goto IL_38F;
}
byte *ptr12 = ptr10 + 8 + 1;
while (ptr8 < ptr5)
{
if (*ptr12 != *ptr8)
{
break;
}
ptr12++;
ptr8++;
}
uint num7 = (uint)((long)(ptr8 - ptr7));
if (num3 <= 16384U)
{
num3 -= 1U;
if (num7 <= 33U)
{
*(ptr9++) = (byte)(32U | num7 - 2U);
}
else
{
num7 -= 33U;
*(ptr9++) = 32;
while (num7 > 255U)
{
num7 -= 255U;
*(ptr9++) = 0;
}
*(ptr9++) = (byte)num7;
}
}
else
{
num3 -= 16384U;
if (num7 <= 9U)
{
*(ptr9++) = (byte)(16U | (num3 & 16384U) >> 11 | num7 - 2U);
}
else
{
num7 -= 9U;
*(ptr9++) = (byte)(16U | (num3 & 16384U) >> 11);
while (num7 > 255U)
{
num7 -= 255U;
*(ptr9++) = 0;
}
*(ptr9++) = (byte)num7;
}
}
*(ptr9++) = (byte)((num3 & 63U) << 2);
*(ptr9++) = (byte)(num3 >> 6);
IL_461:
ptr7 = ptr8;
if (ptr8 >= ptr6)
{
break;
}
continue;
IL_38F:
ptr8--;
num7 = (uint)((long)(ptr8 - ptr7));
if (num3 <= 2048U)
{
num3 -= 1U;
*(ptr9++) = (byte)(num7 - 1U << 5 | (num3 & 7U) << 2);
*(ptr9++) = (byte)(num3 >> 3);
goto IL_461;
}
if (num3 <= 16384U)
{
num3 -= 1U;
*(ptr9++) = (byte)(32U | num7 - 2U);
*(ptr9++) = (byte)((num3 & 63U) << 2);
*(ptr9++) = (byte)(num3 >> 6);
goto IL_461;
}
num3 -= 16384U;
*(ptr9++) = (byte)(16U | (num3 & 16384U) >> 11 | num7 - 2U);
*(ptr9++) = (byte)((num3 & 63U) << 2);
*(ptr9++) = (byte)(num3 >> 6);
goto IL_461;
}
}
num = (uint)((long)(ptr9 - ptr3));
num2 = (uint)((long)(ptr5 - ptr7));
ptr = null;
ptr2 = null;
ptr3 = null;
}
if (num2 > 0U)
{
uint num8 = (uint)(src.Length - (int)num2);
if (num == 0U && num2 <= 238U)
{
dst[(int)((UIntPtr)(num++))] = (byte)(17U + num2);
}
else if (num2 <= 3U)
{
byte[] array4 = dst;
UIntPtr uintPtr = (UIntPtr)(num - 2U);
array4[(int)uintPtr] = (array4[(int)uintPtr] | (byte)num2);
}
else if (num2 <= 18U)
{
dst[(int)((UIntPtr)(num++))] = (byte)(num2 - 3U);
}
else
{
uint num9 = num2 - 18U;
dst[(int)((UIntPtr)(num++))] = 0;
while (num9 > 255U)
{
num9 -= 255U;
dst[(int)((UIntPtr)(num++))] = 0;
}
dst[(int)((UIntPtr)(num++))] = (byte)num9;
}
do
{
dst[(int)((UIntPtr)(num++))] = src[(int)((UIntPtr)(num8++))];
}while ((num2 -= 1U) > 0U);
}
dst[(int)((UIntPtr)(num++))] = 17;
dst[(int)((UIntPtr)(num++))] = 0;
dst[(int)((UIntPtr)(num++))] = 0;
if ((long)dst.Length != (long)((ulong)num))
{
byte[] array5 = new byte[num];
Buffer.BlockCopy(dst, 0, array5, 0, (int)num);
dst = array5;
}
}
// Token: 0x06002AB8 RID: 10936 RVA: 0x00013E83 File Offset: 0x00012083
private unsafe static uint smethod_2(byte *input)
{
return(Class478.smethod_4(Class478.smethod_5(33U, Class478.smethod_7(input, 5, 5, 6)) >> 5, 0));
}
