Манипуляции с битами

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ConsoleApplication156
{
    class Program
    {
        static void Main(string[] args)
        {
            var data = new byte[] {0x81, 0x0d};
            var br = new BitReader(data);
            br.Seek(1);//skip first bit
            var n1 = br.Read(7);//read 7 bits
            br.Seek(1);//skip first bit
            var n2 = br.Read(7);//read 7 bits
 
            var result = (n1 << 7 | n2);
        }
    }
 
    /// <summary>
    /// Reads byte array as stream of bits
    /// </summary>
    class BitReader
    {
        public int Position = 0;
        private byte[] source;
 
        public BitReader(byte[] source)
        {
            this.source = source;
        }
 
        public int Length { get { return source.Length*8; } }
 
        /// <summary>
        /// Reads bitCount bits from stream and return as UInt32
        /// </summary>
        public UInt32 Read(int bitCount)
        {
            UInt32 res = 0;
 
            for (int i = 0; i < bitCount; i++)
            {
                var bit = Read();
                if (bit < 0)
                    throw new Exception("Can not read needed count of the bits");
                unchecked
                {
                    res = (res << 1) | (UInt32) bit;
                }
            }
 
            return res;
        }
 
        /// <summary>
        /// Reads one bit from stream
        /// </summary>
        public int Read()
        {
            if (Position >= Length) return -1;
            var i = Position / 8;
            var j = Position % 8;
            Position++;
            return (source[i] >> (7 - j)) & 0x01;
        }
 
        /// <summary>
        /// Moves Position
        /// </summary>
        public bool Seek(int shift)
        {
            Position += shift;
            if (Position < 0)
            {
                Position = 0;
                return false;
            }
 
            if (Position >= Length)
            {
                Position = Length - 1;
                return false;
            }
 
            return true;
        }
    }
}

value = value ^ (1<<15);
value = value ^ (1<<7);

bool exist = (value & (1<<15)) != 0

byte[] data = ....;
int length = data[0] > 0x7F ? (byte)(data[0] ^ 0x80) : data[0];
for (int i=0; data[i] > 0x7F; i++)
{
    byte nextByte = data[i+1] > 0x7F ? (byte)(data[i+1] ^ 0x80) : data[i+1];
    length = (length << 7) | nextByte;
}

        static int GetLength(byte[] buff, int offset = 0)
        {
            int length = 0;
            int count = Math.Min(buff.Length - offset, 4);
 
            int i = 0;
 
            while (true)
            {
                length |= buff[i + offset] & 0x7F;
 
                if ((buff[i + offset] & 0x80) == 0 || ++i == count)
                    return length;
 
                length <<= 7;
            }
        }

int GetLength(byte[] buf, int offset)
{
    if (buf == null) throw new ArgumentNullException("buf");
    if (offset < 0) throw new ArgumentOutOfRangeException("offset", "Offset must be positive number or zero");
    if (offset >= buf.Length) throw new ArgumentOutOfRangeException("offset", "Offset must be within the bounds of the buffer");
 
    int length = buf[offset] & 0x7F;
    for (int idx=offset+1, count=0; buf[idx-1] > 0x7F; count++, idx++)
    {
        if (idx>=buf.Length || count>3 || (count==3 && buf[idx]>0x7F)) throw new InvalidOperationException();
        
        byte nextByte = (byte)(buf[idx] & 0x7F);
        length = (length << 7) | nextByte;
    }
    return length;
}