<pre class="brush: csharp; gutter: false;">using System;
using System.Collections.Generic;
using System.Text;

namespace BitIntegerTest
{
    public class Packet
    {
        private List&lt;byte&gt; buffer;
        private int bitIndex = 0;
        private int maxBitIndex = 0;
        private int previousBitIndex = -1;

        /// &lt;summary&gt;
        /// Expands the buffer size appending bytes so that the write functions don't overflow.
        /// Records the furthest write in the maxBitIndex
        /// &lt;/summary&gt;
        /// &lt;param name="bits"&gt;The number of bits to allocate and record.&lt;/param&gt;
        private void ExpandBuffer(int bits)
        {
            if (bits &lt; 1) throw new ArgumentOutOfRangeException("bits must be greater than 0");
            while ((bitIndex + bits + 7) / 8 &gt; buffer.Count) buffer.Add(new byte());
            maxBitIndex = Math.Max(maxBitIndex, bitIndex + bits);
        }

        /// &lt;summary&gt;
        /// Constructor.
        /// &lt;/summary&gt;
        public Packet()
        {
            buffer = new List&lt;byte&gt;();
        }

        /// &lt;summary&gt;
        /// Fills the buffer with the requested bytes to work with.
        /// &lt;/summary&gt;
        /// &lt;param name="buffer"&gt;The bytes to load into the buffer&lt;/param&gt;
        public Packet(byte[] buffer)
        {
            this.buffer = new List&lt;byte&gt;(buffer);
        }

        /// &lt;summary&gt;
        /// Fills the buffer with the requested bytes to work with.
        /// &lt;/summary&gt;
        /// &lt;param name="buffer"&gt;The bytes to load into the buffer&lt;/param&gt;
        /// &lt;param name="maxBitIndex"&gt;The maximum bit index&lt;/param&gt;
        public Packet(byte[] buffer, int maxBitIndex)
        {
            this.buffer = new List&lt;byte&gt;(buffer);
            this.maxBitIndex = maxBitIndex;
        }

        /// &lt;summary&gt;
        /// Gets or sets the bit index.
        /// &lt;/summary&gt;
        public int BitIndex
        {
            get
            {
                return bitIndex;
            }
            set
            {
                if (value &lt; 0 || (value + 7) / 8 &gt; buffer.Count) throw new ArgumentOutOfRangeException("Unable to set the bit index outside of the buffer size.");
                bitIndex = value;
            }
        }

        /// &lt;summary&gt;
        /// Sets the bit index to the start of the data section.
        /// &lt;/summary&gt;
        public void ResetBitIndex()
        {
            if (maxBitIndex &lt; 32) throw new InvalidOperationException("Unable to set the bit index over the max bit index.");
            bitIndex = 32;
        }

        /// &lt;summary&gt;
        /// Gets or Sets the max bit index.
        /// &lt;/summary&gt;
        public int MaxBitIndex
        {
            set
            {
                if (value &lt; 0 || (value + 7) / 8 &gt; buffer.Count) throw new ArgumentOutOfRangeException("Unable to set the max bit index outside of the buffer size.");
                maxBitIndex = value;
            }
        }

        public int BufferLength
        {
            get
            {
                return buffer.Count;
            }
        }

        /// &lt;summary&gt;
        /// Returns the buffer as an array of bytes.
        /// &lt;/summary&gt;
        public byte[] Buffer
        {
            get
            {
                return buffer.ToArray();
            }
        }

        public int HeaderSize
        {
            get
            {
                return 4;
            }
        }

        /// &lt;summary&gt;
        /// Returns a string of 0s and 1s representing the bits in the buffer. Good for debugging.
        /// Places a space between nibbles and two spaces between bytes.
        /// &lt;/summary&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public string Trace()
        {
            string s = string.Empty;
            for (int copyBits = 0; copyBits &lt; buffer.Count * 8; ++copyBits)
            {
                s += ((buffer[copyBits / 8] &gt;&gt; (7 - copyBits % 8)) &amp; 0x1) == 0 ? "0" : "1";
                if ((copyBits + 1) % 4 == 0 &amp;&amp; copyBits != 0)
                {
                    s += " ";
                    if ((copyBits + 1) % 8 == 0)
                    {
                        s += " ";
                    }
                }
            }
            return s;
        }

        /// &lt;summary&gt;
        /// Rounds the bitIndex up to a byte.
        /// &lt;/summary&gt;
        public void RoundUpToByte()
        {
            bitIndex = (bitIndex + 7) / 8 * 8;
        }

        /// &lt;summary&gt;
        ///
        /// &lt;/summary&gt;
        /// &lt;returns&gt;true if 32 bits exist in the buffer&lt;/returns&gt;
        public bool HasHeader()
        {
            return buffer.Count &gt;= 4;
        }

        /// &lt;summary&gt;
        /// Reads the length in bits stored in the header.
        /// &lt;/summary&gt;
        public void ReadHeader()
        {
            int oldBitIndex = bitIndex;
            bitIndex = 0;
            maxBitIndex = 32;
            uint length;
            if (ReadUInt32(out length))
            {
                if (length &gt; int.MaxValue)
                {
                    maxBitIndex = int.MaxValue;
                }
                else
                {
                    maxBitIndex = (int)length;
                }
            }
            bitIndex = oldBitIndex;
        }

        /// &lt;summary&gt;
        /// Writes a begin packet header of 32 bits.
        /// &lt;/summary&gt;
        internal void BeginPacket()
        {
            WriteUInt32(0);
        }

        /// &lt;summary&gt;
        /// Writes maxBitIndex to the packet header created with BeginPacket.
        /// &lt;/summary&gt;
        internal void EndPacket()
        {
            int oldBitIndex = bitIndex;
            bitIndex = 0;
            WriteUInt32((uint)maxBitIndex);
            bitIndex = oldBitIndex;
        }

        /// &lt;summary&gt;
        /// Appends a byte directly to the end of the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;&lt;/param&gt;
        public void AppendByte(byte value)
        {
            buffer.Add(value);
            bitIndex += 8;
        }

        /// &lt;summary&gt;
        /// Determines if the packet has read in all the data defined by the maxBitIndex.
        /// &lt;/summary&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public bool HasData()
        {
            return bitIndex &gt;= maxBitIndex;
        }

        /// &lt;summary&gt;
        /// Rollback as if the last read didn't occur.
        /// &lt;/summary&gt;
        public void RollbackRead()
        {
            if (previousBitIndex == -1) throw new InvalidOperationException("A read method must be called successfully first");
            bitIndex = previousBitIndex;
            previousBitIndex = -1;
        }

        public void ClearBits(int bits)
        {
            if (bitIndex % 8 + bits - 1 &lt; 8)
            {
                byte mask = 0xFF;
                for (int bitItr = bitIndex; bitItr &lt; bitIndex + bits; ++bitItr)
                {
                    mask ^= (byte)(1 &lt;&lt; 7 - bitItr % 8);
                }
                buffer[bitIndex / 8] &amp;= mask;
            }
            else if (bitIndex % 8 + bits - 1 &lt; 16)
            {
                int offset = 8 - bitIndex % 8;
                buffer[bitIndex / 8] &gt;&gt;= offset;
                buffer[bitIndex / 8] &lt;&lt;= offset;
                offset = bits - (8 - bitIndex % 8);
                buffer[bitIndex / 8 + 1] &lt;&lt;= offset;
                buffer[bitIndex / 8 + 1] &gt;&gt;= offset;
            }
            else
            {
                int offset = 8 - bitIndex % 8;
                buffer[bitIndex / 8] &gt;&gt;= offset;
                buffer[bitIndex / 8] &lt;&lt;= offset;
                for (int bitItr = bitIndex + 8 - bitIndex % 8; bitItr &lt; (bitIndex + bits - 1) / 8 * 8; bitItr += 8)
                {
                    buffer[bitItr / 8] = 0;
                }
                offset = bitIndex + bits - (bitIndex + bits - 1) / 8 * 8;
                buffer[(bitIndex + bits - 1) / 8] &lt;&lt;= offset;
                buffer[(bitIndex + bits - 1) / 8] &gt;&gt;= offset;
            }
        }

