// 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));
 }