/*
CryptoJS v3.1.2
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
(function (Math) {

    // Shortcuts

    var C = CryptoJS;

    var C_lib = C.lib;

    var WordArray = C_lib.WordArray;

    var Hasher = C_lib.Hasher;

    var C_algo = C.algo;



    // Initialization and round constants tables

    var H = [];

    var K = [];



    // Compute constants

    (function () {

        function isPrime(n) {

            var sqrtN = Math.sqrt(n);

            for (var factor = 2; factor <= sqrtN; factor++) {

                if (!(n % factor)) {

                    return false;

                }

            }



            return true;

        }



        function getFractionalBits(n) {

            return ((n - (n | 0)) * 0x100000000) | 0;

        }



        var n = 2;

        var nPrime = 0;

        while (nPrime < 64) {

            if (isPrime(n)) {

                if (nPrime < 8) {

                    H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));

                }

                K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));



                nPrime++;

            }



            n++;

        }

    }());



    // Reusable object

    var W = [];



    /**

     * SHA-256 hash algorithm.

     */

    var SHA256 = C_algo.SHA256 = Hasher.extend({

        _doReset: function () {

            this._hash = new WordArray.init(H.slice(0));

        },



        _doProcessBlock: function (M, offset) {

            // Shortcut

            var H = this._hash.words;



            // Working variables

            var a = H[0];

            var b = H[1];

            var c = H[2];

            var d = H[3];

            var e = H[4];

            var f = H[5];

            var g = H[6];

            var h = H[7];



            // Computation

            for (var i = 0; i < 64; i++) {

                if (i < 16) {

                    W[i] = M[offset + i] | 0;

                } else {

                    var gamma0x = W[i - 15];

                    var gamma0  = ((gamma0x << 25) | (gamma0x >>> 7))  ^

                                  ((gamma0x << 14) | (gamma0x >>> 18)) ^

                                   (gamma0x >>> 3);



                    var gamma1x = W[i - 2];

                    var gamma1  = ((gamma1x << 15) | (gamma1x >>> 17)) ^

                                  ((gamma1x << 13) | (gamma1x >>> 19)) ^

                                   (gamma1x >>> 10);



                    W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];

                }



                var ch  = (e & f) ^ (~e & g);

                var maj = (a & b) ^ (a & c) ^ (b & c);



                var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));

                var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7)  | (e >>> 25));



                var t1 = h + sigma1 + ch + K[i] + W[i];

                var t2 = sigma0 + maj;



                h = g;

                g = f;

                f = e;

                e = (d + t1) | 0;

                d = c;

                c = b;

                b = a;

                a = (t1 + t2) | 0;

            }



            // Intermediate hash value

            H[0] = (H[0] + a) | 0;

            H[1] = (H[1] + b) | 0;

            H[2] = (H[2] + c) | 0;

            H[3] = (H[3] + d) | 0;

            H[4] = (H[4] + e) | 0;

            H[5] = (H[5] + f) | 0;

            H[6] = (H[6] + g) | 0;

            H[7] = (H[7] + h) | 0;

        },



        _doFinalize: function () {

            // Shortcuts

            var data = this._data;

            var dataWords = data.words;



            var nBitsTotal = this._nDataBytes * 8;

            var nBitsLeft = data.sigBytes * 8;



            // Add padding

            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);

            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);

            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;

            data.sigBytes = dataWords.length * 4;



            // Hash final blocks

            this._process();



            // Return final computed hash

            return this._hash;

        },



        clone: function () {

            var clone = Hasher.clone.call(this);

            clone._hash = this._hash.clone();



            return clone;

        }

    });



    /**

     * Shortcut function to the hasher's object interface.

     *

     * @param {WordArray|string} message The message to hash.

     *

     * @return {WordArray} The hash.

     *

     * @static

     *

     * @example

     *

     *     var hash = CryptoJS.SHA256('message');

     *     var hash = CryptoJS.SHA256(wordArray);

     */

    C.SHA256 = Hasher._createHelper(SHA256);



    /**

     * Shortcut function to the HMAC's object interface.

     *

     * @param {WordArray|string} message The message to hash.

     * @param {WordArray|string} key The secret key.

     *

     * @return {WordArray} The HMAC.

     *

     * @static

     *

     * @example

     *

     *     var hmac = CryptoJS.HmacSHA256(message, key);

     */

    C.HmacSHA256 = Hasher._createHmacHelper(SHA256);

}(Math));