        // Write Methods

        /// &lt;summary&gt;
        /// Writes an Event ID.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The event ID normally stored in an enumeration.&lt;/param&gt;
        public void WriteEventID(uint value)
        {
            WriteVariableWidthUInt(value, 6);
        }

        /// &lt;summary&gt;
        /// Writes a single bit either 0 or 1 into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The boolean value to write.&lt;/param&gt;
        public void WriteBool(bool value)
        {
            ExpandBuffer(1);
            if (value) buffer[bitIndex / 8] |= (byte)(1 &lt;&lt; (7 - bitIndex % 8));
            ++bitIndex;
        }

        /// &lt;summary&gt;
        /// Writes an 8 bit unsigned byte into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned byte value to write.&lt;/param&gt;
        public void WriteByte(byte value)
        {
            ExpandBuffer(8);
            int offset = bitIndex % 8;
            buffer[bitIndex / 8] |= (byte)(value &gt;&gt; offset);
            if (offset != 0)
            {
                buffer[bitIndex / 8 + 1] |= (byte)(value &lt;&lt; 8 - offset);
            }
            bitIndex += 8;
        }

        /// &lt;summary&gt;
        /// Writes an 8 bit signed byte into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed byte value to write.&lt;/param&gt;
        public void WriteSByte(sbyte value)
        {
            WriteByte((byte)value);
        }

        /// &lt;summary&gt;
        /// Writes a 16 bit unsigned short into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned short value to write.&lt;/param&gt;
        public void WriteUInt16(ushort value)
        {
            ExpandBuffer(16);
            int offset = bitIndex % 8;
            buffer[bitIndex / 8] |= (byte)(value &gt;&gt; 8 + offset);
            buffer[bitIndex / 8 + 1] |= (byte)(value &gt;&gt; offset);
            if (offset != 0)
            {
                buffer[bitIndex / 8 + 2] |= (byte)(value &lt;&lt; 8 - offset);
            }
            bitIndex += 16;
        }

        /// &lt;summary&gt;
        /// Writes a 16 bit signed short into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed short value to write.&lt;/param&gt;
        public void WriteInt16(short value)
        {
            WriteUInt16((ushort)value);
        }

        /// &lt;summary&gt;
        /// Writes a 32 bit unsigned integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned integer value to write.&lt;/param&gt;
        public void WriteUInt32(uint value)
        {
            ExpandBuffer(32);
            int offset = bitIndex % 8;
            buffer[bitIndex / 8] |= (byte)(value &gt;&gt; 24 + offset);
            buffer[bitIndex / 8 + 1] |= (byte)(value &gt;&gt; 16 + offset);
            buffer[bitIndex / 8 + 2] |= (byte)(value &gt;&gt; 8 + offset);
            buffer[bitIndex / 8 + 3] |= (byte)(value &gt;&gt; offset);
            if (offset != 0)
            {
                buffer[bitIndex / 8 + 4] |= (byte)(value &lt;&lt; 8 - offset);
            }
            bitIndex += 32;
        }

        /// &lt;summary&gt;
        /// Writes a 32 bit signed integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed integer value to write.&lt;/param&gt;
        public void WriteInt32(int value)
        {
            WriteUInt32((uint)value);
        }

        /// &lt;summary&gt;
        /// Writes a 64 bit unsigned integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned integer value to write.&lt;/param&gt;
        public void WriteUInt64(ulong value)
        {
            ExpandBuffer(64);
            int offset = bitIndex % 8;
            buffer[bitIndex / 8] |= (byte)(value &gt;&gt; 56 + offset);
            buffer[bitIndex / 8 + 1] |= (byte)(value &gt;&gt; 48 + offset);
            buffer[bitIndex / 8 + 2] |= (byte)(value &gt;&gt; 32 + offset);
            buffer[bitIndex / 8 + 3] |= (byte)(value &gt;&gt; 24 + offset);
            buffer[bitIndex / 8 + 4] |= (byte)(value &gt;&gt; 16 + offset);
            buffer[bitIndex / 8 + 5] |= (byte)(value &gt;&gt; 8 + offset);
            buffer[bitIndex / 8 + 6] |= (byte)(value &gt;&gt; offset);
            if (offset != 0)
            {
                buffer[bitIndex / 8 + 7] |= (byte)(value &lt;&lt; 8 - offset);
            }
            bitIndex += 64;
        }

        /// &lt;summary&gt;
        /// Writes a 64 bit signed integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed integer value to write.&lt;/param&gt;
        public void WriteInt64(long value)
        {
            WriteUInt64((ulong)value);
        }

        /// &lt;summary&gt;
        /// Writes an n bit unsigned integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned integer value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits to use.&lt;/param&gt;
        public void WriteUInt(uint value, int bits)
        {
            if (bits &lt; 1 || bits &gt; 32) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32].");
            if (bits != 32 &amp;&amp; value &gt; (0x1 &lt;&lt; bits) - 1) throw new ArgumentOutOfRangeException("Value does not fit into " + bits.ToString() + " bits.");

            ExpandBuffer(bits);

            value &lt;&lt;= 32 - bits;

            int offset = bitIndex % 8;
            buffer[bitIndex / 8] |= (byte)(value &gt;&gt; 24 + offset);
            if (offset + bits &gt; 8)
            {
                buffer[bitIndex / 8 + 1] |= (byte)(value &gt;&gt; 16 + offset);
                if (offset + bits &gt; 16)
                {
                    buffer[bitIndex / 8 + 2] |= (byte)(value &gt;&gt; 8 + offset);
                    if (offset + bits &gt; 24)
                    {
                        buffer[bitIndex / 8 + 3] |= (byte)(value &gt;&gt; offset);
                        if (offset + bits &gt; 32)
                        {
                            buffer[bitIndex / 8 + 4] |= (byte)(value &lt;&lt; 8 - offset);
                        }
                    }
                }
            }
            bitIndex += bits;
        }

        /// &lt;summary&gt;
        /// Writes an n bit unsigned integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned integer value to write.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        public void WriteUInt(uint value, uint min, uint max)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (value &lt; min || value &gt; max) throw new ArgumentOutOfRangeException("The value must be on the interval [min, max]");

