public byte[] Decrypt(byte[] data)
        {
            Decompress(data);
            BitMatrixManager bitMatrixManager = new BitMatrixManager(data);


            for (int i = 0; i < 3; i++)
            {
                for (int y = Key.Length - 1; y >= 0; y--)
                {
                    for (int x = Chunks.Length - 1; x >= 0; x--)
                    {
                        bitMatrixManager.ShiftDown(2, 0);
                        bitMatrixManager.ShiftLeft(Key[y], x);
                    }
                }

                for (int y = LinkedKey.Length - 1; y >= 0; y--)
                {
                    for (int x = 31; x >= 0; x--)
                    {
                        bitMatrixManager.ShiftLeft(1, 0);
                        bitMatrixManager.ShiftDown(LinkedKey[y], x);
                    }
                }
            }

            Decompress(bitMatrixManager.Compress());
            bitMatrixManager = null;

            ShiftChunksLeft(IntegralSum(LinkedKey));

            return(UnprotectChunks());
        }
        public byte[] Encrypt(byte[] data)
        {
            Chunks = new byte[data.Length][];
            for (int x = 0; x < data.Length; x++)
            {
                Chunks[x] = ProtectChunk(GenerateChunk(data[x]));
            }

            ShiftChunksRight(IntegralSum(LinkedKey));

            BitMatrixManager bitMatrixManager = new BitMatrixManager(Compress());

            for (int i = 0; i < 3; i++)
            {
                for (int y = 0; y < LinkedKey.Length; y++)
                {
                    for (int x = 0; x < 32; x++)
                    {
                        bitMatrixManager.ShiftUp(LinkedKey[y], x);
                        bitMatrixManager.ShiftRight(1, 0);
                    }
                }

                for (int y = 0; y < Key.Length; y++)
                {
                    for (int x = 0; x < Chunks.Length; x++)
                    {
                        bitMatrixManager.ShiftRight(Key[y], x);
                        bitMatrixManager.ShiftUp(2, 0);
                    }
                }
            }

            return(bitMatrixManager.Compress());
        }