Число размером 128 бит

        /// <summary>
        /// Выполняет побитовый циклический сдвиг массива (область сдвигаемых данных массива должна быть кратной 8).
        /// </summary>
        /// <param name="Data">Преобразуемые данные.</param>
        /// <param name="Step">Шаг сдвига.</param>
        private unsafe void UnsafeShiftBits(byte[] Data, int Step)
        {
            if (Data == null)
                throw new ArgumentNullException("Data == null");
 
            if (Data.Length % 8 != 0)
                throw new ArgumentException("Data.Length % 8 != 0");
 
            if (Step == 0)
                return;
 
            byte[] CarryBits = new byte[Data.Length / 8];
 
            fixed (byte* DataPointer = Data)
            {
                if (Step > 0)
                {
                    for (int i = 0; i < Step; i++)
                    {
                        for (int j = 0; j < Data.Length; j += 8)
                        {
                            CarryBits[j / 8] = (byte)((*(ulong*)(DataPointer + j) & 0x8000000000000000) >> 63);
                            *(ulong*)(DataPointer + j) <<= 1;
                        }
 
                        for (int j = 0; j < Data.Length; j += 8)
                        {
                            if (j < Data.Length - 8)
                            {
                                if (CarryBits[j / 8] == 0)
                                    *(ulong*)(DataPointer + j + 8) &= 0xFFFFFFFFFFFFFFFE;
                                else
                                    *(ulong*)(DataPointer + j + 8) |= 0x0000000000000001;
                            }
                            else
                            {
                                if (CarryBits[j / 8] == 0)
                                    *(ulong*)(DataPointer) &= 0xFFFFFFFFFFFFFFFE;
                                else
                                    *(ulong*)(DataPointer) |= 0x0000000000000001;
                            }
                        }
                    }
                }
                else
                {
                    Step *= -1;
 
                    for (int i = 0; i < Step; i++)
                    {
                        for (int j = Data.Length - 8; j >= 0; j -= 8)
                        {
                            CarryBits[j / 8] = (byte)(*(ulong*)(DataPointer + j) & 0x0000000000000001);
                            *(ulong*)(DataPointer + j) >>= 1;
                        }
 
                        for (int j = Data.Length - 8; j >= 0; j -= 8)
                        {
                            if (j > 0)
                            {
                                if (CarryBits[j / 8] == 0)
                                    *(ulong*)(DataPointer + j - 8) &= 0x7FFFFFFFFFFFFFFF;
                                else
                                    *(ulong*)(DataPointer + j - 8) |= 0x8000000000000000;
                            }
                            else
                            {
                                if (CarryBits[j / 8] == 0)
                                    *(ulong*)(DataPointer + (Data.Length - 8)) &= 0x7FFFFFFFFFFFFFFF;
                                else
                                    *(ulong*)(DataPointer + (Data.Length - 8)) |= 0x8000000000000000;
                            }
                        }
                    }
                }
            }
        }