            uint valueBase = max - min + 1;
            // Log2
            var bits = 32;
            if (valueBase != 0)
            {
                int left = 0;
                int right = 32;
                for (int i = 0; i &lt; 5; ++i)
                {
                    if (valueBase &gt;&gt; (32 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                bits = 32 - left;
            }
            WriteUInt(value - min, bits);
        }

        /// &lt;summary&gt;
        /// Writes an n bit unsigned integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned integer value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits to use.&lt;/param&gt;
        public void WriteUInt(ulong value, int bits)
        {
            if (bits &lt; 1 || bits &gt; 64) throw new ArgumentOutOfRangeException("bits must be in the range (0, 64].");
            if (bits != 64 &amp;&amp; value &gt; ((ulong)0x1 &lt;&lt; bits) - 1) throw new ArgumentOutOfRangeException("Value does not fit into " + bits.ToString() + " bits.");

            ExpandBuffer(bits);

            value &lt;&lt;= 64 - bits;

            int offset = bitIndex % 8;
            buffer[bitIndex / 8] |= (byte)(value &gt;&gt; 56 + offset);
            if (offset + bits &gt; 8)
            {
                buffer[bitIndex / 8 + 1] |= (byte)(value &gt;&gt; 48 + offset);
                if (offset + bits &gt; 16)
                {
                    buffer[bitIndex / 8 + 2] |= (byte)(value &gt;&gt; 40 + offset);
                    if (offset + bits &gt; 24)
                    {
                        buffer[bitIndex / 8 + 3] |= (byte)(value &gt;&gt; 32 + offset);
                        if (offset + bits &gt; 32)
                        {
                            buffer[bitIndex / 8 + 4] |= (byte)(value &gt;&gt; 24 + offset);
                            if (offset + bits &gt; 40)
                            {
                                buffer[bitIndex / 8 + 5] |= (byte)(value &gt;&gt; 16 + offset);
                                if (offset + bits &gt; 48)
                                {
                                    buffer[bitIndex / 8 + 6] |= (byte)(value &gt;&gt; 8 + offset);
                                    if (offset + bits &gt; 56)
                                    {
                                        buffer[bitIndex / 8 + 7] |= (byte)(value &gt;&gt; offset);
                                        if (offset + bits &gt; 64)
                                        {
                                            buffer[bitIndex / 8 + 8] |= (byte)(value &lt;&lt; 8 - offset);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            bitIndex += bits;
        }

        /// &lt;summary&gt;
        /// Writes an n bit unsigned integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned integer value to write.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        public void WriteUInt(ulong value, ulong min, ulong max)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (value &lt; min || value &gt; max) throw new ArgumentOutOfRangeException("The value must be on the interval [min, max]");

            ulong valueBase = max - min + 1;
            // Log2
            var bits = 64;
            if (valueBase != 0)
            {
                int left = 0;
                int right = 64;
                for (int i = 0; i &lt; 6; ++i)
                {
                    if (valueBase &gt;&gt; (64 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                bits = 64 - left;
            }
            WriteUInt(value - min, bits);
        }

        /// &lt;summary&gt;
        /// Writes an n bit signed integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed integer value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits to use.&lt;/param&gt;
        public void WriteInt(int value, int bits)
        {
            if (bits &lt; 1 || bits &gt; 32) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32].");
            if (bits != 32 &amp;&amp; (value &lt; -(0x1 &lt;&lt; (bits - 1)) || value &gt;= 0x1 &lt;&lt; (bits - 1))) throw new ArgumentOutOfRangeException("Value does not fit into " + bits.ToString() + " bits.");

            ExpandBuffer(bits);

            value &lt;&lt;= 32 - bits;
            uint uvalue = (uint)value;

            int offset = bitIndex % 8;
            buffer[bitIndex / 8] |= (byte)(uvalue &gt;&gt; 24 + offset);
            if (offset + bits &gt; 8)
            {
                buffer[bitIndex / 8 + 1] |= (byte)(uvalue &gt;&gt; 16 + offset);
                if (offset + bits &gt; 16)
                {
                    buffer[bitIndex / 8 + 2] |= (byte)(uvalue &gt;&gt; 8 + offset);
                    if (offset + bits &gt; 24)
                    {
                        buffer[bitIndex / 8 + 3] |= (byte)(uvalue &gt;&gt; offset);
                        if (offset + bits &gt; 32)
                        {
                            buffer[bitIndex / 8 + 4] |= (byte)(uvalue &lt;&lt; 8 - offset);
                        }
                    }
                }
            }
            bitIndex += bits;
        }

        /// &lt;summary&gt;
        /// Writes an n bit signed integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed integer value to write.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        public void WriteInt(int value, int min, int max)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (value &lt; min || value &gt; max) throw new ArgumentOutOfRangeException("The value must be on the interval [min, max]");

            uint valueBase = (uint)(max - min + 1);
            // Log2
            var bits = 32;
            if (valueBase != 0)
            {
                int left = 0;
                int right = 32;
                for (int i = 0; i &lt; 5; ++i)
                {
                    if (valueBase &gt;&gt; (32 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                bits = 32 - left;
            }
            WriteInt(value - min, bits);
        }

        /// &lt;summary&gt;
        /// Writes an n bit signed integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed integer value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits to use.&lt;/param&gt;
        public void WriteInt(long value, int bits)
        {
            if (bits &lt; 1 || bits &gt; 64) throw new ArgumentOutOfRangeException("bits must be in the range (0, 64].");
            if (bits != 64 &amp;&amp; (value &lt; -((long)0x1 &lt;&lt; (bits - 1)) || value &gt;= (long)0x1 &lt;&lt; (bits - 1))) throw new ArgumentOutOfRangeException("Value does not fit into " + bits.ToString() + " bits.");

            ExpandBuffer(bits);

            value &lt;&lt;= 64 - bits;
            ulong uvalue = (ulong)value;

            int offset = bitIndex % 8;
            buffer[bitIndex / 8] |= (byte)(uvalue &gt;&gt; 56 + offset);
            if (offset + bits &gt; 8)
            {
                buffer[bitIndex / 8 + 1] |= (byte)(uvalue &gt;&gt; 48 + offset);
                if (offset + bits &gt; 16)
                {
                    buffer[bitIndex / 8 + 2] |= (byte)(uvalue &gt;&gt; 40 + offset);
                    if (offset + bits &gt; 24)
                    {
                        buffer[bitIndex / 8 + 3] |= (byte)(uvalue &gt;&gt; 32 + offset);
                        if (offset + bits &gt; 32)
                        {
                            buffer[bitIndex / 8 + 4] |= (byte)(uvalue &gt;&gt; 24 + offset);
                            if (offset + bits &gt; 40)
                            {
                                buffer[bitIndex / 8 + 5] |= (byte)(uvalue &gt;&gt; 16 + offset);
                                if (offset + bits &gt; 48)
                                {
                                    buffer[bitIndex / 8 + 6] |= (byte)(uvalue &gt;&gt; 8 + offset);
                                    if (offset + bits &gt; 56)
                                    {
                                        buffer[bitIndex / 8 + 7] |= (byte)(uvalue &gt;&gt; offset);
                                        if (offset + bits &gt; 64)
                                        {
                                            buffer[bitIndex / 8 + 8] |= (byte)(uvalue &lt;&lt; 8 - offset);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            bitIndex += bits;
        }

        /// &lt;summary&gt;
        /// Writes an n bit signed integer into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed integer value to write.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        public void WriteInt(long value, long min, long max)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (value &lt; min || value &gt; max) throw new ArgumentOutOfRangeException("The value must be on the interval [min, max]");

            ulong valueBase = (ulong)(max - min + 1);
            // Log2
            var bits = 64;
            if (valueBase != 0)
            {
                int left = 0;
                int right = 64;
                for (int i = 0; i &lt; 6; ++i)
                {
                    if (valueBase &gt;&gt; (64 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                bits = 64 - left;
            }
            WriteInt(value - min, bits);
        }

        /// &lt;summary&gt;
        /// Writes a 32 bit single into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The single value to write.&lt;/param&gt;
        public void WriteSingle(float value)
        {
            WriteUInt32(BitConverter.ToUInt32(BitConverter.GetBytes(value), 0));
        }

        /// &lt;summary&gt;
        /// Writes a 64 bit double into the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The double value to write.&lt;/param&gt;
        public void WriteDouble(double value)
        {
            byte[] bytes = BitConverter.GetBytes(value);
            WriteUInt32(BitConverter.ToUInt32(bytes, 0));
            WriteUInt32(BitConverter.ToUInt32(bytes, 4));
        }

        /// &lt;summary&gt;
        /// Writes an integer using a variable width encoding of bits. Choose a bits value that represents the number of bits to hold the average value.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned integer value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits to use for the sequence.&lt;/param&gt;
        public void WriteVariableWidthUInt(uint value, int bits = 4)
        {
            if (bits &lt; 1 || bits &gt; 32) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32].");
            int shift = bits;
            // Stop when our value can fit inside
            for (; shift &lt; 32 &amp;&amp; value &gt;= (0x1 &lt;&lt; shift); shift += bits)
            {
                WriteBool(true); // Write a 1 for a continuation bit signifying one more interval is needed
            }
            if (shift &lt; 32)
            {
                WriteBool(false); // Write a 0 for a continuation bit signifying the end
            }
            WriteUInt(value, shift &gt;= 32 ? 32 : shift);
        }

        /// &lt;summary&gt;
        /// Writes an integer using a variable width encoding of bits. Choose a bits value that represents the number of bits to hold the average value.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The unsigned integer value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits to use for the sequence.&lt;/param&gt;
        public void WriteVariableWidthUInt(ulong value, int bits = 4)
        {
            if (bits &lt; 1 || bits &gt; 64) throw new ArgumentOutOfRangeException("bits must be in the range (0, 64].");
            int shift = bits;
            // Stop when our value can fit inside
            for (; shift &lt; 64 &amp;&amp; value &gt;= (ulong)(0x1 &lt;&lt; shift); shift += bits)
            {
                WriteBool(true); // Write a 1 for a continuation bit signifying one more interval is needed
            }
            if (shift &lt; 64)
            {
                WriteBool(false); // Write a 0 for a continuation bit signifying the end
            }
            WriteUInt(value, shift &gt;= 64 ? 64 : shift);
        }

        /// &lt;summary&gt;
        /// Writes an integer using a variable length of bits. Choose a bits value that represents the number of bits to hold the average value.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed integer value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits to use for the sequence.&lt;/param&gt;
        public void WriteVariableWidthInt(int value, int bits = 4)
        {
            if (bits &lt; 1 || bits &gt; 32) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32].");
            int shift = bits;
            // Stop when our value can fit inside
            for (; shift &lt; 32 &amp;&amp; (value &lt; -(0x1 &lt;&lt; (shift - 1)) || value &gt;= 0x1 &lt;&lt; (shift - 1)); shift += bits)
            {
                WriteBool(true); // Write a 1 for a continuation bit signifying one more interval is needed
            }
            if (shift &lt; 32)
            {
                WriteBool(false); // Write a 0 for a continuation bit signifying the end
            }
            WriteInt(value, shift &gt;= 32 ? 32 : shift);
        }

        /// &lt;summary&gt;
        /// Writes an integer using a variable length of bits. Choose a bits value that represents the number of bits to hold the average value.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The signed integer value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits to use for the sequence.&lt;/param&gt;
        public void WriteVariableWidthInt(long value, int bits = 4)
        {
            if (bits &lt; 1 || bits &gt; 64) throw new ArgumentOutOfRangeException("bits must be in the range (0, 64].");
            int shift = bits;
            // Stop when our value can fit inside
            for (; shift &lt; 64 &amp;&amp; (value &lt; -(0x1 &lt;&lt; (shift - 1)) || value &gt;= 0x1 &lt;&lt; (shift - 1)); shift += bits)
            {
                WriteBool(true); // Write a 1 for a continuation bit signifying one more interval is needed
            }
            if (shift &lt; 64)
            {
                WriteBool(false); // Write a 0 for a continuation bit signifying the end
            }
            WriteInt(value, shift &gt;= 64 ? 64 : shift);
        }

        /// &lt;summary&gt;
        /// Writes an array of unsigned integers in a given range defining a base.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The array of unsigned integers to write.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        public void WriteArrayUInt32(uint[] value, int min, int max)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            ulong valueBase = (ulong)(max - min + 1);
            var sum = new List&lt;ulong&gt;();
            var valueBasePow = new List&lt;ulong&gt;();
            valueBasePow.Add(1);
            for (var i = 0; i &lt; value.Length; ++i)
            {
                // sum += arrayBasePow * array[i];
                ulong multiplyCarry = 0;
                ulong addCarry = 0;
                for (var j = 0; j &lt; valueBasePow.Count || multiplyCarry != 0 || j &lt; sum.Count || addCarry != 0; ++j)
                {
                    if (j &gt;= sum.Count)
                    {
                        sum.Add(0);
                    }

                    ulong temp = 0;
                    ulong product = 0;
                    if (j &lt; valueBasePow.Count)
                    {
                        product = (ulong)(value[i] - min) * valueBasePow[j];
                    }
                    temp += product + multiplyCarry;
                    multiplyCarry = temp &gt;&gt; 32;
                    temp &amp;= 0xFFFFFFFF;

                    sum[j] += temp + addCarry;
                    addCarry = sum[j] &gt;&gt; 32;
                    sum[j] &amp;= 0xFFFFFFFF;
                }
                // arrayBasePow *= arrayBase;
                multiplyCarry = 0;
                for (var j = 0; j &lt; valueBasePow.Count || multiplyCarry != 0; ++j)
                {
                    if (j &gt;= valueBasePow.Count)
                    {
                        valueBasePow.Add(0);
                    }
                    ulong product = 0;
                    if (j &lt; valueBasePow.Count)
                    {
                        product = valueBase * valueBasePow[j];
                    }
                    valueBasePow[j] = product + multiplyCarry;
                    multiplyCarry = valueBasePow[j] &gt;&gt; 32;
                    valueBasePow[j] &amp;= 0xFFFFFFFF;
                }
            }

            for (var i = sum.Count - 1; i &gt; 0 &amp;&amp; sum[i] == 0; --i)
            {
                sum.RemoveAt(sum.Count - 1);
            }

            // Log2
            int numberOfBits = 0;
            if (!(valueBasePow.Count == 1 &amp;&amp; valueBasePow[0] == 0))
            {
                int left = 0;
                int right = 32;
                for (int i = 0; i &lt; 5; ++i)
                {
                    if (valueBasePow[valueBasePow.Count - 1] &gt;&gt; (32 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                numberOfBits = (valueBasePow.Count - 1) * 32 + (32 - left);
            }

            for (int copyBits = 0; copyBits &lt; numberOfBits; copyBits += 32)
            {
                WriteUInt((uint)sum[copyBits / 32], numberOfBits - copyBits &gt; 32 ? 32 : numberOfBits - copyBits);
            }
        }

        /// &lt;summary&gt;
        /// Writes an array of signed integers in a given range defining a base.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The array of signed integers to write.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        public void WriteArrayInt32(int[] value, int min, int max)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            var uValue = new uint[value.Length];
            for (var i = 0; i &lt; value.Length; ++i)
            {
                uValue[i] = (uint)(value[i] - min);
            }
            WriteArrayUInt32(uValue, 0, max - min);
        }

        /// &lt;summary&gt;
        /// Writes an array of singles in a given range converted to a given integral base.
        /// Creates a value for the ratio: value / (valueBase - 1) in relationship to value / (max - min).
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The array of singles to write.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="valueBase"&gt;The base to convert the singles to.&lt;/param&gt;
        public void WriteArraySingle(float[] value, float min, float max, int valueBase)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            var uValue = new uint[value.Length];
            if (min &lt; 0 &amp;&amp; max &gt; 0)
            {
                for (var i = 0; i &lt; value.Length; ++i)
                {
                    uValue[i] = value[i] == 0 ? 0 : (uint)Math.Round((value[i] - min) / (max - min) * (valueBase - 2)) + 1;
                }
            }
            else
            {
                for (var i = 0; i &lt; value.Length; ++i)
                {
                    uValue[i] = (uint)Math.Round((value[i] - min) / (max - min) * (valueBase - 1));
                }
            }
            WriteArrayUInt32(uValue, 0, valueBase - 1);
        }

        /// &lt;summary&gt;
        /// Writes an array of doubles in a given range converted to a given integral base.
        /// Creates a value for the ratio: value / (valueBase - 1) in relationship to value / (max - min).
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The array of doubles to write.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="valueBase"&gt;The base to convert the doubles to.&lt;/param&gt;
        public void WriteArrayDouble(double[] value, double min, double max, int valueBase)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            var uValue = new uint[value.Length];
            if (min &lt; 0 &amp;&amp; max &gt; 0)
            {
                for (var i = 0; i &lt; value.Length; ++i)
                {
                    uValue[i] = value[i] == 0 ? 0 : (uint)Math.Round((value[i] - min) / (max - min) * (valueBase - 2)) + 1;
                }
            }
            else
            {
                for (var i = 0; i &lt; value.Length; ++i)
                {
                    uValue[i] = (uint)Math.Round((value[i] - min) / (max - min) * (valueBase - 1));
                }
            }
            WriteArrayUInt32(uValue, 0, valueBase - 1);
        }

        /// &lt;summary&gt;
        /// Creates a value for the ratio: value / (2 ^ bitResolution - 1) in relationship to value / (max - min).
        /// This allows a floating point to have a resolution.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The floating point value in the range.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="bitResolution"&gt;The number of bits to use for the ratio.&lt;/param&gt;
        public void WriteCustomResolutionSingle(float value, float min, float max, int bitResolution)
        {
            if (bitResolution &lt; 1 || bitResolution &gt; 31) throw new ArgumentOutOfRangeException("bitResolution must be in the range (0, 32).");
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (value &lt; min || value &gt; max) throw new ArgumentOutOfRangeException("The value must be on the interval [min, max]");
            uint uValue;
            if (min &lt; 0 &amp;&amp; max &gt; 0)
            {
                uValue = value == 0 ? 0 : (uint)Math.Round((value - min) / (max - min) * (float)((0x1 &lt;&lt; bitResolution) - 2)) + 1;
            }
            else
            {
                uValue = (uint)Math.Round((value - min) / (max - min) * (float)((0x1 &lt;&lt; bitResolution) - 1));
            }
            WriteUInt(uValue, bitResolution);
        }

        /// &lt;summary&gt;
        /// Creates a value for the ratio: value / (2 ^ bitResolution - 1) in relationship to value / (max - min).
        /// This allows a floating point to have a resolution.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The double value in the range.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="bitResolution"&gt;The number of bits to use for the ratio.&lt;/param&gt;
        public void WriteCustomResolutionDouble(double value, double min, double max, int bitResolution)
        {
            if (bitResolution &lt; 1 || bitResolution &gt; 31) throw new ArgumentOutOfRangeException("bitResolution must be in the range (0, 32).");
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (value &lt; min || value &gt; max) throw new ArgumentOutOfRangeException("The value must be on the interval [min, max]");
            uint uValue;
            if (min &lt; 0 &amp;&amp; max &gt; 0)
            {
                uValue = value == 0 ? 0 : (uint)Math.Round((value - min) / (max - min) * (double)((0x1 &lt;&lt; bitResolution) - 2)) + 1;
            }
            else
            {
                uValue = (uint)Math.Round((value - min) / (max - min) * (double)((0x1 &lt;&lt; bitResolution) - 1));
            }
            WriteUInt(uValue, bitResolution);
        }

        /// &lt;summary&gt;
        /// Writes the length of the string using WriteVariableWidthUInt and then writes a boolean, true for unicode, false for ascii.
        /// ASCII uses a compression step using either 6 or 7 bits per character.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The string value to write.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits for the length written using an unsigned variable-width integer.&lt;/param&gt;
        public void WriteString(string value, int bits = 4)
        {
            if (bits &lt; 1 || bits &gt; 31) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32).");

            var asciiBytes = Encoding.ASCII.GetBytes(value);
            uint size = (uint)asciiBytes.Length;
            WriteVariableWidthUInt(size, bits);
            foreach (byte asciiByte in asciiBytes)
            {
                WriteByte(asciiByte);
            }
        }

        /// &lt;summary&gt;
        /// Appends a binary packet to the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The binary packet to write.&lt;/param&gt;
        public void WriteBinaryPacket(Packet value)
        {
            int oldBitIndex = value.bitIndex;
            value.bitIndex = 0;
            int valueMaxBitIndex = value.maxBitIndex;
            WriteVariableWidthUInt((uint)valueMaxBitIndex);
            for (int copyBits = 0; copyBits &lt; valueMaxBitIndex; copyBits += 32)
            {
                uint uValue;
                value.ReadUInt(out uValue, valueMaxBitIndex - copyBits &gt; 32 ? 32 : valueMaxBitIndex - copyBits);
                WriteUInt(uValue, valueMaxBitIndex - copyBits &gt; 32 ? 32 : valueMaxBitIndex - copyBits);
            }
            bitIndex += (int)valueMaxBitIndex;
            value.bitIndex = oldBitIndex;
        }

        //READ METHODS

        /// &lt;summary&gt;
        /// Reads an Event ID.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The event ID normally stored in an enumeration.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadEventID(out uint value, bool nestedRead = false)
        {
            return ReadVariableWidthUInt(out value, 6);
        }

        /// &lt;summary&gt;
        /// Reads one bit from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Boolean.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadBool(out bool value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = false;
            if ((bitIndex + 1 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            value = ((buffer[bitIndex / 8] &gt;&gt; (7 - bitIndex % 8)) &amp; 0x1) == 1;
            ++bitIndex;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an 8 bits unsigned byte from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Byte.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadByte(out byte value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 8 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            int offset = bitIndex % 8;
            value |= (byte)(buffer[bitIndex / 8] &lt;&lt; offset);
            if (offset != 0)
            {
                value |= (byte)(buffer[bitIndex / 8 + 1] &gt;&gt; 8 - offset);
            }
            bitIndex += 8;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an 8 bits signed byte from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Byte.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadSByte(out sbyte value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 8 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            int offset = bitIndex % 8;
            value |= (sbyte)(buffer[bitIndex / 8] &lt;&lt; offset);
            if (offset != 0)
            {
                value |= (sbyte)(buffer[bitIndex / 8 + 1] &gt;&gt; 8 - offset);
            }
            bitIndex += 8;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a 16 bit unsigned short from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Short.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadUInt16(out ushort value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 16 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            int offset = bitIndex % 8;
            value |= (ushort)(buffer[bitIndex / 8] &lt;&lt; 8 + offset);
            value |= (ushort)(buffer[bitIndex / 8 + 1] &lt;&lt; offset);
            if (offset != 0)
            {
                value |= (ushort)(buffer[bitIndex / 8 + 2] &gt;&gt; 8 - offset);
            }
            bitIndex += 16;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a 16 bit signed short from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Short.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadInt16(out short value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 16 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            int offset = bitIndex % 8;
            value |= (short)(buffer[bitIndex / 8] &lt;&lt; 8 + offset);
            value |= (short)(buffer[bitIndex / 8 + 1] &lt;&lt; offset);
            if (offset != 0)
            {
                value |= (short)(buffer[bitIndex / 8 + 2] &gt;&gt; 8 - offset);
            }
            bitIndex += 16;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a 32 bit unsigned integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Integer.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadUInt32(out uint value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 32 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            int offset = bitIndex % 8;
            value |= (uint)(buffer[bitIndex / 8] &lt;&lt; 24 + offset);
            value |= (uint)(buffer[bitIndex / 8 + 1] &lt;&lt; 16 + offset);
            value |= (uint)(buffer[bitIndex / 8 + 2] &lt;&lt; 8 + offset);
            value |= (uint)(buffer[bitIndex / 8 + 3] &lt;&lt; offset);
            if (offset != 0)
            {
                value |= (uint)(buffer[bitIndex / 8 + 4] &gt;&gt; 8 - offset);
            }
            bitIndex += 32;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a 32 bit signed integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Integer.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadInt32(out int value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 32 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            int offset = bitIndex % 8;
            value |= (int)(buffer[bitIndex / 8] &lt;&lt; 24 + offset);
            value |= (int)(buffer[bitIndex / 8 + 1] &lt;&lt; 16 + offset);
            value |= (int)(buffer[bitIndex / 8 + 2] &lt;&lt; 8 + offset);
            value |= (int)(buffer[bitIndex / 8 + 3] &lt;&lt; offset);
            if (offset != 0)
            {
                value |= (int)(buffer[bitIndex / 8 + 4] &gt;&gt; 8 - offset);
            }
            bitIndex += 32;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a 64 bit unsigned integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Long.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadUInt64(out ulong value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 64 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            int offset = bitIndex % 8;
            value |= (ulong)(buffer[bitIndex / 8]) &lt;&lt; 56 + offset;
            value |= (ulong)(buffer[bitIndex / 8 + 1]) &lt;&lt; 48 + offset;
            value |= (ulong)(buffer[bitIndex / 8 + 2]) &lt;&lt; 40 + offset;
            value |= (ulong)(buffer[bitIndex / 8 + 3]) &lt;&lt; 32 + offset;
            value |= (ulong)(buffer[bitIndex / 8 + 4]) &lt;&lt; 24 + offset;
            value |= (ulong)(buffer[bitIndex / 8 + 5]) &lt;&lt; 16 + offset;
            value |= (ulong)(buffer[bitIndex / 8 + 6]) &lt;&lt; 8 + offset;
            value |= (ulong)(buffer[bitIndex / 8 + 7]) &lt;&lt; offset;
            if (offset != 0)
            {
                value |= (ulong)(buffer[bitIndex / 8 + 8]) &gt;&gt; 8 - offset;
            }
            bitIndex += 64;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a 64 bit signed integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Long.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadInt64(out long value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 64 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            int offset = bitIndex % 8;
            value |= (long)(buffer[bitIndex / 8]) &lt;&lt; 56 + offset;
            value |= (long)(buffer[bitIndex / 8 + 1]) &lt;&lt; 48 + offset;
            value |= (long)(buffer[bitIndex / 8 + 2]) &lt;&lt; 40 + offset;
            value |= (long)(buffer[bitIndex / 8 + 3]) &lt;&lt; 32 + offset;
            value |= (long)(buffer[bitIndex / 8 + 4]) &lt;&lt; 24 + offset;
            value |= (long)(buffer[bitIndex / 8 + 5]) &lt;&lt; 16 + offset;
            value |= (long)(buffer[bitIndex / 8 + 6]) &lt;&lt; 8 + offset;
            value |= (long)(buffer[bitIndex / 8 + 7]) &lt;&lt; offset;
            if (offset != 0)
            {
                value |= (long)(buffer[bitIndex / 8 + 8]) &gt;&gt; 8 - offset;
            }
            bitIndex += 64;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an n bit unsigned integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Integer.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits used to write.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadUInt(out uint value, int bits, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 32) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32].");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + bits + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }

            int offset = bitIndex % 8;
            value = (uint)buffer[bitIndex / 8] &lt;&lt; 24 + offset;
            if (offset + bits &gt; 8)
            {
                value |= (uint)buffer[bitIndex / 8 + 1] &lt;&lt; 16 + offset;
                if (offset + bits &gt; 16)
                {
                    value |= (uint)buffer[bitIndex / 8 + 2] &lt;&lt; 8 + offset;
                    if (offset + bits &gt; 24)
                    {
                        value |= (uint)buffer[bitIndex / 8 + 3] &lt;&lt; offset;
                        if (offset + bits &gt; 32)
                        {
                            value |= (uint)buffer[bitIndex / 8 + 4] &gt;&gt; 8 - offset;
                        }
                    }
                }
            }

            value &gt;&gt;= 32 - bits;
            bitIndex += bits;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an n bit unsigned integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Integer.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadUInt(out uint value, uint min, uint max, bool nestedRead = false)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");

            if (!nestedRead) previousBitIndex = bitIndex;
            uint valueBase = max - min + 1;
            // Log2
            var bits = 32;
            if (valueBase != 0)
            {
                int left = 0;
                int right = 32;
                for (int i = 0; i &lt; 5; ++i)
                {
                    if (valueBase &gt;&gt; (32 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                bits = 32 - left;
            }
            if (!ReadUInt(out value, bits, true)) return false;
            value += min;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an n bit unsigned integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Integer.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits used to write.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadUInt(out ulong value, int bits, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 64) throw new ArgumentOutOfRangeException("bits must be in the range (0, 64].");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + bits + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }

            int offset = bitIndex % 8;
            value = (ulong)buffer[bitIndex / 8] &lt;&lt; 56 + offset;
            if (offset + bits &gt; 8)
            {
                value |= (ulong)buffer[bitIndex / 8 + 1] &lt;&lt; 48 + offset;
                if (offset + bits &gt; 16)
                {
                    value |= (ulong)buffer[bitIndex / 8 + 2] &lt;&lt; 40 + offset;
                    if (offset + bits &gt; 24)
                    {
                        value |= (ulong)buffer[bitIndex / 8 + 3] &lt;&lt; 32 + offset;
                        if (offset + bits &gt; 32)
                        {
                            value |= (ulong)buffer[bitIndex / 8 + 4] &lt;&lt; 24 + offset;
                            if (offset + bits &gt; 40)
                            {
                                value |= (ulong)buffer[bitIndex / 8 + 5] &lt;&lt; 16 + offset;
                                if (offset + bits &gt; 48)
                                {
                                    value |= (ulong)buffer[bitIndex / 8 + 6] &lt;&lt; 8 + offset;
                                    if (offset + bits &gt; 56)
                                    {
                                        value |= (ulong)buffer[bitIndex / 8 + 7] &lt;&lt; offset;
                                        if (offset + bits &gt; 64)
                                        {
                                            value |= (ulong)buffer[bitIndex / 8 + 8] &gt;&gt; 8 - offset;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            value &gt;&gt;= 64 - bits;
            bitIndex += bits;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an n bit unsigned integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Integer.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadUInt(out ulong value, ulong min, ulong max, bool nestedRead = false)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");

            if (!nestedRead) previousBitIndex = bitIndex;
            ulong valueBase = max - min + 1;
            // Log2
            var bits = 64;
            if (valueBase != 0)
            {
                int left = 0;
                int right = 64;
                for (int i = 0; i &lt; 6; ++i)
                {
                    if (valueBase &gt;&gt; (64 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                bits = 64 - left;
            }
            if (!ReadUInt(out value, bits, true)) return false;
            value += min;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an n bit custom signed integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Integer.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits used to write.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadInt(out int value, int bits, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 32) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32].");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + bits + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }

            int offset = bitIndex % 8;
            value = buffer[bitIndex / 8] &lt;&lt; 24 + offset;
            if (offset + bits &gt; 8)
            {
                value |= buffer[bitIndex / 8 + 1] &lt;&lt; 16 + offset;
                if (offset + bits &gt; 16)
                {
                    value |= buffer[bitIndex / 8 + 2] &lt;&lt; 8 + offset;
                    if (offset + bits &gt; 24)
                    {
                        value |= buffer[bitIndex / 8 + 3] &lt;&lt; offset;
                        if (offset + bits &gt; 32)
                        {
                            value |= buffer[bitIndex / 8 + 4] &gt;&gt; 8 - offset;
                        }
                    }
                }
            }

            value &gt;&gt;= 32 - bits;
            bitIndex += bits;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an n bit custom signed integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Integer.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadInt(out int value, int min, int max, bool nestedRead = false)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");

            if (!nestedRead) previousBitIndex = bitIndex;
            uint valueBase = (uint)(max - min + 1);
            // Log2
            var bits = 32;
            if (valueBase != 0)
            {
                int left = 0;
                int right = 32;
                for (int i = 0; i &lt; 5; ++i)
                {
                    if (valueBase &gt;&gt; (32 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                bits = 32 - left;
            }
            if (!ReadInt(out value, bits, true)) return false;
            value += min;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an n bit custom signed integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Integer.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits used to write.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadInt(out long value, int bits, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 64) throw new ArgumentOutOfRangeException("bits must be in the range (0, 64].");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + bits + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }

            int offset = bitIndex % 8;
            value = buffer[bitIndex / 8] &lt;&lt; 56 + offset;
            if (offset + bits &gt; 8)
            {
                value |= (long)buffer[bitIndex / 8 + 1] &lt;&lt; 48 + offset;
                if (offset + bits &gt; 16)
                {
                    value |= (long)buffer[bitIndex / 8 + 2] &lt;&lt; 40 + offset;
                    if (offset + bits &gt; 24)
                    {
                        value |= (long)buffer[bitIndex / 8 + 3] &lt;&lt; 32 + offset;
                        if (offset + bits &gt; 32)
                        {
                            value |= (long)buffer[bitIndex / 8 + 4] &lt;&lt; 24 + offset;
                            if (offset + bits &gt; 40)
                            {
                                value |= (long)buffer[bitIndex / 8 + 5] &lt;&lt; 16 + offset;
                                if (offset + bits &gt; 48)
                                {
                                    value |= (long)buffer[bitIndex / 8 + 6] &lt;&lt; 8 + offset;
                                    if (offset + bits &gt; 56)
                                    {
                                        value |= (long)buffer[bitIndex / 8 + 7] &lt;&lt; offset;
                                        if (offset + bits &gt; 64)
                                        {
                                            value |= (long)buffer[bitIndex / 8 + 8] &gt;&gt; 8 - offset;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            value &gt;&gt;= 64 - bits;
            bitIndex += bits;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an n bit custom signed integer from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Integer.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadInt(out long value, long min, long max, bool nestedRead = false)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");

            if (!nestedRead) previousBitIndex = bitIndex;
            ulong valueBase = (ulong)(max - min + 1);
            // Log2
            var bits = 64;
            if (valueBase != 0)
            {
                int left = 0;
                int right = 64;
                for (int i = 0; i &lt; 6; ++i)
                {
                    if (valueBase &gt;&gt; (64 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                bits = 64 - left;
            }
            if (!ReadInt(out value, bits, true)) return false;
            value += min;
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a 32 bit single from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Single.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadSingle(out float value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 32 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            uint uValue;
            if (!ReadUInt32(out uValue, true)) return false;
            value = BitConverter.ToSingle(BitConverter.GetBytes(uValue), 0);
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a 64 bit double from the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Double.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadDouble(out double value, bool nestedRead = false)
        {
            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            if ((bitIndex + 64 + 7) / 8 &gt; buffer.Count)
            {
                return false;
            }
            byte[] bytes = new byte[8];
            uint uValue1;
            if (!ReadUInt32(out uValue1, true)) return false;
            byte[] first4bytes = BitConverter.GetBytes(uValue1);
            uint uValue2;
            if (!ReadUInt32(out uValue2, true)) return false;
            byte[] last4bytes = BitConverter.GetBytes(uValue2);

            for (uint copyBytes = 0; copyBytes &lt; 4; ++copyBytes)
            {
                bytes[copyBytes] = first4bytes[copyBytes];
            }
            for (uint copyBytes = 4; copyBytes &lt; 8; ++copyBytes)
            {
                bytes[copyBytes] = last4bytes[copyBytes - 4];
            }
            value = BitConverter.ToDouble(bytes, 0);
            return true;
        }

        /// &lt;summary&gt;
        /// Reads the variable-width unsigned integer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Integer.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The bit size of the sequence used to write.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadVariableWidthUInt(out uint value, int bits = 4, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 32) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32].");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            int valueBitCount = bits;
            bool continuationBitValue = true;
            do
            {
                if (!ReadBool(out continuationBitValue, true)) return false;
                if (continuationBitValue) valueBitCount += bits;
            }
            while (continuationBitValue &amp;&amp; valueBitCount &lt; 32);
            return ReadUInt(out value, valueBitCount &gt;= 32 ? 32 : valueBitCount, true);
        }

        /// &lt;summary&gt;
        /// Reads the variable-width unsigned integer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Unsigned Integer.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The bit size of the sequence used to write.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadVariableWidthUInt(out ulong value, int bits = 4, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 64) throw new ArgumentOutOfRangeException("bits must be in the range (0, 64].");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            int valueBitCount = bits;
            bool continuationBitValue = true;
            do
            {
                if (!ReadBool(out continuationBitValue, true)) return false;
                if (continuationBitValue) valueBitCount += bits;
            }
            while (continuationBitValue &amp;&amp; valueBitCount &lt; 64);
            return ReadUInt(out value, valueBitCount &gt;= 64 ? 64 : valueBitCount, true);
        }

        /// &lt;summary&gt;
        /// Reads the variable-width signed integer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Integer.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The bit size of the sequence used to write.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadVariableWidthInt(out int value, int bits = 4, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 32) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32].");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            int valueBitCount = bits;
            bool continuationBitValue = true;
            do
            {
                if (!ReadBool(out continuationBitValue, true)) return false;
                if (continuationBitValue) valueBitCount += bits;
            }
            while (continuationBitValue &amp;&amp; valueBitCount &lt; 32);
            return ReadInt(out value, valueBitCount &gt;= 32 ? 32 : valueBitCount, true);
        }

        /// &lt;summary&gt;
        /// Reads the variable-width signed integer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Signed Integer.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The bit size of the sequence used to write.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadVariableWidthInt(out long value, int bits = 4, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 64) throw new ArgumentOutOfRangeException("bits must be in the range (0, 64].");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            int valueBitCount = bits;
            bool continuationBitValue = true;
            do
            {
                if (!ReadBool(out continuationBitValue, true)) return false;
                if (continuationBitValue) valueBitCount += bits;
            }
            while (continuationBitValue &amp;&amp; valueBitCount &lt; 64);
            return ReadInt(out value, valueBitCount &gt;= 64 ? 64 : valueBitCount, true);
        }

        /// &lt;summary&gt;
        /// Reads an array of unsigned integers in the given range defining a base.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Array of Unsigned Integers.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadArrayUInt32(uint[] value, int min, int max, bool nestedRead = false)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (!nestedRead) previousBitIndex = bitIndex;
            ulong valueBase = (ulong)(max - min + 1);
            var exponent = value.Length;

            var powResult = new List&lt;ulong&gt;();
            powResult.Add(1);
            var newPowResult = new List&lt;ulong&gt;();

            var valueBaseTemp = new List&lt;ulong&gt;();
            valueBaseTemp.Add(valueBase);
            var newValueBaseTemp = new List&lt;ulong&gt;();

            // Pow(value.size, arrayBase) using exponentiation by squaring
            while (exponent != 0)
            {
                if (exponent % 2 != 0)
                {
                    // powResult *= valueBaseTemp;
                    newPowResult.Clear();
                    for (int i = 0; i &lt; valueBaseTemp.Count; ++i)
                    {
                        ulong carry = 0;
                        for (var j = 0; j &lt; powResult.Count || carry != 0; ++j)
                        {
                            if (i + j &gt;= newPowResult.Count)
                            {
                                newPowResult.Add(0);
                            }
                            ulong product = 0;
                            if (j &lt; powResult.Count)
                            {
                                product = valueBaseTemp[i] * powResult[j];
                            }
                            newPowResult[j + i] += product + carry;
                            carry = newPowResult[j + i] &gt;&gt; 32;
                            newPowResult[j + i] &amp;= 0xFFFFFFFF;
                        }
                    }
                    powResult.Clear();
                    powResult.InsertRange(0, newPowResult);
                    exponent--;
                }
                // valueBaseTemp *= valueBaseTemp;
                newValueBaseTemp.Clear();
                for (int i = 0; i &lt; valueBaseTemp.Count; ++i)
                {
                    ulong carry = 0;
                    for (var j = 0; j &lt; valueBaseTemp.Count || carry != 0; ++j)
                    {
                        if (i + j &gt;= newValueBaseTemp.Count)
                        {
                            newValueBaseTemp.Add(0);
                        }
                        ulong product = 0;
                        if (j &lt; valueBaseTemp.Count)
                        {
                            product = valueBaseTemp[i] * valueBaseTemp[j];
                        }
                        newValueBaseTemp[j + i] += product + carry;
                        carry = newValueBaseTemp[j + i] &gt;&gt; 32;
                        newValueBaseTemp[j + i] &amp;= 0xFFFFFFFF;
                    }
                }
                valueBaseTemp.Clear();
                valueBaseTemp.InsertRange(0, newValueBaseTemp);

                exponent /= 2;
            }

            for (var i = powResult.Count - 1; i &gt; 0 &amp;&amp; powResult[i] == 0; --i)
            {
                powResult.RemoveAt(powResult.Count - 1);
            }

            // Log2
            int numberOfBits = 0;
            if (!(powResult.Count == 1 &amp;&amp; powResult[0] == 0))
            {
                int left = 0;
                int right = 32;
                for (int i = 0; i &lt; 5; ++i)
                {
                    if (powResult[powResult.Count - 1] &gt;&gt; (32 - (left + right) / 2) != 0)
                    {
                        // Left
                        right = (left + right) / 2;
                    }
                    else
                    {
                        // Right
                        left = (left + right) / 2;
                    }
                }
                numberOfBits = (powResult.Count - 1) * 32 + (32 - left);
            }

            var sum = new List&lt;ulong&gt;((numberOfBits + 31) / 32);
            for (int copyBits = 0; copyBits &lt; numberOfBits; copyBits += 32)
            {
                uint uValue;
                if (!ReadUInt(out uValue, (int)numberOfBits - copyBits &gt; 32 ? 32 : (int)numberOfBits - copyBits, true)) return false;
                sum.Add(uValue);
            }

            for (var i = 0; i &lt; value.Length; ++i)
            {
                ulong remainder = 0;
                for (var j = sum.Count - 1; j &gt;= 0; --j)
                {
                    sum[j] += remainder &lt;&lt; 32;
                    remainder = sum[j] % valueBase;
                    sum[j] /= valueBase;
                }
                value[i] = (uint)remainder + (uint)min;
            }
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an array of signed integers in the given range defining a base.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Array of Signed Integers.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadArrayInt32(int[] value, int min, int max, bool nestedRead = false)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (!nestedRead) previousBitIndex = bitIndex;

            var uValue = new uint[value.Length];
            if (!ReadArrayUInt32(uValue, min, max, true)) return false;

            for (var i = 0; i &lt; value.Length; ++i)
            {
                value[i] = (int)uValue[i] + min;
            }
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an array of singles in the given range converted to the given base.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Array of Singles.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="valueBase"&gt;The base to convert the singles to.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadArraySingle(float[] value, float min, float max, int valueBase, bool nestedRead = false)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (!nestedRead) previousBitIndex = bitIndex;
            var uValue = new uint[value.Length];
            if (!ReadArrayUInt32(uValue, 0, valueBase - 1, true)) return false;
            if (min &lt; 0 &amp;&amp; max &gt; 0)
            {
                for (var i = 0; i &lt; value.Length; ++i)
                {
                    value[i] = uValue[i] == 0 ? 0 : (uValue[i] - 1) / (float)(valueBase - 2) * (max - min) + min;
                }
            }
            else
            {
                for (var i = 0; i &lt; value.Length; ++i)
                {
                    value[i] = uValue[i] / (float)(valueBase - 1) * (max - min) + min;
                }
            }
            return true;
        }

        /// &lt;summary&gt;
        /// Reads an array of doubles in the given range converted to the given base.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Array of Doubles.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="valueBase"&gt;The base to convert the doubles to.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadArrayDouble(double[] value, double min, double max, int valueBase, bool nestedRead = false)
        {
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");
            if (!nestedRead) previousBitIndex = bitIndex;
            var uValue = new uint[value.Length];
            if (!ReadArrayUInt32(uValue, 0, valueBase - 1, true)) return false;
            if (min &lt; 0 &amp;&amp; max &gt; 0)
            {
                for (var i = 0; i &lt; value.Length; ++i)
                {
                    value[i] = uValue[i] == 0 ? 0 : (uValue[i] - 1) / (double)(valueBase - 2) * (max - min) + min;
                }
            }
            else
            {
                for (var i = 0; i &lt; value.Length; ++i)
                {
                    value[i] = uValue[i] / (double)(valueBase - 1) * (max - min) + min;
                }
            }
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a custom resolution single.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Single.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="bitResolution"&gt;The number of bits written for the ratio.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadCustomResolutionSingle(out float value, float min, float max, int bitResolution, bool nestedRead = false)
        {
            if (bitResolution &lt; 1 || bitResolution &gt; 31) throw new ArgumentOutOfRangeException("bitResolution must be in the range (0, 32).");
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            uint uValue;
            if (!ReadUInt(out uValue, bitResolution, true)) return false;
            if (min &lt; 0 &amp;&amp; max &gt; 0)
            {
                value = uValue == 0 ? 0 : (uValue - 1) / (float)((0x1 &lt;&lt; bitResolution) - 2) * (max - min) + min;
            }
            else
            {
                value = uValue / (float)((0x1 &lt;&lt; bitResolution) - 1) * (max - min) + min;
            }
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a custom resolution double.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;Double.&lt;/param&gt;
        /// &lt;param name="min"&gt;The minimum value in the range.&lt;/param&gt;
        /// &lt;param name="max"&gt;The maximum value in the range.&lt;/param&gt;
        /// &lt;param name="bitResolution"&gt;The number of bits written for the ratio.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadCustomResolutionDouble(out double value, double min, double max, int bitResolution, bool nestedRead = false)
        {
            if (bitResolution &lt; 1 || bitResolution &gt; 31) throw new ArgumentOutOfRangeException("bitResolution must be in the range (0, 32).");
            if (max &lt;= min) throw new ArgumentOutOfRangeException("max must be greater than min.");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = 0;
            uint uValue;
            if (!ReadUInt(out uValue, bitResolution, true)) return false;
            if (min &lt; 0 &amp;&amp; max &gt; 0)
            {
                value = uValue == 0 ? 0 : (uValue - 1) / (double)((0x1 &lt;&lt; bitResolution) - 2) * (max - min) + min;
            }
            else
            {
                value = uValue / (double)((0x1 &lt;&lt; bitResolution) - 1) * (max - min) + min;
            }
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a string.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;String.&lt;/param&gt;
        /// &lt;param name="bits"&gt;The number of bits for the length written using an unsigned variable-width integer.&lt;/param&gt;
        /// &lt;param name="limit"&gt;The maximum number of characters to read.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadString(out string value, int bits = 4, int limit = 255, bool nestedRead = false)
        {
            if (bits &lt; 1 || bits &gt; 31) throw new ArgumentOutOfRangeException("bits must be in the range (0, 32).");

            if (!nestedRead) previousBitIndex = bitIndex;
            value = string.Empty;
            uint size;
            if (!ReadVariableWidthUInt(out size, bits, true)) return false;
            for (var asciiByteItr = 0; asciiByteItr &lt; size; ++asciiByteItr)
            {
                byte asciiByte;
                if (!ReadByte(out asciiByte, true)) return false;
                value += asciiByte;
                if (value.Length &gt; limit) return false;
            }
            return true;
        }

        /// &lt;summary&gt;
        /// Reads a binary packet that has been written to the buffer.
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;A binary packet.&lt;/param&gt;
        /// &lt;param name="nestedRead"&gt;If false then the previous bit index is stored so the operation can be rolled back.&lt;/param&gt;
        /// &lt;returns&gt;false on error.&lt;/returns&gt;
        public bool ReadBinaryPacket(out Packet value, bool nestedRead = false)
        {
            value = new Packet();
            if (!nestedRead) previousBitIndex = bitIndex;
            uint valueMaxBitIndex;
            if (!ReadVariableWidthUInt(out valueMaxBitIndex, nestedRead: true)) return false;
            for (int copyBits = 0; copyBits &lt; valueMaxBitIndex; copyBits += 32)
            {
                uint uValue;
                if (!ReadUInt(out uValue, (int)valueMaxBitIndex - copyBits &gt; 32 ? 32 : (int)valueMaxBitIndex - copyBits, true)) return false;
                value.WriteUInt(uValue, (int)valueMaxBitIndex - copyBits &gt; 32 ? 32 : (int)valueMaxBitIndex - copyBits);
            }
            bitIndex += (int)valueMaxBitIndex;
            value.bitIndex = 0;
            return true;
        }

    }
}</pre>