mcs/class/referencesource/mscorlib/system/security/cryptography/rijndaelmanagedtransform.cs

   1 using System.Diagnostics.Contracts;
   2 // ==++==
   3 //
   4 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   5 //
   6 // ==--==
   7 // <OWNER>[....]</OWNER>
   8 //
   9
  10 //
  11 // RijndaelManagedTransform.cs
  12 //
  13
  14 namespace System.Security.Cryptography
  15 {
  16     [Serializable]
  17     internal enum RijndaelManagedTransformMode {
  18         Encrypt = 0,
  19         Decrypt = 1
  20     }
  21
  22     [System.Runtime.InteropServices.ComVisible(true)]
  23     public sealed class RijndaelManagedTransform : ICryptoTransform {
  24         private CipherMode m_cipherMode;
  25         private PaddingMode m_paddingValue;
  26         private RijndaelManagedTransformMode m_transformMode;
  27
  28         private int m_blockSizeBits;
  29         private int m_blockSizeBytes;
  30         private int m_inputBlockSize;
  31         private int m_outputBlockSize;
  32
  33         private int[] m_encryptKeyExpansion;
  34         private int[] m_decryptKeyExpansion;
  35
  36         private int m_Nr;
  37         private int m_Nb;
  38         private int m_Nk;
  39
  40         private int[] m_encryptindex = null;
  41         private int[] m_decryptindex = null;
  42
  43         private int[] m_IV;
  44         private int[] m_lastBlockBuffer;
  45         private byte[] m_depadBuffer;
  46         private byte[] m_shiftRegister;
  47
  48         internal RijndaelManagedTransform (byte[] rgbKey,
  49                                            CipherMode mode,
  50                                            byte[] rgbIV,
  51                                            int blockSize,
  52                                            int feedbackSize,
  53                                            PaddingMode PaddingValue,
  54                                            RijndaelManagedTransformMode transformMode) {
  55             if (rgbKey == null)
  56                 throw new ArgumentNullException("rgbKey");
  57             Contract.EndContractBlock();
  58
  59 #if !FEATURE_CRYPTO
  60             Contract.Assert(mode == CipherMode.CBC, "CipherMode is unsupported on CoreCLR");
  61             Contract.Assert(PaddingValue == PaddingMode.PKCS7, "PaddingMode is unsupported on CoreCLR");
  62 #endif // !FEATURE_CRYPTO
  63
  64             m_blockSizeBits = blockSize;
  65             m_blockSizeBytes = blockSize / 8;
  66             m_cipherMode = mode;
  67             m_paddingValue = PaddingValue;
  68             m_transformMode = transformMode;
  69             m_Nb = blockSize / 32;
  70             m_Nk = rgbKey.Length / 4;
  71
  72             int S1 = m_Nb > 6 ? 3 : 2;
  73             int S2 = m_Nb > 6 ? 4 : 3;
  74
  75             // Precompute the modulus operations: these are performance killers when called frequently
  76             int[] encryptindex1 = new int[m_Nb];
  77             int[] encryptindex2 = new int[m_Nb];
  78             int[] encryptindex3 = new int[m_Nb];
  79
  80             int[] decryptindex1 = new int[m_Nb];
  81             int[] decryptindex2 = new int[m_Nb];
  82             int[] decryptindex3 = new int[m_Nb];
  83
  84             for (int j=0; j < m_Nb; j++) {
  85                 encryptindex1[j] = (j + 1) % m_Nb;
  86                 encryptindex2[j] = (j + S1) % m_Nb;
  87                 encryptindex3[j] = (j + S2) % m_Nb;
  88                 decryptindex1[j] = (j -1  + m_Nb) % m_Nb;
  89                 decryptindex2[j] = (j -S1 + m_Nb) % m_Nb;
  90                 decryptindex3[j] = (j -S2 + m_Nb) % m_Nb;
  91             }
  92
  93             m_encryptindex = new int[m_Nb * 3];
  94             Array.Copy(encryptindex1, 0, m_encryptindex, 0, m_Nb);
  95             Array.Copy(encryptindex2, 0, m_encryptindex, m_Nb, m_Nb);
  96             Array.Copy(encryptindex3, 0, m_encryptindex, m_Nb * 2, m_Nb);
  97
  98             m_decryptindex = new int[m_Nb * 3];
  99             Array.Copy(decryptindex1, 0, m_decryptindex, 0, m_Nb);
 100             Array.Copy(decryptindex2, 0, m_decryptindex, m_Nb, m_Nb);
 101             Array.Copy(decryptindex3, 0, m_decryptindex, m_Nb * 2, m_Nb);
 102
 103             switch (m_cipherMode) {
 104                 case CipherMode.ECB:
 105                 case CipherMode.CBC:
 106                     m_inputBlockSize = m_blockSizeBytes;
 107                     m_outputBlockSize = m_blockSizeBytes;
 108                     break;
 109
 110                 case CipherMode.CFB:
 111                     m_inputBlockSize = feedbackSize / 8;
 112                     m_outputBlockSize = feedbackSize / 8;
 113                     break;
 114
 115                 default:
 116                     throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidCipherMode"));
 117             }
 118
 119             // On CorECLR we only support CBC mode
 120 #if FEATURE_CRYPTO
 121             if (mode == CipherMode.CBC || mode == CipherMode.CFB) {
 122 #endif // FEATURE_CRYPTO
 123                 if (rgbIV == null)
 124                     throw new ArgumentNullException("rgbIV");
 125                 if (rgbIV.Length / 4 != m_Nb)
 126                     throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidIVSize"));
 127
 128                 m_IV = new int[m_Nb];
 129                 int index = 0;
 130                 for (int i = 0; i < m_Nb; ++i) {
 131                     int i0 = rgbIV[index++];
 132                     int i1 = rgbIV[index++];
 133                     int i2 = rgbIV[index++];
 134                     int i3 = rgbIV[index++];
 135                     m_IV[i] = i3 << 24 | i2 << 16 | i1 << 8 | i0;
 136                 }
 137 #if FEATURE_CRYPTO
 138             }
 139 #endif // FEATURE_CRYPTO
 140
 141             GenerateKeyExpansion(rgbKey);
 142
 143 #if FEATURE_CRYPTO // see code:System.Security.Cryptography.RijndaelManaged#CoreCLRRijndaelModes
 144             if (m_cipherMode == CipherMode.CBC) {
 145 #endif // FEATURE_CRYPTO
 146                 m_lastBlockBuffer = new int[m_Nb];
 147                 Buffer.InternalBlockCopy(m_IV, 0, m_lastBlockBuffer, 0, m_blockSizeBytes);
 148 #if FEATURE_CRYPTO
 149             }
 150 #endif // FEATURE_CRYPTO
 151
 152 #if FEATURE_CRYPTO
 153             if (m_cipherMode == CipherMode.CFB) {
 154                 m_shiftRegister = new byte[4*m_Nb];
 155                 Buffer.InternalBlockCopy(m_IV, 0, m_shiftRegister, 0, 4*m_Nb);
 156             }
 157 #endif // FEATURE_CRYPTO
 158         }
 159
 160 #if FEATURE_CORECLR
 161         void IDisposable.Dispose()
 162 #else
 163         public void Dispose()
 164 #endif
 165         {
 166             Dispose(true);
 167         }
 168
 169         public void Clear() {
 170            Dispose(true);
 171         }
 172
 173         private void Dispose (bool disposing) {
 174             if (disposing) {
 175                 // We need to always zeroize the following fields because they contain sensitive data
 176                 if (m_IV != null) {
 177                     Array.Clear(m_IV, 0, m_IV.Length);
 178                     m_IV = null;
 179                 }
 180                 if (m_lastBlockBuffer != null) {
 181                     Array.Clear(m_lastBlockBuffer, 0, m_lastBlockBuffer.Length);
 182                     m_lastBlockBuffer = null;
 183                 }
 184                 if (m_encryptKeyExpansion != null) {
 185                     Array.Clear(m_encryptKeyExpansion, 0, m_encryptKeyExpansion.Length);
 186                     m_encryptKeyExpansion = null;
 187                 }
 188                 if (m_decryptKeyExpansion != null) {
 189                     Array.Clear(m_decryptKeyExpansion, 0, m_decryptKeyExpansion.Length);
 190                     m_decryptKeyExpansion = null;
 191                 }
 192                 if (m_depadBuffer != null) {
 193                     Array.Clear(m_depadBuffer, 0, m_depadBuffer.Length);
 194                     m_depadBuffer = null;
 195                 }
 196                 if (m_shiftRegister != null) {
 197                     Array.Clear(m_shiftRegister, 0, m_shiftRegister.Length);
 198                     m_shiftRegister = null;
 199                 }
 200             }
 201         }
 202
 203         //
 204         // ICryptoTransform methods and properties.
 205         //
 206
 207         public int BlockSizeValue {
 208             get {
 209                 return m_blockSizeBits;
 210             }
 211         }
 212
 213         public int InputBlockSize {
 214             get {
 215                 return m_inputBlockSize;
 216             }
 217         }
 218
 219         public int OutputBlockSize {
 220             get {
 221                 return m_outputBlockSize;
 222             }
 223         }
 224
 225         public bool CanTransformMultipleBlocks {
 226             get {
 227                 return true;
 228             }
 229         }
 230
 231         public bool CanReuseTransform {
 232             get {
 233                 return true;
 234             }
 235         }
 236
 237         public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {
 238             // Note: special handling required if decrypting & using padding because the padding adds to the end of the last
 239             // block, we have to buffer an entire block's worth of bytes in case what I just transformed turns out to be
 240             // the last block Then in TransformFinalBlock we strip off the padding.
 241
 242             if (inputBuffer == null) throw new ArgumentNullException("inputBuffer");
 243             if (outputBuffer == null) throw new ArgumentNullException("outputBuffer");
 244             if (inputOffset < 0) throw new ArgumentOutOfRangeException("inputOffset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
 245             if (inputCount <= 0 || (inputCount % InputBlockSize != 0) || (inputCount > inputBuffer.Length)) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidValue"));
 246             if ((inputBuffer.Length - inputCount) < inputOffset) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
 247             Contract.EndContractBlock();
 248
 249             if (m_transformMode == RijndaelManagedTransformMode.Encrypt) {
 250                 // if we're encrypting we can always push out the bytes because no padding mode
 251                 // removes bytes during encryption
 252                 return EncryptData(inputBuffer,
 253                                    inputOffset,
 254                                    inputCount,
 255                                    ref outputBuffer,
 256                                    outputOffset,
 257                                    m_paddingValue,
 258                                    false);
 259             }
 260             else {
 261 #if FEATURE_CRYPTO // see code:System.Security.Cryptography.RijndaelManaged#CoreCLRRijndaelModes
 262                 if (m_paddingValue == PaddingMode.Zeros || m_paddingValue == PaddingMode.None) {
 263                     // like encryption, if we're using None or Zeros padding on decrypt we can write out all
 264                     // the bytes.  Note that we cannot depad a block partially padded with Zeros because
 265                     // we can't tell if those zeros are plaintext or pad.
 266                     return DecryptData(inputBuffer, inputOffset, inputCount, ref outputBuffer, outputOffset, m_paddingValue, false);
 267                 }
 268                 else {
 269 #endif // FEATURE_CRYPTO
 270                     // OK, now we're in the special case.  Check to see if this is the *first* block we've seen
 271                     // If so, buffer it and return null zero bytes
 272                     if (m_depadBuffer == null) {
 273                         m_depadBuffer = new byte[InputBlockSize];
 274                         // copy the last InputBlockSize bytes to m_depadBuffer everything else gets processed and returned
 275                         int inputToProcess = inputCount - InputBlockSize;
 276                         Buffer.InternalBlockCopy(inputBuffer, inputOffset+inputToProcess, m_depadBuffer, 0, InputBlockSize);
 277                         return DecryptData(inputBuffer,
 278                                            inputOffset,
 279                                            inputToProcess,
 280                                            ref outputBuffer,
 281                                            outputOffset,
 282                                            m_paddingValue,
 283                                            false);
 284                     } else {
 285                         // we already have a depad buffer, so we need to decrypt that info first & copy it out
 286                         int r = DecryptData(m_depadBuffer,
 287                                             0, m_depadBuffer.Length,
 288                                             ref outputBuffer,
 289                                             outputOffset,
 290                                             m_paddingValue,
 291                                             false);
 292                         outputOffset += OutputBlockSize;
 293                         int inputToProcess = inputCount - InputBlockSize;
 294                         Buffer.InternalBlockCopy(inputBuffer, inputOffset+inputToProcess, m_depadBuffer, 0, InputBlockSize);
 295                         r = DecryptData(inputBuffer,
 296                                         inputOffset,
 297                                         inputToProcess,
 298                                         ref outputBuffer,
 299                                         outputOffset,
 300                                         m_paddingValue,
 301                                         false);
 302                         return (OutputBlockSize + r);
 303                     }
 304 #if FEATURE_CRYPTO
 305                 }
 306 #endif // FEATURE_CRYPTO
 307             }
 308         }
 309
 310         public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) {
 311             if (inputBuffer == null) throw new ArgumentNullException("inputBuffer");
 312             if (inputOffset < 0) throw new ArgumentOutOfRangeException("inputOffset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
 313             if (inputCount < 0 || (inputCount > inputBuffer.Length)) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidValue"));
 314             if ((inputBuffer.Length - inputCount) < inputOffset) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
 315             Contract.EndContractBlock();
 316
 317             if (m_transformMode == RijndaelManagedTransformMode.Encrypt) {
 318                 // If we're encrypting we can alway return what we compute because there's no m_depadBuffer
 319                 byte[] transformedBytes = null;
 320                 EncryptData(inputBuffer,
 321                             inputOffset,
 322                             inputCount,
 323                             ref transformedBytes,
 324                             0,
 325                             m_paddingValue,
 326                             true);
 327                 Reset();
 328                 return transformedBytes;
 329             }
 330             else {
 331                 if (inputCount%InputBlockSize != 0)
 332                     throw new CryptographicException(Environment.GetResourceString("Cryptography_SSD_InvalidDataSize"));
 333
 334                 if (m_depadBuffer == null) {
 335                     byte[] transformedBytes = null;
 336                     DecryptData(inputBuffer,
 337                                 inputOffset,
 338                                 inputCount,
 339                                 ref transformedBytes,
 340                                 0,
 341                                 m_paddingValue,
 342                                 true);
 343                     Reset();
 344                     return transformedBytes;
 345                 } else {
 346                     byte[] temp = new byte[m_depadBuffer.Length + inputCount];
 347                     Buffer.InternalBlockCopy(m_depadBuffer, 0, temp, 0, m_depadBuffer.Length);
 348                     Buffer.InternalBlockCopy(inputBuffer, inputOffset, temp, m_depadBuffer.Length, inputCount);
 349                     byte[] transformedBytes = null;
 350                     DecryptData(temp,
 351                                 0,
 352                                 temp.Length,
 353                                 ref transformedBytes,
 354                                 0,
 355                                 m_paddingValue,
 356                                 true);
 357                     Reset();
 358                     return transformedBytes;
 359                 }
 360             }
 361         }
 362
 363         //
 364         // resets the state of the transform
 365         //
 366
 367         public void Reset() {
 368             m_depadBuffer = null;
 369 #if FEATURE_CRYPTO // see code:System.Security.Cryptography.RijndaelManaged#CoreCLRRijndaelModes
 370             if (m_cipherMode == CipherMode.CBC)
 371 #endif // FEATURE_CRYPTO
 372                 Buffer.InternalBlockCopy(m_IV, 0, m_lastBlockBuffer, 0, m_blockSizeBytes);
 373 #if FEATURE_CRYPTO
 374             if (m_cipherMode == CipherMode.CFB)
 375                 Buffer.InternalBlockCopy(m_IV, 0, m_shiftRegister, 0, 4*m_Nb);
 376 #endif // FEATURE_CRYPTO
 377         }
 378
 379         //
 380         // Deals with the various cipher and padding modes and calls the AES encryption routine.
 381         // This method writes the encrypted data into the output buffer. If the output buffer is null,
 382         // it allocates it and populates it with the encrypted data.
 383         //
 384         [SecuritySafeCritical]
 385         private unsafe int EncryptData(byte[] inputBuffer,
 386                                        int inputOffset,
 387                                        int inputCount,
 388                                        ref byte[] outputBuffer,
 389                                        int outputOffset,
 390                                        PaddingMode paddingMode,
 391                                        bool fLast) {
 392             if (inputBuffer.Length < inputOffset + inputCount)
 393                 throw new CryptographicException(Environment.GetResourceString("Cryptography_InsufficientBuffer"));
 394
 395             int padSize = 0;
 396             int lonelyBytes = inputCount % m_inputBlockSize;
 397
 398             // Check the padding mode and make sure we have enough outputBuffer to handle any padding we have to do.
 399             byte[] padBytes = null;
 400             int workBaseIndex = inputOffset, index = 0;
 401             if (fLast) {
 402 #if FEATURE_CRYPTO // see code:System.Security.Cryptography.RijndaelManaged#CoreCLRRijndaelModes
 403                 switch (paddingMode) {
 404                 case PaddingMode.None:
 405                     if (lonelyBytes != 0)
 406                         throw new CryptographicException(Environment.GetResourceString("Cryptography_SSE_InvalidDataSize"));
 407                     break;
 408                 case PaddingMode.Zeros:
 409                     if (lonelyBytes != 0)
 410                         padSize = m_inputBlockSize - lonelyBytes;
 411                     break;
 412                 case PaddingMode.PKCS7:
 413 #endif // FEATURE_CRYPTO
 414                     padSize = m_inputBlockSize - lonelyBytes;
 415
 416 #if FEATURE_CRYPTO
 417                     break;
 418                 case PaddingMode.ANSIX923:
 419                     padSize = m_inputBlockSize - lonelyBytes;
 420                     break;
 421                 case PaddingMode.ISO10126:
 422                     padSize = m_inputBlockSize - lonelyBytes;
 423                     break;
 424                 }
 425 #endif // FEATURE_CRYPTO
 426
 427                 if (padSize != 0) {
 428                     padBytes = new byte[padSize];
 429 #if FEATURE_CRYPTO
 430                     switch (paddingMode) {
 431                     case PaddingMode.None:
 432                         break;
 433                     case PaddingMode.Zeros:
 434                         // padBytes is already initialized with zeros
 435                         break;
 436                     case PaddingMode.PKCS7:
 437 #endif // FEATURE_CRYPTO
 438                         for (index = 0; index < padSize; index++)
 439                             padBytes[index] = (byte) padSize;
 440
 441 #if FEATURE_CRYPTO
 442                         break;
 443                     case PaddingMode.ANSIX923:
 444                         // padBytes is already initialized with zeros. Simply change the last byte.
 445                         padBytes[padSize - 1] = (byte) padSize;
 446                         break;
 447                     case PaddingMode.ISO10126:
 448                         // generate random bytes
 449                         Utils.StaticRandomNumberGenerator.GetBytes(padBytes);
 450                         padBytes[padSize - 1] = (byte) padSize;
 451                         break;
 452                     }
 453 #endif // FEATURE_CRYPTO
 454                 }
 455             }
 456
 457             if (outputBuffer == null) {
 458                 outputBuffer = new byte[inputCount + padSize];
 459                 outputOffset = 0;
 460             } else {
 461                 if ((outputBuffer.Length - outputOffset) < (inputCount + padSize))
 462                     throw new CryptographicException(Environment.GetResourceString("Cryptography_InsufficientBuffer"));
 463             }
 464
 465             fixed (int* encryptindex = m_encryptindex) {
 466                 fixed (int* encryptKeyExpansion = m_encryptKeyExpansion) {
 467                     fixed (int *T = s_T) {
 468                         fixed (int *TF = s_TF) {
 469                             int* work = stackalloc int[m_Nb];
 470                             int* temp = stackalloc int[m_Nb];
 471
 472                             int iNumBlocks = (inputCount + padSize) / m_inputBlockSize;
 473                             int transformCount = outputOffset;
 474                             for (int blockNum = 0;  blockNum < iNumBlocks; ++blockNum) {
 475 #if FEATURE_CRYPTO // see code:System.Security.Cryptography.RijndaelManaged#CoreCLRRijndaelModes
 476                                 if (m_cipherMode == CipherMode.CFB) {
 477                                     Contract.Assert(m_blockSizeBytes <= m_Nb * sizeof(int), "m_blockSizeBytes <= m_Nb * sizeof(int)");
 478                                     Buffer.Memcpy((byte *)work, 0, m_shiftRegister, 0, m_blockSizeBytes);
 479                                 } else {
 480 #endif // FEATURE_CRYPTO
 481                                                                                            if (blockNum != iNumBlocks - 1 || padSize == 0) {
 482                                         Contract.Assert(m_blockSizeBytes <= m_Nb * sizeof(int), "m_blockSizeBytes <= m_Nb * sizeof(int)");
 483                                         Buffer.Memcpy((byte*)work, 0, inputBuffer, workBaseIndex, m_blockSizeBytes);
 484                                     } else {
 485                                         int padIndex = 0;
 486                                         index = workBaseIndex;
 487                                         for (int i = 0; i < m_Nb; ++i) {
 488                                             int i0 = (index >= workBaseIndex + lonelyBytes) ? padBytes[padIndex++] : inputBuffer[index++];
 489                                             int i1 = (index >= workBaseIndex + lonelyBytes) ? padBytes[padIndex++] : inputBuffer[index++];
 490                                             int i2 = (index >= workBaseIndex + lonelyBytes) ? padBytes[padIndex++] : inputBuffer[index++];
 491                                             int i3 = (index >= workBaseIndex + lonelyBytes) ? padBytes[padIndex++] : inputBuffer[index++];
 492                                             work[i] = i3 << 24 | i2 << 16 | i1 << 8 | i0;
 493                                         }
 494                                     }
 495 #if FEATURE_CRYPTO
 496                                 }
 497 #endif // FEATURE_CRYPTO
 498
 499 #if FEATURE_CRYPTO
 500                                 if (m_cipherMode == CipherMode.CBC) {
 501 #endif // FEATURE_CRYPTO
 502                                     for (int i = 0; i < m_Nb; ++i) {
 503                                         // XOR with the last encrypted block
 504                                         work[i] ^= m_lastBlockBuffer[i];
 505                                     }
 506 #if FEATURE_CRYPTO
 507                                 }
 508 #endif // FEATURE_CRYPTO
 509
 510                                 Enc(encryptindex, encryptKeyExpansion, T, TF, work, temp);
 511
 512 #if FEATURE_CRYPTO
 513                                 if (m_cipherMode == CipherMode.CFB) {
 514                                     index = workBaseIndex;
 515                                     if (blockNum != iNumBlocks - 1 || padSize == 0) {
 516                                         for (int i = 0; i < m_Nb; ++i) {
 517                                             if (index >= workBaseIndex + m_inputBlockSize) break;
 518                                             outputBuffer[transformCount++] = (byte)((temp[i]       & 0xFF) ^ inputBuffer[index++]);
 519                                             if (index >= workBaseIndex + m_inputBlockSize) break;
 520                                             outputBuffer[transformCount++] = (byte)((temp[i] >> 8  & 0xFF) ^ inputBuffer[index++]);
 521                                             if (index >= workBaseIndex + m_inputBlockSize) break;
 522                                             outputBuffer[transformCount++] = (byte)((temp[i] >> 16 & 0xFF) ^ inputBuffer[index++]);
 523                                             if (index >= workBaseIndex + m_inputBlockSize) break;
 524                                             outputBuffer[transformCount++] = (byte)((temp[i] >> 24 & 0xFF) ^ inputBuffer[index++]);
 525                                         }
 526                                     } else {
 527                                         byte[] tmpInputBuffer = new byte[m_inputBlockSize];
 528                                         Buffer.InternalBlockCopy(inputBuffer, workBaseIndex, tmpInputBuffer, 0, lonelyBytes);
 529                                         Buffer.InternalBlockCopy(padBytes, 0, tmpInputBuffer, lonelyBytes, padSize);
 530                                         index = 0;
 531                                         for (int i = 0; i < m_Nb; ++i) {
 532                                             if (index >= m_inputBlockSize) break;
 533                                             outputBuffer[transformCount++] = (byte)((temp[i]       & 0xFF) ^ tmpInputBuffer[index++]);
 534                                             if (index >= m_inputBlockSize) break;
 535                                             outputBuffer[transformCount++] = (byte)((temp[i] >> 8  & 0xFF) ^ tmpInputBuffer[index++]);
 536                                             if (index >= m_inputBlockSize) break;
 537                                             outputBuffer[transformCount++] = (byte)((temp[i] >> 16 & 0xFF) ^ tmpInputBuffer[index++]);
 538                                             if (index >= m_inputBlockSize) break;
 539                                             outputBuffer[transformCount++] = (byte)((temp[i] >> 24 & 0xFF) ^ tmpInputBuffer[index++]);
 540                                         }
 541                                     }
 542                                     // shift m_lastBlockBuffer to the left by m_inputBlockSize bytes.
 543                                     index = 0;
 544                                     while (index < m_blockSizeBytes - m_inputBlockSize) {
 545                                         m_shiftRegister[index] = m_shiftRegister[index + m_inputBlockSize];
 546                                         index++;
 547                                     }
 548                                     Buffer.InternalBlockCopy(outputBuffer, blockNum * m_inputBlockSize, m_shiftRegister, m_blockSizeBytes - m_inputBlockSize, m_inputBlockSize);
 549                                 } else {
 550 #endif // FEATURE_CRYPTO
 551                                     for (int i = 0; i < m_Nb; ++i) {
 552                                         outputBuffer[transformCount++] = (byte)(temp[i]       & 0xFF);
 553                                         outputBuffer[transformCount++] = (byte)(temp[i] >> 8  & 0xFF);
 554                                         outputBuffer[transformCount++] = (byte)(temp[i] >> 16 & 0xFF);
 555                                         outputBuffer[transformCount++] = (byte)(temp[i] >> 24 & 0xFF);
 556                                     }
 557
 558 #if FEATURE_CRYPTO
 559                                     if (m_cipherMode == CipherMode.CBC) {
 560 #endif // FEATURE_CRYPTO
 561                                         fixed (int* pLastBlockBuffer = m_lastBlockBuffer) {
 562                                             Contract.Assert(m_blockSizeBytes <= m_lastBlockBuffer.Length * sizeof(int), "m_blockSizeBytes <= m_lastBlockBuffer.Length * sizeof(int)");
 563                                             Buffer.Memcpy((byte*)pLastBlockBuffer, (byte*)temp, m_blockSizeBytes);
 564                                         }
 565 #if FEATURE_CRYPTO
 566                                     }
 567                                 }
 568 #endif // FEATURE_CRYPTO
 569                                 workBaseIndex += m_inputBlockSize;
 570                             }
 571                         }
 572                     }
 573                 }
 574             }
 575
 576             return (inputCount + padSize);
 577         }
 578
 579         //
 580         // Deals with the various cipher and padding modes and calls the AES decryption routine.
 581         // This method writes the decrypted data into the output buffer. If the output buffer is null,
 582         // it allocates it and populates it with the decrypted data.
 583         //
 584
 585         [System.Security.SecuritySafeCritical]  // auto-generated
 586         private unsafe int DecryptData(byte[] inputBuffer,
 587                                        int inputOffset,
 588                                        int inputCount,
 589                                        ref byte[] outputBuffer,
 590                                        int outputOffset,
 591                                        PaddingMode paddingMode,
 592                                        bool fLast) {
 593             if (inputBuffer.Length < inputOffset + inputCount)
 594                 throw new CryptographicException(Environment.GetResourceString("Cryptography_InsufficientBuffer"));
 595
 596             if (outputBuffer == null) {
 597                 outputBuffer = new byte[inputCount];
 598                 outputOffset = 0;
 599             } else {
 600                 if ((outputBuffer.Length - outputOffset) < inputCount)
 601                     throw new CryptographicException(Environment.GetResourceString("Cryptography_InsufficientBuffer"));
 602             }
 603
 604             fixed (int* encryptindex = m_encryptindex) {
 605                 fixed (int* encryptKeyExpansion = m_encryptKeyExpansion) {
 606                     fixed (int* decryptindex = m_decryptindex) {
 607                         fixed (int* decryptKeyExpansion = m_decryptKeyExpansion) {
 608                             fixed (int *T = s_T) {
 609                                 fixed (int *TF = s_TF) {
 610                                     fixed (int *iT = s_iT) {
 611                                         fixed (int *iTF = s_iTF) {
 612                                             int* work = stackalloc int[m_Nb];
 613                                             int* temp = stackalloc int[m_Nb];
 614
 615                                             int iNumBlocks = inputCount / m_inputBlockSize;
 616                                             int workBaseIndex = inputOffset, index = 0, transformCount = outputOffset;
 617                                             for (int blockNum = 0; blockNum < iNumBlocks; ++blockNum) {
 618 #if FEATURE_CRYPTO // see code:System.Security.Cryptography.RijndaelManaged#CoreCLRRijndaelModes
 619                                                 if (m_cipherMode == CipherMode.CFB) {
 620                                                     index = 0;
 621                                                     for (int i = 0; i < m_Nb; ++i) {
 622                                                         int i0 = m_shiftRegister[index++];
 623                                                         int i1 = m_shiftRegister[index++];
 624                                                         int i2 = m_shiftRegister[index++];
 625                                                         int i3 = m_shiftRegister[index++];
 626                                                         work[i] = i3 << 24 | i2 << 16 | i1 << 8 | i0;
 627                                                     }
 628                                                 } else {
 629 #endif // FEATURE_CRYPTO
 630                                                     index = workBaseIndex;
 631                                                     for (int i = 0; i < m_Nb; ++i) {
 632                                                         int i0 = inputBuffer[index++];
 633                                                         int i1 = inputBuffer[index++];
 634                                                         int i2 = inputBuffer[index++];
 635                                                         int i3 = inputBuffer[index++];
 636                                                         work[i] = i3 << 24 | i2 << 16 | i1 << 8 | i0;
 637                                                     }
 638 #if FEATURE_CRYPTO
 639                                                 }
 640 #endif // FEATURE_CRYPTO
 641
 642 #if FEATURE_CRYPTO
 643                                                 if (m_cipherMode == CipherMode.CFB) {
 644                                                     // We use the encryption function in both encryption and decryption in CFB mode.
 645                                                     Enc(encryptindex, encryptKeyExpansion, T, TF, work, temp);
 646
 647                                                     index = workBaseIndex;
 648                                                     for (int i = 0; i < m_Nb; ++i) {
 649                                                         if (index >= workBaseIndex + m_inputBlockSize) break;
 650                                                         outputBuffer[transformCount++] = (byte)((temp[i]       & 0xFF) ^ inputBuffer[index++]);
 651                                                         if (index >= workBaseIndex + m_inputBlockSize) break;
 652                                                         outputBuffer[transformCount++] = (byte)((temp[i] >> 8  & 0xFF) ^ inputBuffer[index++]);
 653                                                         if (index >= workBaseIndex + m_inputBlockSize) break;
 654                                                         outputBuffer[transformCount++] = (byte)((temp[i] >> 16 & 0xFF) ^ inputBuffer[index++]);
 655                                                         if (index >= workBaseIndex + m_inputBlockSize) break;
 656                                                         outputBuffer[transformCount++] = (byte)((temp[i] >> 24 & 0xFF) ^ inputBuffer[index++]);
 657                                                     }
 658                                                     // shift m_lastBlockBuffer to the left by m_inputBlockSize bytes.
 659                                                     index = 0;
 660                                                     while (index < m_blockSizeBytes - m_inputBlockSize) {
 661                                                         m_shiftRegister[index] = m_shiftRegister[index + m_inputBlockSize];
 662                                                         index++;
 663                                                     }
 664                                                     Buffer.InternalBlockCopy(inputBuffer, workBaseIndex, m_shiftRegister, m_blockSizeBytes - m_inputBlockSize, m_inputBlockSize);
 665                                                 } else {
 666 #endif // FEATURE_CRYPTO
 667                                                     Dec(decryptindex, decryptKeyExpansion, iT, iTF, work, temp);
 668
 669 #if FEATURE_CRYPTO
 670                                                     if (m_cipherMode == CipherMode.CBC) {
 671 #endif // FEATURE_CRYPTO
 672                                                         index = workBaseIndex;
 673                                                         for (int i = 0; i < m_Nb; ++i) {
 674                                                             temp[i] ^= m_lastBlockBuffer[i];
 675                                                             // save the input buffer
 676                                                             int i0 = inputBuffer[index++];
 677                                                             int i1 = inputBuffer[index++];
 678                                                             int i2 = inputBuffer[index++];
 679                                                             int i3 = inputBuffer[index++];
 680                                                             m_lastBlockBuffer[i] = i3 << 24 | i2 << 16 | i1 << 8 | i0;
 681                                                         }
 682 #if FEATURE_CRYPTO
 683                                                     }
 684 #endif // FEATURE_CRYPTO
 685
 686                                                     for (int i = 0; i < m_Nb; ++i) {
 687                                                         outputBuffer[transformCount++] = (byte)(temp[i]       & 0xFF);
 688                                                         outputBuffer[transformCount++] = (byte)(temp[i] >> 8  & 0xFF);
 689                                                         outputBuffer[transformCount++] = (byte)(temp[i] >> 16 & 0xFF);
 690                                                         outputBuffer[transformCount++] = (byte)(temp[i] >> 24 & 0xFF);
 691                                                     }
 692 #if FEATURE_CRYPTO
 693                                                 }
 694 #endif // FEATURE_CRYPTO
 695
 696                                                 workBaseIndex += m_inputBlockSize;
 697                                             }
 698
 699                                             if (fLast == false)
 700                                                 return inputCount;
 701
 702                                             // this is the last block, remove the padding.
 703                                             byte[] outputBuffer1 = outputBuffer;
 704                                             int padSize = 0;
 705 #if FEATURE_CRYPTO // see code:System.Security.Cryptography.RijndaelManaged#CoreCLRRijndaelModes
 706                                             switch (paddingMode) {
 707                                             case PaddingMode.None:
 708                                                 break;
 709                                             case PaddingMode.Zeros:
 710                                                 break;
 711                                             case PaddingMode.PKCS7:
 712 #endif // FEATURE_CRYPTO
 713                                                 if (inputCount == 0)
 714                                                     throw new CryptographicException(Environment.GetResourceString("Cryptography_PKCS7_InvalidPadding"));
 715                                                 padSize = outputBuffer[inputCount - 1];
 716                                                 if (padSize > outputBuffer.Length || padSize > InputBlockSize || padSize <= 0)
 717                                                     throw new CryptographicException(Environment.GetResourceString("Cryptography_PKCS7_InvalidPadding"));
 718                                                 for (index = 1; index <= padSize; index++)
 719                                                     if (outputBuffer[inputCount - index] != padSize)
 720                                                         throw new CryptographicException(Environment.GetResourceString("Cryptography_PKCS7_InvalidPadding"));
 721                                                 outputBuffer1 = new byte[outputBuffer.Length - padSize];
 722                                                 Buffer.InternalBlockCopy(outputBuffer, 0, outputBuffer1, 0, outputBuffer.Length - padSize);
 723 #if FEATURE_CRYPTO
 724                                                 break;
 725                                             case PaddingMode.ANSIX923:
 726                                                 if (inputCount == 0)
 727                                                     throw new CryptographicException(Environment.GetResourceString("Cryptography_PKCS7_InvalidPadding"));
 728                                                 padSize = outputBuffer[inputCount - 1];
 729                                                 if (padSize > outputBuffer.Length || padSize > InputBlockSize || padSize <= 0)
 730                                                     throw new CryptographicException(Environment.GetResourceString("Cryptography_PKCS7_InvalidPadding"));
 731                                                 // check the validity of the padding
 732                                                 for (index = 2; index <= padSize; index++)
 733                                                     if (outputBuffer[inputCount - index] != 0)
 734                                                         throw new CryptographicException(Environment.GetResourceString("Cryptography_PKCS7_InvalidPadding"));
 735                                                 outputBuffer1 = new byte[outputBuffer.Length - padSize];
 736                                                 Buffer.InternalBlockCopy(outputBuffer, 0, outputBuffer1, 0, outputBuffer.Length - padSize);
 737                                                 break;
 738                                             case PaddingMode.ISO10126:
 739                                                 if (inputCount == 0)
 740                                                     throw new CryptographicException(Environment.GetResourceString("Cryptography_PKCS7_InvalidPadding"));
 741                                                 padSize = outputBuffer[inputCount - 1];
 742                                                 if (padSize > outputBuffer.Length || padSize > InputBlockSize || padSize <= 0)
 743                                                     throw new CryptographicException(Environment.GetResourceString("Cryptography_PKCS7_InvalidPadding"));
 744                                                 // Just ignore the random bytes
 745                                                 outputBuffer1 = new byte[outputBuffer.Length - padSize];
 746                                                 Buffer.InternalBlockCopy(outputBuffer, 0, outputBuffer1, 0, outputBuffer.Length - padSize);
 747                                                 break;
 748                                             }
 749 #endif // FEATURE_CRYPTO
 750                                             outputBuffer = outputBuffer1;
 751                                             return outputBuffer1.Length;
 752                                         }
 753                                     }
 754                                 }
 755                             }
 756                         }
 757                     }
 758                 }
 759             }
 760         }
 761
 762         //
 763         // AES encryption function.
 764         //
 765         [System.Security.SecurityCritical]  // auto-generated
 766         private unsafe void Enc(int* encryptindex, int* encryptKeyExpansion, int* T, int* TF, int* work, int* temp) {
 767             for (int i = 0; i < m_Nb; ++i) {
 768                 work[i] ^= encryptKeyExpansion[i];
 769             }
 770
 771             int* _encryptindex;
 772             int* _encryptKeyExpansion = &encryptKeyExpansion[m_Nb];
 773             for (int r = 1; r < m_Nr; ++r) {
 774                 _encryptindex = encryptindex;
 775                 for (int i = 0; i < m_Nb; ++i) {
 776                     temp[i] = T[0 + (work[i] & 0xFF)] ^
 777                               T[256 + ((work[_encryptindex[0]] >> 8) & 0xFF)] ^
 778                               T[512 + ((work[_encryptindex[m_Nb]] >> 16) & 0xFF)] ^
 779                               T[768 + ((work[_encryptindex[m_Nb * 2]] >> 24) & 0xFF)] ^
 780                               *_encryptKeyExpansion;
 781                     _encryptindex++;
 782                     _encryptKeyExpansion++;
 783                 }
 784
 785                 for (int i = 0; i < m_Nb; ++i) {
 786                     work[i] = temp[i];
 787                 }
 788             }
 789
 790             _encryptindex = encryptindex;
 791             for (int i = 0; i < m_Nb; ++i) {
 792                 temp[i] = TF[0 + (work[i] & 0xFF)] ^
 793                           TF[256 + ((work[_encryptindex[0]] >> 8) & 0xFF)] ^
 794                           TF[512 + ((work[_encryptindex[m_Nb]] >> 16) & 0xFF)] ^
 795                           TF[768 + ((work[_encryptindex[m_Nb * 2]] >> 24) & 0xFF)] ^
 796                           *_encryptKeyExpansion;
 797                 _encryptindex++;
 798                 _encryptKeyExpansion++;
 799             }
 800         }
 801
 802         //
 803         // AES decryption function.
 804         //
 805
 806         [System.Security.SecurityCritical]  // auto-generated
 807         unsafe private void Dec (int *decryptindex, int *decryptKeyExpansion, int *iT, int *iTF, int *work, int *temp) {
 808             int keyIndex = m_Nb * m_Nr;
 809             for (int i = 0; i < m_Nb; ++i) {
 810                 work[i] ^= decryptKeyExpansion[keyIndex];
 811                 keyIndex++;
 812             }
 813
 814             int* _decryptindex;
 815             int* _decryptKeyExpansion;
 816             for (int r = 1; r < m_Nr; ++r) {
 817                 keyIndex -= 2 * m_Nb;
 818                 _decryptindex = decryptindex;
 819                 _decryptKeyExpansion = &decryptKeyExpansion[keyIndex];
 820                 for (int i = 0; i < m_Nb; ++i) {
 821                     temp[i] = iT[0 + ((work[i]) & 0xFF)] ^
 822                               iT[256 + ((work[_decryptindex[0]] >> 8) & 0xFF)] ^
 823                               iT[512 + ((work[_decryptindex[m_Nb]] >> 16) & 0xFF)] ^
 824                               iT[768 + ((work[_decryptindex[m_Nb * 2]] >> 24) & 0xFF)] ^
 825                               *_decryptKeyExpansion;
 826                     keyIndex++;
 827                     _decryptindex++;
 828                     _decryptKeyExpansion++;
 829                 }
 830                 for (int i = 0; i < m_Nb; ++i) {
 831                     work[i] = temp[i];
 832                 }
 833             }
 834
 835             keyIndex = 0;
 836             _decryptindex = decryptindex;
 837             _decryptKeyExpansion = &decryptKeyExpansion[keyIndex];
 838             for (int i = 0; i < m_Nb; ++i) {
 839                 temp[i] = iTF[0 + ((work[i]) & 0xFF)] ^
 840                           iTF[256 + ((work[_decryptindex[0]] >> 8) & 0xFF)] ^
 841                           iTF[512 + ((work[_decryptindex[m_Nb]] >> 16) & 0xFF)] ^
 842                           iTF[768 + ((work[_decryptindex[m_Nb * 2]] >> 24) & 0xFF)] ^
 843                           *_decryptKeyExpansion;
 844                 _decryptindex++;
 845                 _decryptKeyExpansion++;
 846             }
 847         }
 848
 849         //
 850         // Key expansion routine.
 851         //
 852
 853         private void GenerateKeyExpansion(byte[] rgbKey) {
 854             switch (m_blockSizeBits > rgbKey.Length * 8 ? m_blockSizeBits : rgbKey.Length * 8) {
 855             case 128:
 856                 m_Nr = 10;
 857                 break;
 858
 859             case 192:
 860                 m_Nr = 12;
 861                 break;
 862
 863             case 256:
 864                 m_Nr = 14;
 865                 break;
 866
 867             default:
 868                 throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidKeySize"));
 869             }
 870
 871             m_encryptKeyExpansion = new int[m_Nb * (m_Nr + 1)];
 872             m_decryptKeyExpansion = new int[m_Nb * (m_Nr + 1)];
 873             int iTemp;
 874
 875             int index = 0;
 876             for (int i = 0; i < m_Nk; ++i) {
 877                 int i0 = rgbKey[index++];
 878                 int i1 = rgbKey[index++];
 879                 int i2 = rgbKey[index++];
 880                 int i3 = rgbKey[index++];
 881                 m_encryptKeyExpansion[i] = i3 << 24 | i2 << 16 | i1 << 8 | i0;
 882             }
 883
 884             if (m_Nk <= 6) {
 885                 for (int i = m_Nk; i < m_Nb * (m_Nr + 1); ++i) {
 886                     iTemp = m_encryptKeyExpansion[i-1];
 887
 888                     if (i % m_Nk == 0) {
 889                         iTemp = SubWord(rot3(iTemp));
 890                         iTemp = iTemp ^ s_Rcon[(i / m_Nk) - 1];
 891                     }
 892
 893                     m_encryptKeyExpansion[i] = m_encryptKeyExpansion[i - m_Nk] ^ iTemp;
 894                 }
 895             } else {
 896                 for (int i = m_Nk; i < m_Nb * (m_Nr + 1); ++i) {
 897                     iTemp = m_encryptKeyExpansion[i-1];
 898
 899                     if (i % m_Nk == 0) {
 900                         iTemp = SubWord(rot3(iTemp));
 901                         iTemp = iTemp ^ s_Rcon[(i / m_Nk) - 1];
 902                     }
 903                     else if (i % m_Nk == 4) {
 904                         iTemp = SubWord(iTemp);
 905                     }
 906
 907                     m_encryptKeyExpansion[i] = m_encryptKeyExpansion[i - m_Nk] ^ iTemp;
 908                 }
 909             }
 910
 911             for (int i = 0; i < m_Nb; ++i) {
 912                 m_decryptKeyExpansion[i] = m_encryptKeyExpansion[i];
 913                 m_decryptKeyExpansion[m_Nb * m_Nr + i] = m_encryptKeyExpansion[m_Nb * m_Nr + i];
 914             }
 915
 916             for (int i = m_Nb; i < m_Nb * m_Nr; ++i) {
 917                 int key = m_encryptKeyExpansion[i];
 918                 int mul02 = MulX(key);
 919                 int mul04 = MulX(mul02);
 920                 int mul08 = MulX(mul04);
 921                 int mul09 = key ^ mul08;
 922                 m_decryptKeyExpansion[i] = mul02 ^ mul04 ^ mul08 ^ rot3(mul02 ^ mul09) ^ rot2(mul04 ^ mul09) ^ rot1(mul09);
 923             }
 924         }
 925
 926         private static int rot1(int val) {
 927             return (val << 8  & unchecked((int)0xFFFFFF00)) | (val >> 24 & unchecked((int)0x000000FF));
 928         }
 929
 930         private static int rot2(int val) {
 931             return (val << 16 & unchecked((int)0xFFFF0000)) | (val >> 16 & unchecked((int)0x0000FFFF));
 932         }
 933
 934         private static int rot3(int val) {
 935             return (val << 24 & unchecked((int)0xFF000000)) | (val >> 8  & unchecked((int)0x00FFFFFF));
 936         }
 937
 938         private static int SubWord(int a) {
 939             return s_Sbox[a       & 0xFF]       |
 940                    s_Sbox[a >> 8  & 0xFF] << 8  |
 941                    s_Sbox[a >> 16 & 0xFF] << 16 |
 942                    s_Sbox[a >> 24 & 0xFF] << 24;
 943         }
 944
 945         private static int MulX(int x) {
 946             int    u = x & unchecked((int)0x80808080);
 947             return ((x & unchecked((int)0x7f7f7f7f)) << 1) ^ ((u - (u >> 7 & 0x01FFFFFF)) & 0x1b1b1b1b);
 948         }
 949
 950         private static readonly byte[] s_Sbox = new byte[] {
 951              99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254, 215, 171, 118,
 952             202, 130, 201, 125, 250,  89,  71, 240, 173, 212, 162, 175, 156, 164, 114, 192,
 953             183, 253, 147,  38,  54,  63, 247, 204,  52, 165, 229, 241, 113, 216,  49,  21,
 954               4, 199,  35, 195,  24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,
 955               9, 131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,  47, 132,
 956              83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,  57,  74,  76,  88, 207,
 957             208, 239, 170, 251,  67,  77,  51, 133,  69, 249,   2, 127,  80,  60, 159, 168,
 958              81, 163,  64, 143, 146, 157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210,
 959             205,  12,  19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25, 115,
 960              96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20, 222,  94,  11, 219,
 961             224,  50,  58,  10,  73,   6,  36,  92, 194, 211, 172,  98, 145, 149, 228, 121,
 962             231, 200,  55, 109, 141, 213,  78, 169, 108,  86, 244, 234, 101, 122, 174,   8,
 963             186, 120,  37,  46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,
 964             112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134, 193,  29, 158,
 965             225, 248, 152,  17, 105, 217, 142, 148, 155,  30, 135, 233, 206,  85,  40, 223,
 966             140, 161, 137,  13, 191, 230,  66, 104,  65, 153,  45,  15, 176,  84, 187,  22 };
 967
 968         private static readonly int[] s_Rcon = new int[] {
 969             0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36,
 970             0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6,
 971             0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91 };
 972
 973         private static readonly int[] s_T = new int[4 * 256]
 974             {
 975                 // s_T1
 976                 -1520213050,  -2072216328,  -1720223762,  -1921287178,    234025727,  -1117033514,  -1318096930,   1422247313,
 977                 1345335392,     50397442,  -1452841010,   2099981142,    436141799,   1658312629,   -424957107,  -1703512340,
 978                 1170918031,  -1652391393,   1086966153,  -2021818886,    368769775,   -346465870,   -918075506,    200339707,
 979                 -324162239,   1742001331,    -39673249,   -357585083,  -1080255453,   -140204973,  -1770884380,   1539358875,
 980                -1028147339,    486407649,  -1366060227,   1780885068,   1513502316,   1094664062,     49805301,   1338821763,
 981                 1546925160,   -190470831,    887481809,    150073849,  -1821281822,   1943591083,   1395732834,   1058346282,
 982                  201589768,   1388824469,   1696801606,   1589887901,    672667696,  -1583966665,    251987210,  -1248159185,
 983                  151455502,    907153956,  -1686077413,   1038279391,    652995533,   1764173646,   -843926913,  -1619692054,
 984                  453576978,  -1635548387,   1949051992,    773462580,    756751158,  -1301385508,   -296068428,    -73359269,
 985                 -162377052,   1295727478,   1641469623,   -827083907,   2066295122,   1055122397,   1898917726,  -1752923117,
 986                 -179088474,   1758581177,            0,    753790401,   1612718144,    536673507,   -927878791,   -312779850,
 987                -1100322092,   1187761037,   -641810841,   1262041458,   -565556588,   -733197160,   -396863312,   1255133061,
 988                 1808847035,    720367557,   -441800113,    385612781,   -985447546,   -682799718,   1429418854,  -1803188975,
 989                 -817543798,    284817897,    100794884,  -2122350594,   -263171936,   1144798328,  -1163944155,   -475486133,
 990                 -212774494,    -22830243,  -1069531008,  -1970303227,  -1382903233,  -1130521311,   1211644016,     83228145,
 991                 -541279133,  -1044990345,   1977277103,   1663115586,    806359072,    452984805,    250868733,   1842533055,
 992                 1288555905,    336333848,    890442534,    804056259,   -513843266,  -1567123659,   -867941240,    957814574,
 993                 1472513171,   -223893675,  -2105639172,   1195195770,  -1402706744,   -413311558,    723065138,  -1787595802,
 994                -1604296512,  -1736343271,   -783331426,   2145180835,   1713513028,   2116692564,  -1416589253,  -2088204277,
 995                 -901364084,    703524551,   -742868885,   1007948840,   2044649127,   -497131844,    487262998,   1994120109,
 996                 1004593371,   1446130276,   1312438900,    503974420,   -615954030,    168166924,   1814307912,   -463709000,
 997                 1573044895,   1859376061,   -273896381,  -1503501628,  -1466855111,  -1533700815,    937747667,  -1954973198,
 998                  854058965,   1137232011,   1496790894,  -1217565222,  -1936880383,   1691735473,   -766620004,   -525751991,
 999                -1267962664,    -95005012,    133494003,    636152527,  -1352309302,  -1904575756,   -374428089,    403179536,
1000                 -709182865,  -2005370640,   1864705354,   1915629148,    605822008,   -240736681,   -944458637,   1371981463,
1001                  602466507,   2094914977,  -1670089496,    555687742,   -582268010,   -591544991,  -2037675251,  -2054518257,
1002                -1871679264,   1111375484,   -994724495,  -1436129588,   -666351472,     84083462,     32962295,    302911004,
1003                -1553899070,   1597322602,   -111716434,   -793134743,  -1853454825,   1489093017,    656219450,  -1180787161,
1004                  954327513,    335083755,  -1281845205,    856756514,  -1150719534,   1893325225,  -1987146233,  -1483434957,
1005                -1231316179,    572399164,  -1836611819,    552200649,   1238290055,    -11184726,   2015897680,   2061492133,
1006                -1886614525,   -123625127,  -2138470135,    386731290,   -624967835,    837215959,   -968736124,  -1201116976,
1007                -1019133566,  -1332111063,   1999449434,    286199582,   -877612933,    -61582168,   -692339859,    974525996,
1008
1009                 // s_T2
1010                1667483301,   2088564868,   2004348569,   2071721613,   -218956019,   1802229437,   1869602481,   -976907948,
1011                  808476752,     16843267,   1734856361,    724260477,    -16849127,   -673729182,  -1414836762,   1987505306,
1012                 -892694715,  -2105401443,   -909539008,   2105408135,    -84218091,   1499050731,   1195871945,   -252642549,
1013                -1381154324,   -724257945,  -1566416899,  -1347467798,  -1667488833,  -1532734473,   1920132246,  -1061119141,
1014                -1212713534,    -33693412,  -1819066962,    640044138,    909536346,   1061125697,   -134744830,   -859012273,
1015                  875849820,  -1515892236,   -437923532,   -235800312,   1903288979,   -656888973,    825320019,    353708607,
1016                   67373068,   -943221422,    589514341,  -1010590370,    404238376,  -1768540255,     84216335,  -1701171275,
1017                  117902857,    303178806,  -2139087973,   -488448195,   -336868058,    656887401,  -1296924723,   1970662047,
1018                  151589403,  -2088559202,    741103732,    437924910,    454768173,   1852759218,   1515893998,  -1600103429,
1019                 1381147894,    993752653,   -690571423,  -1280082482,    690573947,   -471605954,    791633521,  -2071719017,
1020                 1397991157,   -774784664,            0,   -303185620,    538984544,    -50535649,  -1313769016,   1532737261,
1021                 1785386174,   -875852474,  -1094817831,    960066123,   1246401758,   1280088276,   1482207464,   -808483510,
1022                 -791626901,   -269499094,  -1431679003,    -67375850,   1128498885,   1296931543,    859006549,  -2054876780,
1023                 1162185423,   -101062384,     33686534,   2139094657,   1347461360,   1010595908,  -1616960070,  -1465365533,
1024                 1364304627,  -1549574658,   1077969088,  -1886452342,  -1835909203,  -1650646596,    943222856,   -168431356,
1025                -1128504353,  -1229555775,   -623202443,    555827811,    269492272,        -6886,   -202113778,   -757940371,
1026                 -842170036,    202119188,    320022069,   -320027857,   1600110305,  -1751698014,   1145342156,    387395129,
1027                 -993750185,  -1482205710,   2122251394,   1027439175,   1684326572,   1566423783,    421081643,   1936975509,
1028                 1616953504,  -2122245736,   1330618065,   -589520001,    572671078,    707417214,  -1869595733,  -2004350077,
1029                 1179028682,   -286341335,  -1195873325,    336865340,   -555833479,   1583267042,    185275933,   -606360202,
1030                 -522134725,    842163286,    976909390,    168432670,   1229558491,    101059594,    606357612,   1549580516,
1031                -1027432611,   -741098130,  -1397996561,   1650640038,  -1852753496,  -1785384540,   -454765769,   2038035083,
1032                 -404237006,   -926381245,    926379609,   1835915959,  -1920138868,   -707415708,   1313774802,  -1448523296,
1033                 1819072692,   1448520954,   -185273593,   -353710299,   1701169839,   2054878350,  -1364310039,    134746136,
1034                -1162186795,   2021191816,    623200879,    774790258,    471611428,  -1499047951,  -1263242297,   -960063663,
1035                 -387396829,   -572677764,   1953818780,    522141217,   1263245021,  -1111662116,  -1953821306,  -1970663547,
1036                 1886445712,   1044282434,  -1246400060,   1718013098,   1212715224,     50529797,   -151587071,    235805714,
1037                 1633796771,    892693087,   1465364217,  -1179031088,  -2038032495,  -1044276904,    488454695,  -1633802311,
1038                 -505292488,   -117904621,  -1734857805,    286335539,   1768542907,   -640046736,  -1903294583,  -1802226777,
1039                -1684329034,    505297954,  -2021190254,   -370554592,   -825325751,   1431677695,    673730680,   -538991238,
1040                -1936981105,  -1583261192,  -1987507840,    218962455,  -1077975590,   -421079247,   1111655622,   1751699640,
1041                 1094812355,  -1718015568,    757946999,    252648977,  -1330611253,   1414834428,  -1145344554,    370551866,
1042
1043                 // s_T3
1044                 1673962851,   2096661628,   2012125559,   2079755643,   -218165774,   1809235307,   1876865391,   -980331323,
1045                  811618352,     16909057,   1741597031,    727088427,    -18408962,   -675978537,  -1420958037,   1995217526,
1046                 -896580150,  -2111857278,   -913751863,   2113570685,    -84994566,   1504897881,   1200539975,   -251982864,
1047                -1388188499,   -726439980,  -1570767454,  -1354372433,  -1675378788,  -1538000988,   1927583346,  -1063560256,
1048                -1217019209,    -35578627,  -1824674157,    642542118,    913070646,   1065238847,   -134937865,   -863809588,
1049                  879254580,  -1521355611,   -439274267,   -235337487,   1910674289,   -659852328,    828527409,    355090197,
1050                   67636228,   -946515257,    591815971,  -1013096765,    405809176,  -1774739050,     84545285,  -1708149350,
1051                  118360327,    304363026,  -2145674368,   -488686110,   -338876693,    659450151,  -1300247118,   1978310517,
1052                  152181513,  -2095210877,    743994412,    439627290,    456535323,   1859957358,   1521806938,  -1604584544,
1053                 1386542674,    997608763,   -692624938,  -1283600717,    693271337,   -472039709,    794718511,  -2079090812,
1054                 1403450707,   -776378159,            0,   -306107155,    541089824,    -52224004,  -1317418831,   1538714971,
1055                 1792327274,   -879933749,  -1100490306,    963791673,   1251270218,   1285084236,   1487988824,   -813348145,
1056                 -793023536,   -272291089,  -1437604438,    -68348165,   1132905795,   1301993293,    862344499,  -2062445435,
1057                 1166724933,   -102166279,     33818114,   2147385727,   1352724560,   1014514748,  -1624917345,  -1471421528,
1058                 1369633617,  -1554121053,   1082179648,  -1895462257,  -1841320558,  -1658733411,    946882616,   -168753931,
1059                -1134305348,  -1233665610,   -626035238,    557998881,    270544912,     -1762561,   -201519373,   -759206446,
1060                 -847164211,    202904588,    321271059,   -322752532,   1606345055,  -1758092649,   1149815876,    388905239,
1061                 -996976700,  -1487539545,   2130477694,   1031423805,   1690872932,   1572530013,    422718233,   1944491379,
1062                 1623236704,  -2129028991,   1335808335,   -593264676,    574907938,    710180394,  -1875137648,  -2012511352,
1063                 1183631942,   -288937490,  -1200893000,    338181140,   -559449634,   1589437022,    185998603,   -609388837,
1064                 -522503200,    845436466,    980700730,    169090570,   1234361161,    101452294,    608726052,   1555620956,
1065                -1029743166,   -742560045,  -1404833876,   1657054818,  -1858492271,  -1791908715,   -455919644,   2045938553,
1066                 -405458201,   -930397240,    929978679,   1843050349,  -1929278323,   -709794603,   1318900302,  -1454776151,
1067                 1826141292,   1454176854,   -185399308,   -355523094,   1707781989,   2062847610,  -1371018834,    135272456,
1068                -1167075910,   2029029496,    625635109,    777810478,    473441308,  -1504185946,  -1267480652,   -963161658,
1069                 -389340184,   -576619299,   1961401460,    524165407,   1268178251,  -1117659971,  -1962047861,  -1978694262,
1070                 1893765232,   1048330814,  -1250835275,   1724688998,   1217452104,     50726147,   -151584266,    236720654,
1071                 1640145761,    896163637,   1471084887,  -1184247623,  -2045275770,  -1046914879,    490350365,  -1641563746,
1072                 -505857823,   -118811656,  -1741966440,    287453969,   1775418217,   -643206951,  -1912108658,  -1808554092,
1073                -1691502949,    507257374,  -2028629369,   -372694807,   -829994546,   1437269845,    676362280,   -542803233,
1074                -1945923700,  -1587939167,  -1995865975,    219813645,  -1083843905,   -422104602,   1115997762,   1758509160,
1075                 1099088705,  -1725321063,    760903469,    253628687,  -1334064208,   1420360788,  -1150429509,    371997206,
1076
1077                 // s_T4
1078                -962239645,   -125535108,   -291932297,   -158499973,    -15863054,   -692229269,   -558796945,  -1856715323,
1079                 1615867952,     33751297,   -827758745,   1451043627,   -417726722,  -1251813417,   1306962859,   -325421450,
1080                -1891251510,    530416258,  -1992242743,    -91783811,   -283772166,  -1293199015,  -1899411641,    -83103504,
1081                 1106029997,  -1285040940,   1610457762,   1173008303,    599760028,   1408738468,   -459902350,  -1688485696,
1082                 1975695287,   -518193667,   1034851219,   1282024998,   1817851446,   2118205247,   -184354825,  -2091922228,
1083                 1750873140,   1374987685,   -785062427,   -116854287,   -493653647,  -1418471208,   1649619249,    708777237,
1084                  135005188,  -1789737017,   1181033251,  -1654733885,    807933976,    933336726,    168756485,    800430746,
1085                  235472647,    607523346,    463175808,   -549592350,   -853087253,   1315514151,   2144187058,   -358648459,
1086                  303761673,    496927619,   1484008492,    875436570,    908925723,   -592286098,  -1259447718,   1543217312,
1087                -1527360942,   1984772923,  -1218324778,   2110698419,   1383803177,   -583080989,   1584475951,    328696964,
1088                -1493871789,  -1184312879,            0,  -1054020115,   1080041504,   -484442884,   2043195825,  -1225958565,
1089                 -725718422,  -1924740149,   1742323390,   1917532473,  -1797371318,  -1730917300,  -1326950312,  -2058694705,
1090                -1150562096,   -987041809,   1340451498,   -317260805,  -2033892541,  -1697166003,   1716859699,    294946181,
1091                -1966127803,   -384763399,     67502594,    -25067649,  -1594863536,   2017737788,    632987551,   1273211048,
1092                -1561112239,   1576969123,  -2134884288,     92966799,   1068339858,    566009245,   1883781176,   -251333131,
1093                 1675607228,   2009183926,  -1351230758,   1113792801,    540020752,   -451215361,    -49351693,  -1083321646,
1094                -2125673011,    403966988,    641012499,  -1020269332,  -1092526241,    899848087,  -1999879100,    775493399,
1095                -1822964540,   1441965991,    -58556802,   2051489085,   -928226204,  -1159242403,    841685273,   -426413197,
1096                -1063231392,    429425025,  -1630449841,  -1551901476,   1147544098,   1417554474,   1001099408,    193169544,
1097                -1932900794,   -953553170,   1809037496,    675025940,  -1485185314,  -1126015394,    371002123,  -1384719397,
1098                 -616832800,   1683370546,   1951283770,    337512970,  -1831122615,    201983494,   1215046692,  -1192993700,
1099                -1621245246,  -1116810285,   1139780780,   -995728798,    967348625,    832869781,   -751311644,   -225740423,
1100                 -718084121,  -1958491960,   1851340599,   -625513107,     25988493,  -1318791723,  -1663938994,   1239460265,
1101                 -659264404,  -1392880042,   -217582348,   -819598614,   -894474907,   -191989126,   1206496942,    270010376,
1102                 1876277946,   -259491720,   1248797989,   1550986798,    941890588,   1475454630,   1942467764,  -1756248378,
1103                 -886839064,  -1585652259,   -392399756,   1042358047,  -1763882165,   1641856445,    226921355,    260409994,
1104                 -527404944,   2084716094,   1908716981,   -861247898,  -1864873912,    100991747,   -150866186,    470945294,
1105                -1029480095,   1784624437,  -1359390889,   1775286713,    395413126,  -1722236479,    975641885,    666476190,
1106                 -650583583,   -351012616,    733190296,    573772049,   -759469719,  -1452221991,    126455438,    866620564,
1107                  766942107,   1008868894,    361924487,   -920589847,  -2025206066,  -1426107051,   1350051880,  -1518673953,
1108                   59739276,   1509466529,    159418761,    437718285,   1708834751,   -684595482,  -2067381694,   -793221016,
1109                -2101132991,    699439513,   1517759789,    504434447,   2076946608,  -1459858348,   1842789307,    742004246 };
1110
1111         private static readonly int[] s_TF = new int[4 * 256]
1112             {
1113                         // s_TF1
1114                         99,          124,          119,          123,          242,          107,          111,          197,
1115                         48,            1,          103,           43,          254,          215,          171,          118,
1116                        202,          130,          201,          125,          250,           89,           71,          240,
1117                        173,          212,          162,          175,          156,          164,          114,          192,
1118                        183,          253,          147,           38,           54,           63,          247,          204,
1119                         52,          165,          229,          241,          113,          216,           49,           21,
1120                          4,          199,           35,          195,           24,          150,            5,          154,
1121                          7,           18,          128,          226,          235,           39,          178,          117,
1122                          9,          131,           44,           26,           27,          110,           90,          160,
1123                         82,           59,          214,          179,           41,          227,           47,          132,
1124                         83,          209,            0,          237,           32,          252,          177,           91,
1125                        106,          203,          190,           57,           74,           76,           88,          207,
1126                        208,          239,          170,          251,           67,           77,           51,          133,
1127                         69,          249,            2,          127,           80,           60,          159,          168,
1128                         81,          163,           64,          143,          146,          157,           56,          245,
1129                        188,          182,          218,           33,           16,          255,          243,          210,
1130                        205,           12,           19,          236,           95,          151,           68,           23,
1131                        196,          167,          126,           61,          100,           93,           25,          115,
1132                         96,          129,           79,          220,           34,           42,          144,          136,
1133                         70,          238,          184,           20,          222,           94,           11,          219,
1134                        224,           50,           58,           10,           73,            6,           36,           92,
1135                        194,          211,          172,           98,          145,          149,          228,          121,
1136                        231,          200,           55,          109,          141,          213,           78,          169,
1137                        108,           86,          244,          234,          101,          122,          174,            8,
1138                        186,          120,           37,           46,           28,          166,          180,          198,
1139                        232,          221,          116,           31,           75,          189,          139,          138,
1140                        112,           62,          181,          102,           72,            3,          246,           14,
1141                         97,           53,           87,          185,          134,          193,           29,          158,
1142                        225,          248,          152,           17,          105,          217,          142,          148,
1143                        155,           30,          135,          233,          206,           85,           40,          223,
1144                        140,          161,          137,           13,          191,          230,           66,          104,
1145                         65,          153,           45,           15,          176,           84,          187,           22,
1146
1147                         // s_TF2
1148                      25344,        31744,        30464,        31488,        61952,        27392,        28416,        50432,
1149                      12288,          256,        26368,        11008,        65024,        55040,        43776,        30208,
1150                      51712,        33280,        51456,        32000,        64000,        22784,        18176,        61440,
1151                      44288,        54272,        41472,        44800,        39936,        41984,        29184,        49152,
1152                      46848,        64768,        37632,         9728,        13824,        16128,        63232,        52224,
1153                      13312,        42240,        58624,        61696,        28928,        55296,        12544,         5376,
1154                       1024,        50944,         8960,        49920,         6144,        38400,         1280,        39424,
1155                       1792,         4608,        32768,        57856,        60160,         9984,        45568,        29952,
1156                       2304,        33536,        11264,         6656,         6912,        28160,        23040,        40960,
1157                      20992,        15104,        54784,        45824,        10496,        58112,        12032,        33792,
1158                      21248,        53504,            0,        60672,         8192,        64512,        45312,        23296,
1159                      27136,        51968,        48640,        14592,        18944,        19456,        22528,        52992,
1160                      53248,        61184,        43520,        64256,        17152,        19712,        13056,        34048,
1161                      17664,        63744,          512,        32512,        20480,        15360,        40704,        43008,
1162                      20736,        41728,        16384,        36608,        37376,        40192,        14336,        62720,
1163                      48128,        46592,        55808,         8448,         4096,        65280,        62208,        53760,
1164                      52480,         3072,         4864,        60416,        24320,        38656,        17408,         5888,
1165                      50176,        42752,        32256,        15616,        25600,        23808,         6400,        29440,
1166                      24576,        33024,        20224,        56320,         8704,        10752,        36864,        34816,
1167                      17920,        60928,        47104,         5120,        56832,        24064,         2816,        56064,
1168                      57344,        12800,        14848,         2560,        18688,         1536,         9216,        23552,
1169                      49664,        54016,        44032,        25088,        37120,        38144,        58368,        30976,
1170                      59136,        51200,        14080,        27904,        36096,        54528,        19968,        43264,
1171                      27648,        22016,        62464,        59904,        25856,        31232,        44544,         2048,
1172                      47616,        30720,         9472,        11776,         7168,        42496,        46080,        50688,
1173                      59392,        56576,        29696,         7936,        19200,        48384,        35584,        35328,
1174                      28672,        15872,        46336,        26112,        18432,          768,        62976,         3584,
1175                      24832,        13568,        22272,        47360,        34304,        49408,         7424,        40448,
1176                      57600,        63488,        38912,         4352,        26880,        55552,        36352,        37888,
1177                      39680,         7680,        34560,        59648,        52736,        21760,        10240,        57088,
1178                      35840,        41216,        35072,         3328,        48896,        58880,        16896,        26624,
1179                      16640,        39168,        11520,         3840,        45056,        21504,        47872,         5632,
1180
1181                         // s_TF3
1182                    6488064,      8126464,      7798784,      8060928,     15859712,      7012352,      7274496,     12910592,
1183                    3145728,        65536,      6750208,      2818048,     16646144,     14090240,     11206656,      7733248,
1184                   13238272,      8519680,     13172736,      8192000,     16384000,      5832704,      4653056,     15728640,
1185                   11337728,     13893632,     10616832,     11468800,     10223616,     10747904,      7471104,     12582912,
1186                   11993088,     16580608,      9633792,      2490368,      3538944,      4128768,     16187392,     13369344,
1187                    3407872,     10813440,     15007744,     15794176,      7405568,     14155776,      3211264,      1376256,
1188                     262144,     13041664,      2293760,     12779520,      1572864,      9830400,       327680,     10092544,
1189                     458752,      1179648,      8388608,     14811136,     15400960,      2555904,     11665408,      7667712,
1190                     589824,      8585216,      2883584,      1703936,      1769472,      7208960,      5898240,     10485760,
1191                    5373952,      3866624,     14024704,     11730944,      2686976,     14876672,      3080192,      8650752,
1192                    5439488,     13697024,            0,     15532032,      2097152,     16515072,     11599872,      5963776,
1193                    6946816,     13303808,     12451840,      3735552,      4849664,      4980736,      5767168,     13565952,
1194                   13631488,     15663104,     11141120,     16449536,      4390912,      5046272,      3342336,      8716288,
1195                    4521984,     16318464,       131072,      8323072,      5242880,      3932160,     10420224,     11010048,
1196                    5308416,     10682368,      4194304,      9371648,      9568256,     10289152,      3670016,     16056320,
1197                   12320768,     11927552,     14286848,      2162688,      1048576,     16711680,     15925248,     13762560,
1198                   13434880,       786432,      1245184,     15466496,      6225920,      9895936,      4456448,      1507328,
1199                   12845056,     10944512,      8257536,      3997696,      6553600,      6094848,      1638400,      7536640,
1200                    6291456,      8454144,      5177344,     14417920,      2228224,      2752512,      9437184,      8912896,
1201                    4587520,     15597568,     12058624,      1310720,     14548992,      6160384,       720896,     14352384,
1202                   14680064,      3276800,      3801088,       655360,      4784128,       393216,      2359296,      6029312,
1203                   12713984,     13828096,     11272192,      6422528,      9502720,      9764864,     14942208,      7929856,
1204                   15138816,     13107200,      3604480,      7143424,      9240576,     13959168,      5111808,     11075584,
1205                    7077888,      5636096,     15990784,     15335424,      6619136,      7995392,     11403264,       524288,
1206                   12189696,      7864320,      2424832,      3014656,      1835008,     10878976,     11796480,     12976128,
1207                   15204352,     14483456,      7602176,      2031616,      4915200,     12386304,      9109504,      9043968,
1208                    7340032,      4063232,     11862016,      6684672,      4718592,       196608,     16121856,       917504,
1209                    6356992,      3473408,      5701632,     12124160,      8781824,     12648448,      1900544,     10354688,
1210                   14745600,     16252928,      9961472,      1114112,      6881280,     14221312,      9306112,      9699328,
1211                   10158080,      1966080,      8847360,     15269888,     13500416,      5570560,      2621440,     14614528,
1212                    9175040,     10551296,      8978432,       851968,     12517376,     15073280,      4325376,      6815744,
1213                    4259840,     10027008,      2949120,       983040,     11534336,      5505024,     12255232,      1441792,
1214
1215                         // s_TF4
1216                 1660944384,   2080374784,   1996488704,   2063597568,   -234881024,   1795162112,   1862270976,   -989855744,
1217                  805306368,     16777216,   1728053248,    721420288,    -33554432,   -687865856,  -1426063360,   1979711488,
1218                 -905969664,  -2113929216,   -922746880,   2097152000,   -100663296,   1493172224,   1191182336,   -268435456,
1219                -1392508928,   -738197504,  -1577058304,  -1358954496,  -1677721600,  -1543503872,   1912602624,  -1073741824,
1220                -1224736768,    -50331648,  -1828716544,    637534208,    905969664,   1056964608,   -150994944,   -872415232,
1221                  872415232,  -1526726656,   -452984832,   -251658240,   1895825408,   -671088640,    822083584,    352321536,
1222                   67108864,   -956301312,    587202560,  -1023410176,    402653184,  -1778384896,     83886080,  -1711276032,
1223                  117440512,    301989888,  -2147483648,   -503316480,   -352321536,    654311424,  -1308622848,   1962934272,
1224                  150994944,  -2097152000,    738197504,    436207616,    452984832,   1845493760,   1509949440,  -1610612736,
1225                 1375731712,    989855744,   -704643072,  -1291845632,    687865856,   -486539264,    788529152,  -2080374784,
1226                 1392508928,   -788529152,            0,   -318767104,    536870912,    -67108864,  -1325400064,   1526726656,
1227                 1778384896,   -889192448,  -1107296256,    956301312,   1241513984,   1275068416,   1476395008,   -822083584,
1228                 -805306368,   -285212672,  -1442840576,    -83886080,   1124073472,   1291845632,    855638016,  -2063597568,
1229                 1157627904,   -117440512,     33554432,   2130706432,   1342177280,   1006632960,  -1627389952,  -1476395008,
1230                 1358954496,  -1560281088,   1073741824,  -1895825408,  -1845493760,  -1660944384,    939524096,   -184549376,
1231                -1140850688,  -1241513984,   -637534208,    553648128,    268435456,    -16777216,   -218103808,   -771751936,
1232                 -855638016,    201326592,    318767104,   -335544320,   1593835520,  -1761607680,   1140850688,    385875968,
1233                -1006632960,  -1493172224,   2113929216,   1023410176,   1677721600,   1560281088,    419430400,   1929379840,
1234                 1610612736,  -2130706432,   1325400064,   -603979776,    570425344,    704643072,  -1879048192,  -2013265920,
1235                 1174405120,   -301989888,  -1207959552,    335544320,   -570425344,   1577058304,    184549376,   -620756992,
1236                 -536870912,    838860800,    973078528,    167772160,   1224736768,    100663296,    603979776,   1543503872,
1237                -1040187392,   -754974720,  -1409286144,   1644167168,  -1862270976,  -1795162112,   -469762048,   2030043136,
1238                 -419430400,   -939524096,    922746880,   1828716544,  -1929379840,   -721420288,   1308622848,  -1459617792,
1239                 1811939328,   1442840576,   -201326592,   -369098752,   1694498816,   2046820352,  -1375731712,    134217728,
1240                -1174405120,   2013265920,    620756992,    771751936,    469762048,  -1509949440,  -1275068416,   -973078528,
1241                 -402653184,   -587202560,   1946157056,    520093696,   1258291200,  -1124073472,  -1962934272,  -1979711488,
1242                 1879048192,   1040187392,  -1258291200,   1711276032,   1207959552,     50331648,   -167772160,    234881024,
1243                 1627389952,    889192448,   1459617792,  -1191182336,  -2046820352,  -1056964608,    486539264,  -1644167168,
1244                 -520093696,   -134217728,  -1744830464,    285212672,   1761607680,   -654311424,  -1912602624,  -1811939328,
1245                -1694498816,    503316480,  -2030043136,   -385875968,   -838860800,   1426063360,    671088640,   -553648128,
1246                -1946157056,  -1593835520,  -1996488704,    218103808,  -1090519040,   -436207616,   1107296256,   1744830464,
1247                 1090519040,  -1728053248,    754974720,    251658240,  -1342177280,   1409286144,  -1157627904,    369098752 };
1248
1249         private static readonly int[] s_iT = new int[4 * 256]
1250             {
1251                 // s_iT1
1252                 1353184337,   1399144830,  -1012656358,  -1772214470,   -882136261,   -247096033,  -1420232020,  -1828461749,
1253                 1442459680,   -160598355,  -1854485368,    625738485,    -52959921,   -674551099,  -2143013594,  -1885117771,
1254                 1230680542,   1729870373,  -1743852987,   -507445667,     41234371,    317738113,  -1550367091,   -956705941,
1255                 -413167869,  -1784901099,   -344298049,   -631680363,    763608788,   -752782248,    694804553,   1154009486,
1256                 1787413109,   2021232372,   1799248025,   -579749593,  -1236278850,    397248752,   1722556617,  -1271214467,
1257                  407560035,  -2110711067,   1613975959,   1165972322,   -529046351,  -2068943941,    480281086,  -1809118983,
1258                 1483229296,    436028815,  -2022908268,  -1208452270,    601060267,   -503166094,   1468997603,    715871590,
1259                  120122290,     63092015,  -1703164538,  -1526188077,   -226023376,  -1297760477,  -1167457534,   1552029421,
1260                  723308426,  -1833666137,   -252573709,  -1578997426,   -839591323,   -708967162,    526529745,  -1963022652,
1261                -1655493068,  -1604979806,    853641733,   1978398372,    971801355,  -1427152832,    111112542,   1360031421,
1262                 -108388034,   1023860118,  -1375387939,   1186850381,  -1249028975,     90031217,   1876166148,    -15380384,
1263                  620468249,  -1746289194,   -868007799,   2006899047,  -1119688528,  -2004121337,    945494503,   -605108103,
1264                 1191869601,   -384875908,   -920746760,            0,  -2088337399,   1223502642,  -1401941730,   1316117100,
1265                  -67170563,   1446544655,    517320253,    658058550,   1691946762,    564550760,   -783000677,    976107044,
1266                -1318647284,    266819475,   -761860428,  -1634624741,   1338359936,  -1574904735,   1766553434,    370807324,
1267                  179999714,   -450191168,   1138762300,    488053522,    185403662,  -1379431438,  -1180125651,   -928440812,
1268                -2061897385,   1275557295,  -1143105042,    -44007517,  -1624899081,  -1124765092,   -985962940,    880737115,
1269                 1982415755,   -590994485,   1761406390,   1676797112,   -891538985,    277177154,   1076008723,    538035844,
1270                 2099530373,   -130171950,    288553390,   1839278535,   1261411869,   -214912292,   -330136051,   -790380169,
1271                 1813426987,  -1715900247,    -95906799,    577038663,   -997393240,    440397984,   -668172970,   -275762398,
1272                 -951170681,  -1043253031,    -22885748,    906744984,   -813566554,    685669029,    646887386,  -1530942145,
1273                 -459458004,    227702864,  -1681105046,   1648787028,  -1038905866,   -390539120,   1593260334,   -173030526,
1274                -1098883681,   2090061929,  -1456614033,  -1290656305,    999926984,  -1484974064,   1852021992,   2075868123,
1275                  158869197,   -199730834,     28809964,  -1466282109,   1701746150,   2129067946,    147831841,   -420997649,
1276                 -644094022,   -835293366,   -737566742,   -696471511,  -1347247055,    824393514,    815048134,  -1067015627,
1277                  935087732,  -1496677636,  -1328508704,    366520115,   1251476721,   -136647615,    240176511,    804688151,
1278                -1915335306,   1303441219,   1414376140,   -553347356,   -474623586,    461924940,  -1205916479,   2136040774,
1279                   82468509,   1563790337,   1937016826,    776014843,   1511876531,   1389550482,    861278441,    323475053,
1280                -1939744870,   2047648055,  -1911228327,  -1992551445,   -299390514,    902390199,   -303751967,   1018251130,
1281                 1507840668,   1064563285,   2043548696,  -1086863501,   -355600557,   1537932639,    342834655,  -2032450440,
1282                -2114736182,   1053059257,    741614648,   1598071746,   1925389590,    203809468,  -1958134744,   1100287487,
1283                 1895934009,   -558691320,  -1662733096,  -1866377628,   1636092795,   1890988757,   1952214088,   1113045200,
1284
1285                 // s_iT2
1286                -1477160624,   1698790995,  -1541989693,   1579629206,   1806384075,   1167925233,   1492823211,     65227667,
1287                  -97509291,   1836494326,   1993115793,   1275262245,   -672837636,   -886389289,   1144333952,  -1553812081,
1288                 1521606217,    465184103,    250234264,  -1057071647,   1966064386,   -263421678,  -1756983901,   -103584826,
1289                 1603208167,  -1668147819,   2054012907,   1498584538,  -2084645843,    561273043,   1776306473,   -926314940,
1290                -1983744662,   2039411832,   1045993835,   1907959773,   1340194486,  -1383534569,  -1407137434,    986611124,
1291                 1256153880,    823846274,    860985184,   2136171077,   2003087840,  -1368671356,  -1602093540,    722008468,
1292                 1749577816,    -45773031,   1826526343,   -126135625,   -747394269,     38499042,  -1893735593,  -1420466646,
1293                  686535175,  -1028313341,   2076542618,    137876389,  -2027409166,  -1514200142,   1778582202,  -2112426660,
1294                  483363371,  -1267095662,   -234359824,   -496415071,   -187013683,  -1106966827,   1647628575,    -22625142,
1295                 1395537053,   1442030240,   -511048398,   -336157579,   -326956231,   -278904662,  -1619960314,    275692881,
1296                -1977532679,    115185213,     88006062,  -1108980410,  -1923837515,   1573155077,   -737803153,    357589247,
1297                  -73918172,   -373434729,   1128303052,  -1629919369,   1122545853,  -1953953912,   1528424248,   -288851493,
1298                  175939911,    256015593,    512030921,            0,  -2038429309,   -315936184,   1880170156,   1918528590,
1299                  -15794693,    948244310,   -710001378,    959264295,   -653325724,  -1503893471,   1415289809,    775300154,
1300                 1728711857,   -413691121,  -1762741038,  -1852105826,   -977239985,    551313826,   1266113129,    437394454,
1301                -1164713462,    715178213,   -534627261,    387650077,    218697227,   -947129683,  -1464455751,  -1457646392,
1302                  435246981,    125153100,   -577114437,   1618977789,    637663135,   -177054532,    996558021,   2130402100,
1303                  692292470,   -970732580,    -51530136,   -236668829,   -600713270,  -2057092592,    580326208,    298222624,
1304                  608863613,   1035719416,    855223825,  -1591097491,    798891339,    817028339,   1384517100,   -473860144,
1305                  380840812,  -1183798887,   1217663482,   1693009698,  -1929598780,   1072734234,    746411736,  -1875696913,
1306                 1313441735,   -784803391,  -1563783938,    198481974,  -2114607409,   -562387672,  -1900553690,  -1079165020,
1307                -1657131804,  -1837608947,   -866162021,   1182684258,    328070850,  -1193766680,   -147247522,  -1346141451,
1308                -2141347906,  -1815058052,    768962473,    304467891,  -1716729797,   2098729127,   1671227502,  -1153705093,
1309                 2015808777,    408514292,  -1214583807,  -1706064984,   1855317605,   -419452290,   -809754360,   -401215514,
1310                -1679312167,    913263310,    161475284,   2091919830,  -1297862225,    591342129,  -1801075152,   1721906624,
1311                -1135709129,   -897385306,   -795811664,   -660131051,  -1744506550,   -622050825,   1355644686,   -158263505,
1312                 -699566451,  -1326496947,   1303039060,     76997855,  -1244553501,  -2006299621,    523026872,   1365591679,
1313                 -362898172,    898367837,   1955068531,   1091304238,    493335386,   -757362094,   1443948851,   1205234963,
1314                 1641519756,    211892090,    351820174,   1007938441,    665439982,   -916342987,   -451091987,  -1320715716,
1315                 -539845543,   1945261375,   -837543815,    935818175,   -839429142,  -1426235557,   1866325780,   -616269690,
1316                 -206583167,   -999769794,    874788908,   1084473951,  -1021503886,    635616268,   1228679307,  -1794244799,
1317                   27801969,  -1291056930,   -457910116,  -1051302768,  -2067039391,  -1238182544,   1550600308,   1471729730,
1318
1319                 // s_iT3
1320                 -195997529,   1098797925,    387629988,    658151006,  -1422144661,  -1658851003,    -89347240,   -481586429,
1321                  807425530,   1991112301,   -863465098,     49620300,   -447742761,    717608907,    891715652,   1656065955,
1322                -1310832294,  -1171953893,   -364537842,    -27401792,    801309301,   1283527408,   1183687575,   -747911431,
1323                -1895569569,  -1844079204,   1841294202,   1385552473,  -1093390973,   1951978273,   -532076183,   -913423160,
1324                -1032492407,  -1896580999,   1486449470,  -1188569743,   -507595185,  -1997531219,    550069932,   -830622662,
1325                 -547153846,    451248689,   1368875059,   1398949247,   1689378935,   1807451310,  -2114052960,    150574123,
1326                 1215322216,   1167006205,   -560691348,   2069018616,   1940595667,   1265820162,    534992783,   1432758955,
1327                 -340654296,  -1255210046,   -981034373,    936617224,    674296455,  -1088179547,     50510442,    384654466,
1328                 -813028580,   2041025204,    133427442,   1766760930,   -630862348,     84334014,    886120290,  -1497068802,
1329                  775200083,   -207445931,  -1979370783,   -156994069,  -2096416276,   1614850799,   1901987487,   1857900816,
1330                  557775242,   -577356538,   1054715397,   -431143235,   1418835341,   -999226019,    100954068,   1348534037,
1331                -1743182597,  -1110009879,   1082772547,   -647530594,   -391070398,  -1995994997,    434583643,   -931537938,
1332                 2090944266,   1115482383,  -2064070370,            0,  -2146860154,    724715757,    287222896,   1517047410,
1333                  251526143,  -2062592456,  -1371726123,    758523705,    252339417,   1550328230,   1536938324,    908343854,
1334                  168604007,   1469255655,   -290139498,  -1692688751,  -1065332795,   -597581280,   2002413899,    303830554,
1335                -1813902662,  -1597971158,    574374880,    454171927,    151915277,  -1947030073,  -1238517336,    504678569,
1336                 -245922535,   1974422535,  -1712407587,   2141453664,     33005350,   1918680309,   1715782971,    -77908866,
1337                 1133213225,    600562886,   -306812676,   -457677839,    836225756,   1665273989,  -1760346078,   -964419567,
1338                 1250262308,  -1143801795,   -106032846,    700935585,  -1642247377,  -1294142672,  -2045907886,  -1049112349,
1339                -1288999914,   1890163129,  -1810761144,   -381214108,    -56048500,   -257942977,   2102843436,    857927568,
1340                 1233635150,    953795025,   -896729438,   -728222197,   -173617279,   2057644254,  -1210440050,  -1388337985,
1341                  976020637,   2018512274,   1600822220,   2119459398,  -1913208301,   -661591880,    959340279,  -1014827601,
1342                 1570750080,   -798393197,   -714102483,    634368786,  -1396163687,    403744637,  -1662488989,   1004239803,
1343                  650971512,   1500443672,  -1695809097,   1334028442,  -1780062866,     -5603610,  -1138685745,    368043752,
1344                 -407184997,   1867173430,  -1612000247,  -1339435396,  -1540247630,   1059729699,  -1513738092,  -1573535642,
1345                 1316239292,  -2097371446,  -1864322864,  -1489824296,     82922136,   -331221030,   -847311280,  -1860751370,
1346                 1299615190,   -280801872,  -1429449651,  -1763385596,   -778116171,   1783372680,    750893087,   1699118929,
1347                 1587348714,  -1946067659,  -2013629580,    201010753,   1739807261,   -611167534,    283718486,   -697494713,
1348                 -677737375,  -1590199796,   -128348652,    334203196,  -1446056409,   1639396809,    484568549,   1199193265,
1349                 -761505313,   -229294221,    337148366,   -948715721,   -145495347,    -44082262,   1038029935,   1148749531,
1350                -1345682957,   1756970692,    607661108,  -1547542720,    488010435,   -490992603,   1009290057,    234832277,
1351                -1472630527,    201907891,  -1260872476,   1449431233,   -881106556,    852848822,   1816687708,  -1194311081,
1352
1353                 // s_iT4
1354                 1364240372,   2119394625,    449029143,    982933031,   1003187115,    535905693,  -1398056710,   1267925987,
1355                  542505520,  -1376359050,  -2003732788,   -182105086,   1341970405,   -975713494,    645940277,  -1248877726,
1356                 -565617999,    627514298,   1167593194,   1575076094,  -1023249105,  -2129465268,  -1918658746,   1808202195,
1357                   65494927,    362126482,  -1075086739,  -1780852398,   -735214658,   1490231668,   1227450848,  -1908094775,
1358                 1969916354,   -193431154,  -1721024936,    668823993,  -1095348255,   -266883704,   -916018144,   2108963534,
1359                 1662536415,   -444452582,  -1755303087,   1648721747,  -1310689436,  -1148932501,    -31678335,   -107730168,
1360                 1884842056,  -1894122171,  -1803064098,   1387788411,  -1423715469,   1927414347,   -480800993,   1714072405,
1361                -1308153621,    788775605,  -2036696123,   -744159177,    821200680,    598910399,     45771267,   -312704490,
1362                -1976886065,  -1483557767,   -202313209,   1319232105,   1707996378,    114671109,   -786472396,   -997523802,
1363                  882725678,  -1566550541,     87220618,  -1535775754,    188345475,   1084944224,   1577492337,  -1118760850,
1364                 1056541217,  -1774385443,   -575797954,   1296481766,  -1850372780,   1896177092,     74437638,   1627329872,
1365                  421854104,   -694687299,  -1983102144,   1735892697,  -1329773848,    126389129,   -415737063,   2044456648,
1366                -1589179780,   2095648578,   -121037180,            0,    159614592,    843640107,    514617361,   1817080410,
1367                  -33816818,    257308805,   1025430958,    908540205,    174381327,   1747035740,  -1680780197,    607792694,
1368                  212952842,  -1827674281,  -1261267218,    463376795,  -2142255680,   1638015196,   1516850039,    471210514,
1369                 -502613357,  -1058723168,   1011081250,    303896347,    235605257,   -223492213,    767142070,    348694814,
1370                 1468340721,  -1353971851,   -289677927,  -1543675777,   -140564991,   1555887474,   1153776486,   1530167035,
1371                -1955190461,   -874723805,  -1234633491,  -1201409564,   -674571215,   1108378979,    322970263,  -2078273082,
1372                -2055396278,   -755483205,  -1374604551,   -949116631,    491466654,   -588042062,    233591430,   2010178497,
1373                  728503987,  -1449543312,    301615252,   1193436393,  -1463513860,  -1608892432,   1457007741,    586125363,
1374                -2016981431,   -641609416,  -1929469238,  -1741288492,  -1496350219,  -1524048262,   -635007305,   1067761581,
1375                  753179962,   1343066744,   1788595295,   1415726718,   -155053171,  -1863796520,    777975609,  -2097827901,
1376                -1614905251,   1769771984,   1873358293,   -810347995,   -935618132,    279411992,   -395418724,   -612648133,
1377                 -855017434,   1861490777,   -335431782,  -2086102449,   -429560171,  -1434523905,    554225596,   -270079979,
1378                -1160143897,   1255028335,   -355202657,    701922480,    833598116,    707863359,   -969894747,    901801634,
1379                 1949809742,    -56178046,   -525283184,    857069735,   -246769660,   1106762476,   2131644621,    389019281,
1380                 1989006925,   1129165039,   -866890326,   -455146346,  -1629243951,   1276872810,  -1044898004,   1182749029,
1381                -1660622242,     22885772,    -93096825,    -80854773,  -1285939865,  -1840065829,   -382511600,   1829980118,
1382                -1702075945,    930745505,   1502483704,   -343327725,   -823253079,  -1221211807,   -504503012,   2050797895,
1383                -1671831598,   1430221810,    410635796,   1941911495,   1407897079,   1599843069,   -552308931,   2022103876,
1384                 -897453137,  -1187068824,    942421028,  -1033944925,    376619805,  -1140054558,    680216892,    -12479219,
1385                  963707304,    148812556,   -660806476,   1687208278,   2069988555,   -714033614,   1215585388,   -800958536 };
1386
1387         private static readonly int[] s_iTF = new int[4 * 256]
1388             {
1389                         // s_iTF1
1390                         82,            9,          106,          213,           48,           54,          165,           56,
1391                        191,           64,          163,          158,          129,          243,          215,          251,
1392                        124,          227,           57,          130,          155,           47,          255,          135,
1393                         52,          142,           67,           68,          196,          222,          233,          203,
1394                         84,          123,          148,           50,          166,          194,           35,           61,
1395                        238,           76,          149,           11,           66,          250,          195,           78,
1396                          8,           46,          161,          102,           40,          217,           36,          178,
1397                        118,           91,          162,           73,          109,          139,          209,           37,
1398                        114,          248,          246,          100,          134,          104,          152,           22,
1399                        212,          164,           92,          204,           93,          101,          182,          146,
1400                        108,          112,           72,           80,          253,          237,          185,          218,
1401                         94,           21,           70,           87,          167,          141,          157,          132,
1402                        144,          216,          171,            0,          140,          188,          211,           10,
1403                        247,          228,           88,            5,          184,          179,           69,            6,
1404                        208,           44,           30,          143,          202,           63,           15,            2,
1405                        193,          175,          189,            3,            1,           19,          138,          107,
1406                         58,          145,           17,           65,           79,          103,          220,          234,
1407                        151,          242,          207,          206,          240,          180,          230,          115,
1408                        150,          172,          116,           34,          231,          173,           53,          133,
1409                        226,          249,           55,          232,           28,          117,          223,          110,
1410                         71,          241,           26,          113,           29,           41,          197,          137,
1411                        111,          183,           98,           14,          170,           24,          190,           27,
1412                        252,           86,           62,           75,          198,          210,          121,           32,
1413                        154,          219,          192,          254,          120,          205,           90,          244,
1414                         31,          221,          168,           51,          136,            7,          199,           49,
1415                        177,           18,           16,           89,           39,          128,          236,           95,
1416                         96,           81,          127,          169,           25,          181,           74,           13,
1417                         45,          229,          122,          159,          147,          201,          156,          239,
1418                        160,          224,           59,           77,          174,           42,          245,          176,
1419                        200,          235,          187,           60,          131,           83,          153,           97,
1420                         23,           43,            4,          126,          186,          119,          214,           38,
1421                        225,          105,           20,           99,           85,           33,           12,          125,
1422
1423                         // s_iTF2
1424                      20992,         2304,        27136,        54528,        12288,        13824,        42240,        14336,
1425                      48896,        16384,        41728,        40448,        33024,        62208,        55040,        64256,
1426                      31744,        58112,        14592,        33280,        39680,        12032,        65280,        34560,
1427                      13312,        36352,        17152,        17408,        50176,        56832,        59648,        51968,
1428                      21504,        31488,        37888,        12800,        42496,        49664,         8960,        15616,
1429                      60928,        19456,        38144,         2816,        16896,        64000,        49920,        19968,
1430                       2048,        11776,        41216,        26112,        10240,        55552,         9216,        45568,
1431                      30208,        23296,        41472,        18688,        27904,        35584,        53504,         9472,
1432                      29184,        63488,        62976,        25600,        34304,        26624,        38912,         5632,
1433                      54272,        41984,        23552,        52224,        23808,        25856,        46592,        37376,
1434                      27648,        28672,        18432,        20480,        64768,        60672,        47360,        55808,
1435                      24064,         5376,        17920,        22272,        42752,        36096,        40192,        33792,
1436                      36864,        55296,        43776,            0,        35840,        48128,        54016,         2560,
1437                      63232,        58368,        22528,         1280,        47104,        45824,        17664,         1536,
1438                      53248,        11264,         7680,        36608,        51712,        16128,         3840,          512,
1439                      49408,        44800,        48384,          768,          256,         4864,        35328,        27392,
1440                      14848,        37120,         4352,        16640,        20224,        26368,        56320,        59904,
1441                      38656,        61952,        52992,        52736,        61440,        46080,        58880,        29440,
1442                      38400,        44032,        29696,         8704,        59136,        44288,        13568,        34048,
1443                      57856,        63744,        14080,        59392,         7168,        29952,        57088,        28160,
1444                      18176,        61696,         6656,        28928,         7424,        10496,        50432,        35072,
1445                      28416,        46848,        25088,         3584,        43520,         6144,        48640,         6912,
1446                      64512,        22016,        15872,        19200,        50688,        53760,        30976,         8192,
1447                      39424,        56064,        49152,        65024,        30720,        52480,        23040,        62464,
1448                       7936,        56576,        43008,        13056,        34816,         1792,        50944,        12544,
1449                      45312,         4608,         4096,        22784,         9984,        32768,        60416,        24320,
1450                      24576,        20736,        32512,        43264,         6400,        46336,        18944,         3328,
1451                      11520,        58624,        31232,        40704,        37632,        51456,        39936,        61184,
1452                      40960,        57344,        15104,        19712,        44544,        10752,        62720,        45056,
1453                      51200,        60160,        47872,        15360,        33536,        21248,        39168,        24832,
1454                       5888,        11008,         1024,        32256,        47616,        30464,        54784,         9728,
1455                      57600,        26880,         5120,        25344,        21760,         8448,         3072,        32000,
1456
1457                         // s_iTF3
1458                    5373952,       589824,      6946816,     13959168,      3145728,      3538944,     10813440,      3670016,
1459                   12517376,      4194304,     10682368,     10354688,      8454144,     15925248,     14090240,     16449536,
1460                    8126464,     14876672,      3735552,      8519680,     10158080,      3080192,     16711680,      8847360,
1461                    3407872,      9306112,      4390912,      4456448,     12845056,     14548992,     15269888,     13303808,
1462                    5505024,      8060928,      9699328,      3276800,     10878976,     12713984,      2293760,      3997696,
1463                   15597568,      4980736,      9764864,       720896,      4325376,     16384000,     12779520,      5111808,
1464                     524288,      3014656,     10551296,      6684672,      2621440,     14221312,      2359296,     11665408,
1465                    7733248,      5963776,     10616832,      4784128,      7143424,      9109504,     13697024,      2424832,
1466                    7471104,     16252928,     16121856,      6553600,      8781824,      6815744,      9961472,      1441792,
1467                   13893632,     10747904,      6029312,     13369344,      6094848,      6619136,     11927552,      9568256,
1468                    7077888,      7340032,      4718592,      5242880,     16580608,     15532032,     12124160,     14286848,
1469                    6160384,      1376256,      4587520,      5701632,     10944512,      9240576,     10289152,      8650752,
1470                    9437184,     14155776,     11206656,            0,      9175040,     12320768,     13828096,       655360,
1471                   16187392,     14942208,      5767168,       327680,     12058624,     11730944,      4521984,       393216,
1472                   13631488,      2883584,      1966080,      9371648,     13238272,      4128768,       983040,       131072,
1473                   12648448,     11468800,     12386304,       196608,        65536,      1245184,      9043968,      7012352,
1474                    3801088,      9502720,      1114112,      4259840,      5177344,      6750208,     14417920,     15335424,
1475                    9895936,     15859712,     13565952,     13500416,     15728640,     11796480,     15073280,      7536640,
1476                    9830400,     11272192,      7602176,      2228224,     15138816,     11337728,      3473408,      8716288,
1477                   14811136,     16318464,      3604480,     15204352,      1835008,      7667712,     14614528,      7208960,
1478                    4653056,     15794176,      1703936,      7405568,      1900544,      2686976,     12910592,      8978432,
1479                    7274496,     11993088,      6422528,       917504,     11141120,      1572864,     12451840,      1769472,
1480                   16515072,      5636096,      4063232,      4915200,     12976128,     13762560,      7929856,      2097152,
1481                   10092544,     14352384,     12582912,     16646144,      7864320,     13434880,      5898240,     15990784,
1482                    2031616,     14483456,     11010048,      3342336,      8912896,       458752,     13041664,      3211264,
1483                   11599872,      1179648,      1048576,      5832704,      2555904,      8388608,     15466496,      6225920,
1484                    6291456,      5308416,      8323072,     11075584,      1638400,     11862016,      4849664,       851968,
1485                    2949120,     15007744,      7995392,     10420224,      9633792,     13172736,     10223616,     15663104,
1486                   10485760,     14680064,      3866624,      5046272,     11403264,      2752512,     16056320,     11534336,
1487                   13107200,     15400960,     12255232,      3932160,      8585216,      5439488,     10027008,      6356992,
1488                    1507328,      2818048,       262144,      8257536,     12189696,      7798784,     14024704,      2490368,
1489                   14745600,      6881280,      1310720,      6488064,      5570560,      2162688,       786432,      8192000,
1490
1491                         // s_iTF4
1492                 1375731712,    150994944,   1778384896,   -721420288,    805306368,    905969664,  -1526726656,    939524096,
1493                -1090519040,   1073741824,  -1560281088,  -1644167168,  -2130706432,   -218103808,   -687865856,    -83886080,
1494                 2080374784,   -486539264,    956301312,  -2113929216,  -1694498816,    788529152,    -16777216,  -2030043136,
1495                  872415232,  -1912602624,   1124073472,   1140850688,  -1006632960,   -570425344,   -385875968,   -889192448,
1496                 1409286144,   2063597568,  -1811939328,    838860800,  -1509949440,  -1040187392,    587202560,   1023410176,
1497                 -301989888,   1275068416,  -1795162112,    184549376,   1107296256,   -100663296,  -1023410176,   1308622848,
1498                  134217728,    771751936,  -1593835520,   1711276032,    671088640,   -654311424,    603979776,  -1308622848,
1499                 1979711488,   1526726656,  -1577058304,   1224736768,   1828716544,  -1962934272,   -788529152,    620756992,
1500                 1912602624,   -134217728,   -167772160,   1677721600,  -2046820352,   1744830464,  -1744830464,    369098752,
1501                 -738197504,  -1543503872,   1543503872,   -872415232,   1560281088,   1694498816,  -1241513984,  -1845493760,
1502                 1811939328,   1879048192,   1207959552,   1342177280,    -50331648,   -318767104,  -1191182336,   -637534208,
1503                 1577058304,    352321536,   1174405120,   1459617792,  -1493172224,  -1929379840,  -1660944384,  -2080374784,
1504                -1879048192,   -671088640,  -1426063360,            0,  -1946157056,  -1140850688,   -754974720,    167772160,
1505                 -150994944,   -469762048,   1476395008,     83886080,  -1207959552,  -1291845632,   1157627904,    100663296,
1506                 -805306368,    738197504,    503316480,  -1895825408,   -905969664,   1056964608,    251658240,     33554432,
1507                -1056964608,  -1358954496,  -1124073472,     50331648,     16777216,    318767104,  -1979711488,   1795162112,
1508                  973078528,  -1862270976,    285212672,   1090519040,   1325400064,   1728053248,   -603979776,   -369098752,
1509                -1761607680,   -234881024,   -822083584,   -838860800,   -268435456,  -1275068416,   -436207616,   1929379840,
1510                -1778384896,  -1409286144,   1946157056,    570425344,   -419430400,  -1392508928,    889192448,  -2063597568,
1511                 -503316480,   -117440512,    922746880,   -402653184,    469762048,   1962934272,   -553648128,   1845493760,
1512                 1191182336,   -251658240,    436207616,   1895825408,    486539264,    687865856,   -989855744,  -1996488704,
1513                 1862270976,  -1224736768,   1644167168,    234881024,  -1442840576,    402653184,  -1107296256,    452984832,
1514                  -67108864,   1442840576,   1040187392,   1258291200,   -973078528,   -771751936,   2030043136,    536870912,
1515                -1711276032,   -620756992,  -1073741824,    -33554432,   2013265920,   -855638016,   1509949440,   -201326592,
1516                  520093696,   -587202560,  -1476395008,    855638016,  -2013265920,    117440512,   -956301312,    822083584,
1517                -1325400064,    301989888,    268435456,   1493172224,    654311424,  -2147483648,   -335544320,   1593835520,
1518                 1610612736,   1358954496,   2130706432,  -1459617792,    419430400,  -1258291200,   1241513984,    218103808,
1519                  754974720,   -452984832,   2046820352,  -1627389952,  -1828716544,   -922746880,  -1677721600,   -285212672,
1520                -1610612736,   -536870912,    989855744,   1291845632,  -1375731712,    704643072,   -184549376,  -1342177280,
1521                 -939524096,   -352321536,  -1157627904,   1006632960,  -2097152000,   1392508928,  -1728053248,   1627389952,
1522                  385875968,    721420288,     67108864,   2113929216,  -1174405120,   1996488704,   -704643072,    637534208,
1523                 -520093696,   1761607680,    335544320,   1660944384,   1426063360,    553648128,    201326592,   2097152000 };
1524     }
1525 }