using System;

using System.Globalization;

using System.IO;

using System.Text;

using System.Collections.Generic;

using System.Collections;

​

public class Program

{

    public static void Main()

    {

        var bits2 = new BitArray(11*8 + 8, false);

        bits2.Set(0, true);

        bits2.Set(5, true);

        bits2.Set(20, true);

        byte[] ret = new byte[(bits2.Length - 1) / 8 + 1];

        bits2.CopyTo(ret, 0);

        Console.WriteLine(BitConverter.ToString(ret).Replace("-", ""));

        var sData = "2C000000840040000400000004989600002E200100402FFFFC00F093AD010005000000F07B69020000000000F0886A020003000000F0A72C020000000000F0246E020003000000F0FF2F020001000000F0465C020000000000F0D57D020003000000F08C6A020003000000F0286E020003000000F0E66E020003000000F0E46E020003000000F06176020000000000F07F6F020003000000F0A76A020003000000F0A36A020003000000F00000000000000000F0A82C020000000000";

        var data = new byte[sData.Length / 2];

        for (int i = 0; i < sData.Length; i += 2)

            data[i / 2] = Convert.ToByte(sData.Substring(i, 2), 16);

        var pkt = new PacketReader(data);

        var bits = new BitUnpack(pkt);

        var val = bits.GetBits<int>(6);

        Console.WriteLine($"BitMask: {val}");

        var ctr = 6u;

        var v6 = 1u;

        var v7 = 0;

        var vals = new List<int>();

        var flags = 0;

        do

        {

            if ( (v6 & (val + (v7 >> 5))) == v6)

            {

                vals.Add(bits.GetBits<int>(32));

                flags |= vals[vals.Count - 1];

            }

            ++v7;

            v6 = LeftRotate(v6, 1);

            Console.WriteLine($"{v6:X}");

            --ctr;

        } while (ctr > 0);

        Console.WriteLine();

        Console.WriteLine("flags:");

        foreach (var v in vals)

            Console.WriteLine($"{v:X}");

​

        Console.WriteLine($"Flags: 0x{flags:X}");

        // Data

        if ((vals[0] & 1) == 1)

        {

            if ((vals[0] & 0x20) == 0x20)

            {

                Console.WriteLine($"DisplayId: {pkt.ReadUInt32()}");

            }

        }

        if ((vals[1] & 1) == 1)

        {

            if ((vals[1] & 0x100000) == 0x100000)

            {

                Console.WriteLine($"MountDisplayId: {pkt.ReadUInt32()}");

            }

        }

    }

    public static uint LeftRotate(uint value, int shiftCount) => (value << shiftCount) | (value >> (0x20 - shiftCount));

}

​

 public class PacketReader : BinaryReader

    {

        public uint Size { get; set; }

        public byte[] Storage { get; set; }

​

        public PacketReader(byte[] data) : base(new MemoryStream(data))

        {

        }

​

        public byte[] ReadBytes(uint count)

        {

            return base.ReadBytes((int)count);

        }

​

        public string ReadStringFromBytes(uint count)

        {

            byte[] stringArray = ReadBytes(count);

            Array.Reverse(stringArray);

​

            return UTF8Encoding.UTF8.GetString(stringArray);

        }

​

        public string ReadIPAddress()

        {

            byte[] ip = new byte[4];

​

            for (int i = 0; i < 4; ++i)

                ip[i] = this.ReadByte();

​

            return ip[0] + "." + ip[1] + "." + ip[2] + "." + ip[3];

        }

​

        public string ReadAccountName()

        {

            StringBuilder nameBuilder = new StringBuilder();

​

            byte nameLength = this.ReadByte();

            char[] name = new char[nameLength];

​

            for (int i = 0; i < nameLength; i++)

            {

                name[i] = base.ReadChar();

                nameBuilder.Append(name[i]);

            }

​

            return nameBuilder.ToString().ToUpper(CultureInfo.InvariantCulture);

        }

​

        public void Skip(int count)

        {

            base.BaseStream.Position += count;

        }

    }

    public class BitUnpack

    {

        public PacketReader reader;

        int Position;

        byte Value;

​

        public BitUnpack(PacketReader reader)

        {

            this.reader = reader;

            Position = 8;

            Value = 0;

        }

​

        public bool GetBit()

        {

            if (Position == 8)

            {

                Value = reader.ReadByte();

                Position = 0;

            }

​

            int returnValue = Value;

            Value = (byte)(2 * returnValue);

            ++Position;

​

            return Convert.ToBoolean(returnValue >> 7);

        }

​

        public T GetBits<T>(byte bitCount)

        {

            int returnValue = 0;

​

            checked

            {

                for (var i = bitCount - 1; i >= 0; --i)

                    returnValue = GetBit() ? (1 << i) | returnValue : returnValue;

            }

​

            return (T)Convert.ChangeType(returnValue, typeof(T), CultureInfo.InvariantCulture);

        }

​

        public T GetNameLength<T>(byte bitCount)

        {

            int returnValue = 0;

​

            // Unknown, always before namelength bits...

            GetBit();

​

            checked

            {

                for (var i = bitCount - 1; i >= 0; --i)

                    returnValue = GetBit() ? (1 << i) | returnValue : returnValue;

            }

​

            return (T)Convert.ChangeType(returnValue, typeof(T), CultureInfo.InvariantCulture);

        }

​

        public ulong GetPackedValue(byte[] mask, byte[] bytes)

        {

            bool[] valueMask = new bool[mask.Length];

            byte[] valueBytes = new byte[bytes.Length];

​

            for (int i = 0; i < valueMask.Length; i++)

                valueMask[i] = GetBit();

            for (byte i = 0; i < bytes.Length; i++)

                if (valueMask[mask[i]])

                    valueBytes[bytes[i]] = (byte)(reader.ReadByte() ^ 1);

​

            return BitConverter.ToUInt64(valueBytes, 0);

        }

        public void Flush()

        {

            Value = 0;

            Position = 8;

​

        }

    }