# Commits

committed 23dc58e

Initial commit.

• Participants

# File LatinSquare.js

`+(function() {`
`+  /**`
`+   * Defines a Latin Square object. The square is represented by an array`
`+   * of size NxN. If a size is not specified, then the size defaults to 3x3.`
`+   * Elements of the square are addressed from the top left to bottom right.`
`+   * That is, in the following square:`
`+   *`
`+   * | 1 2 3 |`
`+   * | 2 3 1 |`
`+   * | 3 1 2 |`
`+   *`
`+   * The element at position (2,3) is 1. That is, the value of row 2`
`+   * position 3 is 1.`
`+   *`
`+   * The symbols parameter defines the list of symbols that will be used`
`+   * in the square. If the parameter is not passed, it is assumed the symbols`
`+   * are to be the list of integers 1...n (where n is square size).`
`+   *`
`+   * The func parameter defines the function for determing the placement of`
`+   * symbols in the square. This function should be congruent to the size`
`+   * of the square and return the index of the element in the symbols array.`
`+   * For example, the default function for the default square size of 3 is:`
`+   *`
`+   *   f(x, y) = (x + y) % 3 => f(0, 1) = 1   [symbol = '2']`
`+   *`
`+   * where x is the column and y is the row in the square. Any such function`
`+   * as this can be used, simply pass in a function reference. Otherwise, the`
`+   * function described above will be used. For a thorough explanation, see`
`+   * http://www.math.utah.edu/~carlson/mathcircles/magic.pdf`
`+   *`
`+   * Note: the function passed in must have the same signature as the default`
`+   * function. That is, "var yourFunction = function(x, y);".`
`+   *`
`+   * @param {number} n       The desired size of the square. 3 is the default.`
`+   * @param {array}  symbols The list of symbols to use in the square.`
`+   * @param {function} func  A function to be used for determing symbol placement.`
`+   */`
`+  LatinSquare = function(n, symbols, func) {`
`+    var i = 0;`
`+`
`+    if (n && symbols && n !== symbols.length) {`
`+      throw new Error("Symbols length must match square size.");`
`+    }`
`+`
`+    if ( !(this instanceof LatinSquare) ) {`
`+      return new LatinSquare(n);`
`+    }`
`+`
`+    this.symbols = [];`
`+`
`+    if (n) {`
`+      this.square = Array(n);`
`+      for (i = 0; i < n; i += 1) {`
`+        this.square[i] = Array(n);`
`+      }`
`+`
`+      this.rows = n;`
`+      this.cols = n;`
`+    } else {`
`+      // We will assume the user wants a standard 3x3 square.`
`+      n = 3;`
`+      this.square =`
`+        [`
`+          [null,null,null],`
`+          [null,null,null],`
`+          [null,null,null]`
`+        ];`
`+      this.rows = 3;`
`+      this.cols = 3;`
`+    }`
`+`
`+    if (symbols) {`
`+      this.symbols = symbols;`
`+    } else {`
`+      for (i = 0; i < n; i += 1) {`
`+        this.symbols.push(i + 1);`
`+      }`
`+    }`
`+`
`+    if (func && typeof func === 'function') {`
`+      this.userfunc = func;`
`+    }`
`+  };`
`+`
`+  /**`
`+   * Populate the square with values based on the mapping`
`+   * function and the symbols array.`
`+   */`
`+  LatinSquare.prototype.fill = function() {`
`+    var i, j;`
`+`
`+    for (i = 0; i < this.rows; i += 1) {`
`+      for (j = 0; j < this.cols; j += 1) {`
`+        this.set(i, j);`
`+      }`
`+    }`
`+  };`
`+`
`+  /**`
`+   * Retrieve a value from the square given its row and column position.`
`+   * The top left of the square is (0,0).`
`+   *`
`+   * @param  {number} row            The x position of the value.`
`+   * @param  {number} col            The y position of the value.`
`+   * @return {number,null,undefined} The value.`
`+   */`
`+  LatinSquare.prototype.get = function(row, col) {`
`+    return this.square[row][col];`
`+  };`
`+`
`+  /**`
`+   * Set the value of a position in the square. The value is normally a lettter`
`+   * or a number, but it can be any type of object.`
`+   *`
`+   * @param {number} row   The x position.`
`+   * @param {number} col   The y position.`
`+   */`
`+  LatinSquare.prototype.set = function(row, col) {`
`+    if (this.userfunc) {`
`+      this.square[row][col] = this.symbols[this.userfunc(row, col)];`
`+    } else {`
`+      this.square[row][col] = this.symbols[this._f(row, col)];`
`+    }`
`+  };`
`+`
`+  /**`
`+   * A private method used to calculate which symbol to set`
`+   * for a given position. This should be overridden by a user supplied`
`+   * function.`
`+   *`
`+   * @param  {number} x The column part of the position.`
`+   * @param  {number} y The row part of the position.`
`+   * @return {object}   The symbol for the position.`
`+   */`
`+  LatinSquare.prototype._f = function(x, y) {`
`+    return (x + y) % this.symbols.length;`
`+  };`
`+`
`+  // Return our LatinSquare object.`
`+  if (exports) {`
`+    // node.js`
`+    exports.LatinSquare = LatinSquare;`
`+  } else {`
`+    return LatinSquare;`
`+  }`
`+}());`

# File RandomNumber.js

`+(function() {`
`+  var seedRandom, sha1;`
`+`
`+  if (exports) {`
`+    // node.js`
`+    // If you are not loading this script through node.js, then`
`+    // the following scripts should be loaded in such a fashion that`
`+    // they are in this script's scope.`
`+    seedRandom = require('./seedrandom.js');`
`+    sha1 = require('./sha1.js');`
`+  } else {`
`+    seedRandom = (seedrandom) ? seedrandom : null;`
`+    sha1 = (Sha1) ? Sha1 : null;`
`+  }`
`+`
`+  if (seedRandom === null || sha1 === null) {`
`+    throw new ReferenceError(`
`+      "The seedrandom and Sha1 libraries are required by RandomNumber.");`
`+  }`
`+`
`+  RandomNumber = function() {`
`+    if ( !(this instanceof RandomNumber) ) {`
`+      return new RandomNumber();`
`+    }`
`+  };`
`+`
`+  /**`
`+   * Indicates if the instance's RNG has been seeded. If you wish to re-seed`
`+   * the RNG, e.g. to use your own RandomNumber.SEED, then set this to false.`
`+   * Once the RNG has been seeded, this will be set to true.`
`+   *`
`+   * @type {Boolean}`
`+   */`
`+  RandomNumber.prototype.isSeeded = false;`
`+`
`+  /**`
`+   * A constant that is used to seed the random number generator. If you wish`
`+   * to override this seed with your own, then simply define your own`
`+   * RandomNumber.SEED property and set RandomNumber.isSeeded to false.`
`+   *`
`+   * @return {string} A string to be used as a seed.`
`+   */`
`+  RandomNumber.prototype.SEED = (function() {`
`+    // This seed algorithm attempts to make it difficult to re-generate the`
`+    // same seed multiple times by using three different points in time as the`
`+    // basis for a calculation.`
`+    var s = {};`
`+`
`+    s.a = (new Date()).getTime();`
`+    s.b = (new Date()).getTime() + Math.floor(Math.sqrt(s.a));`
`+    s.c = (new Date()).getTime() + Math.floor(Math.sqrt(s.b));`
`+`
`+    // Normalize our values so that they don't overflow the final calculation.`
`+    s.a = Math.floor(+(s.a.toString().substr(-5)) / 1000);`
`+    s.b = Math.floor(+(s.b.toString().substr(-5)) / 1000);`
`+    s.c = Math.floor(+(s.c.toString().substr(-5)) / 1000);`
`+`
`+    // This should look very familiar to anyone who has ever taken an`
`+    // algebra course.`
`+    s.q = s.a * (s.b * s.b) + s.a * s.b + s.c;`
`+`
`+    return sha1.hash(s.q, false);`
`+  }());`
`+`
`+  /**`
`+   * Get a random integer within a specified range. The range is specified by`
`+   * an object with the properties "min" and "max".`
`+   *`
`+   * @param  {object} range An object with the min and max properties.`
`+   * @return {number}       An integer within the specified range.`
`+   */`
`+  RandomNumber.prototype.randInt = function(range) {`
`+    if (!range || (!range.min && !range.max)) {`
`+      throw new ReferenceError("RandomNumber.randInt requires a range.");`
`+    }`
`+`
`+    if (!this.isSeeded) {`
`+      Math.seedrandom(this.SEED);`
`+      this.isSeeded = true;`
`+    }`
`+`
`+    return Math.floor(Math.random() * (range.max - range.min + 1)) + range.min;`
`+  };`
`+`
`+  if (exports) {`
`+    // node.js`
`+    exports.RandomNumber = RandomNumber;`
`+  } else {`
`+    return RandomNumber;`
`+  }`
`+}());`

# File latin_square.js

`+(function() {`
`+  var LatinSquare = (require('./LatinSquare.js')).LatinSquare,`
`+      RandomNumber = (require('./RandomNumber.js')).RandomNumber,`
`+      N = 3,`
`+      mapper = function(){},`
`+      randomNumber = new RandomNumber(),`
`+      randX = randomNumber.randInt({min:1, max:15}),`
`+      randY = randomNumber.randInt({min:1, max:N}),`
`+      str = '',`
`+      square = {};`
`+`
`+  mapper = function(x, y) {`
`+    // This isn't returning a valid Latin Square on every run :-/`
`+    return (randX*x + randY*y) % N;`
`+  };`
`+`
`+  square = new LatinSquare(N, undefined, mapper);`
`+  square.fill();`
`+`
`+  console.dir(square.square);`
`+`
`+  // For prettier, but slower, output:`
`+  /*for (i = 0; i < square.rows; i += 1) {`
`+    for (j = 0; j < square.cols; j += 1) {`
`+      str += square.get(i, j) + ', ';`
`+    }`
`+`
`+    str = str.slice(0, str.length - 2);`
`+    console.log(str);`
`+    str = '';`
`+  }*/`
`+}());`

# File seedrandom.js

`+// seedrandom.js version 2.0.`
`+// Author: David Bau 4/2/2011`
`+//`
`+// Defines a method Math.seedrandom() that, when called, substitutes`
`+// an explicitly seeded RC4-based algorithm for Math.random().  Also`
`+// supports automatic seeding from local or network sources of entropy.`
`+//`
`+// Usage:`
`+//`
`+//   <script src=http://davidbau.com/encode/seedrandom-min.js></script>`
`+//`
`+//   Math.seedrandom('yipee'); Sets Math.random to a function that is`
`+//                             initialized using the given explicit seed.`
`+//`
`+//   Math.seedrandom();        Sets Math.random to a function that is`
`+//                             seeded using the current time, dom state,`
`+//                             and other accumulated local entropy.`
`+//                             The generated seed string is returned.`
`+//`
`+//   Math.seedrandom('yowza', true);`
`+//                             Seeds using the given explicit seed mixed`
`+//                             together with accumulated entropy.`
`+//`
`+//   <script src="http://bit.ly/srandom-512"></script>`
`+//                             Seeds using physical random bits downloaded`
`+//                             from random.org.`
`+//`
`+//   <script src="https://jsonlib.appspot.com/urandom?callback=Math.seedrandom">`
`+//   </script>                 Seeds using urandom bits from call.jsonlib.com,`
`+//                             which is faster than random.org.`
`+//`
`+// Examples:`
`+//`
`+//   Math.seedrandom("hello");            // Use "hello" as the seed.`
`+//   document.write(Math.random());       // Always 0.5463663768140734`
`+//   document.write(Math.random());       // Always 0.43973793770592234`
`+//   var rng1 = Math.random;              // Remember the current prng.`
`+//`
`+//   var autoseed = Math.seedrandom();    // New prng with an automatic seed.`
`+//   document.write(Math.random());       // Pretty much unpredictable.`
`+//`
`+//   Math.random = rng1;                  // Continue "hello" prng sequence.`
`+//   document.write(Math.random());       // Always 0.554769432473455`
`+//`
`+//   Math.seedrandom(autoseed);           // Restart at the previous seed.`
`+//   document.write(Math.random());       // Repeat the 'unpredictable' value.`
`+//`
`+// Notes:`
`+//`
`+// Each time seedrandom('arg') is called, entropy from the passed seed`
`+// is accumulated in a pool to help generate future seeds for the`
`+// zero-argument form of Math.seedrandom, so entropy can be injected over`
`+// time by calling seedrandom with explicit data repeatedly.`
`+//`
`+// On speed - This javascript implementation of Math.random() is about`
`+// 3-10x slower than the built-in Math.random() because it is not native`
`+// code, but this is typically fast enough anyway.  Seeding is more expensive,`
`+// especially if you use auto-seeding.  Some details (timings on Chrome 4):`
`+//`
`+// Our Math.random()            - avg less than 0.002 milliseconds per call`
`+// seedrandom('explicit')       - avg less than 0.5 milliseconds per call`
`+// seedrandom('explicit', true) - avg less than 2 milliseconds per call`
`+// seedrandom()                 - avg about 38 milliseconds per call`
`+//`
`+// LICENSE (BSD):`
`+//`
`+// Copyright 2010 David Bau, all rights reserved.`
`+//`
`+// Redistribution and use in source and binary forms, with or without`
`+// modification, are permitted provided that the following conditions are met:`
`+//`
`+//   1. Redistributions of source code must retain the above copyright`
`+//      notice, this list of conditions and the following disclaimer.`
`+//`
`+//   2. Redistributions in binary form must reproduce the above copyright`
`+//      notice, this list of conditions and the following disclaimer in the`
`+//      documentation and/or other materials provided with the distribution.`
`+//`
`+//   3. Neither the name of this module nor the names of its contributors may`
`+//      be used to endorse or promote products derived from this software`
`+//      without specific prior written permission.`
`+//`
`+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS`
`+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT`
`+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR`
`+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT`
`+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,`
`+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT`
`+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,`
`+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY`
`+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT`
`+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE`
`+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`
`+//`
`+/**`
`+ * All code is in an anonymous closure to keep the global namespace clean.`
`+ *`
`+ * @param {number=} overflow`
`+ * @param {number=} startdenom`
`+ */`
`+(function (pool, math, width, chunks, significance, overflow, startdenom) {`
`+`
`+`
`+//`
`+// seedrandom()`
`+// This is the seedrandom function described above.`
`+//`
`+math['seedrandom'] = function seedrandom(seed, use_entropy) {`
`+  var key = [];`
`+  var arc4;`
`+`
`+  // Flatten the seed string or build one from local entropy if needed.`
`+  seed = mixkey(flatten(`
`+    use_entropy ? [seed, pool] :`
`+    arguments.length ? seed :`
`+    [new Date().getTime(), pool, window], 3), key);`
`+`
`+  // Use the seed to initialize an ARC4 generator.`
`+  arc4 = new ARC4(key);`
`+`
`+  // Mix the randomness into accumulated entropy.`
`+  mixkey(arc4.S, pool);`
`+`
`+  // Override Math.random`
`+`
`+  // This function returns a random double in [0, 1) that contains`
`+  // randomness in every bit of the mantissa of the IEEE 754 value.`
`+`
`+  math['random'] = function random() {  // Closure to return a random double:`
`+    var n = arc4.g(chunks);             // Start with a numerator n < 2 ^ 48`
`+    var d = startdenom;                 //   and denominator d = 2 ^ 48.`
`+    var x = 0;                          //   and no 'extra last byte'.`
`+    while (n < significance) {          // Fill up all significant digits by`
`+      n = (n + x) * width;              //   shifting numerator and`
`+      d *= width;                       //   denominator and generating a`
`+      x = arc4.g(1);                    //   new least-significant-byte.`
`+    }`
`+    while (n >= overflow) {             // To avoid rounding up, before adding`
`+      n /= 2;                           //   last byte, shift everything`
`+      d /= 2;                           //   right using integer math until`
`+      x >>>= 1;                         //   we have exactly the desired bits.`
`+    }`
`+    return (n + x) / d;                 // Form the number within [0, 1).`
`+  };`
`+`
`+  // Return the seed that was used`
`+  return seed;`
`+};`
`+`
`+//`
`+// ARC4`
`+//`
`+// An ARC4 implementation.  The constructor takes a key in the form of`
`+// an array of at most (width) integers that should be 0 <= x < (width).`
`+//`
`+// The g(count) method returns a pseudorandom integer that concatenates`
`+// the next (count) outputs from ARC4.  Its return value is a number x`
`+// that is in the range 0 <= x < (width ^ count).`
`+//`
`+/** @constructor */`
`+function ARC4(key) {`
`+  var t, u, me = this, keylen = key.length;`
`+  var i = 0, j = me.i = me.j = me.m = 0;`
`+  me.S = [];`
`+  me.c = [];`
`+`
`+  // The empty key [] is treated as [0].`
`+  if (!keylen) { key = [keylen++]; }`
`+`
`+  // Set up S using the standard key scheduling algorithm.`
`+  while (i < width) { me.S[i] = i++; }`
`+  for (i = 0; i < width; i++) {`
`+    t = me.S[i];`
`+    j = lowbits(j + t + key[i % keylen]);`
`+    u = me.S[j];`
`+    me.S[i] = u;`
`+    me.S[j] = t;`
`+  }`
`+`
`+  // The "g" method returns the next (count) outputs as one number.`
`+  me.g = function getnext(count) {`
`+    var s = me.S;`
`+    var i = lowbits(me.i + 1); var t = s[i];`
`+    var j = lowbits(me.j + t); var u = s[j];`
`+    s[i] = u;`
`+    s[j] = t;`
`+    var r = s[lowbits(t + u)];`
`+    while (--count) {`
`+      i = lowbits(i + 1); t = s[i];`
`+      j = lowbits(j + t); u = s[j];`
`+      s[i] = u;`
`+      s[j] = t;`
`+      r = r * width + s[lowbits(t + u)];`
`+    }`
`+    me.i = i;`
`+    me.j = j;`
`+    return r;`
`+  };`
`+  // For robust unpredictability discard an initial batch of values.`
`+  // See http://www.rsa.com/rsalabs/node.asp?id=2009`
`+  me.g(width);`
`+}`
`+`
`+//`
`+// flatten()`
`+// Converts an object tree to nested arrays of strings.`
`+//`
`+/** @param {Object=} result`
`+  * @param {string=} prop`
`+  * @param {string=} typ */`
`+function flatten(obj, depth, result, prop, typ) {`
`+  result = [];`
`+  typ = typeof(obj);`
`+  if (depth && typ == 'object') {`
`+    for (prop in obj) {`
`+      if (prop.indexOf('S') < 5) {    // Avoid FF3 bug (local/sessionStorage)`
`+        try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}`
`+      }`
`+    }`
`+  }`
`+  return (result.length ? result : obj + (typ != 'string' ? '\0' : ''));`
`+}`
`+`
`+//`
`+// mixkey()`
`+// Mixes a string seed into a key that is an array of integers, and`
`+// returns a shortened string seed that is equivalent to the result key.`
`+//`
`+/** @param {number=} smear`
`+  * @param {number=} j */`
`+function mixkey(seed, key, smear, j) {`
`+  seed += '';                         // Ensure the seed is a string`
`+  smear = 0;`
`+  for (j = 0; j < seed.length; j++) {`
`+    key[lowbits(j)] =`
`+      lowbits((smear ^= key[lowbits(j)] * 19) + seed.charCodeAt(j));`
`+  }`
`+  seed = '';`
`+  for (j in key) { seed += String.fromCharCode(key[j]); }`
`+  return seed;`
`+}`
`+`
`+//`
`+// lowbits()`
`+// A quick "n mod width" for width a power of 2.`
`+//`
`+function lowbits(n) { return n & (width - 1); }`
`+`
`+//`
`+// The following constants are related to IEEE 754 limits.`
`+//`
`+startdenom = math.pow(width, chunks);`
`+significance = math.pow(2, significance);`
`+overflow = significance * 2;`
`+`
`+//`
`+// When seedrandom.js is loaded, we immediately mix a few bits`
`+// from the built-in RNG into the entropy pool.  Because we do`
`+// not want to intefere with determinstic PRNG state later,`
`+// seedrandom will not call math.random on its own again after`
`+// initialization.`
`+//`
`+mixkey(math.random(), pool);`
`+`
`+// End anonymous scope, and pass initial values.`
`+})(`
`+  [],   // pool: entropy pool starts empty`
`+  Math, // math: package containing random, pow, and seedrandom`
`+  256,  // width: each RC4 output is 0 <= x < 256`
`+  6,    // chunks: at least six RC4 outputs for each double`
`+  52    // significance: there are 52 significant digits in a double`
`+);`

# File sha1.js

`+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */`
`+/*  SHA-1 implementation in JavaScript | (c) Chris Veness 2002-2010 | www.movable-type.co.uk      */`
`+/*   - see http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html                             */`
`+/*         http://csrc.nist.gov/groups/ST/toolkit/examples.html                                   */`
`+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */`
`+`
`+/**`
`+ * This code has been modified to work as a node.js module.`
`+ * Also, linting errors have been cleaned up. ~ James Sumners`
`+ */`
`+`
`+var Sha1 = {};  // Sha1 namespace`
`+`
`+/**`
`+ * Generates SHA-1 hash of string`
`+ *`
`+ * @param {String} msg                String to be hashed`
`+ * @param {Boolean} [utf8encode=true] Encode msg as UTF-8 before generating hash`
`+ * @returns {String}                  Hash of msg as hex character string`
`+ */`
`+Sha1.hash = function(msg, utf8encode) {`
`+  var a, b, c, d, e,`
`+      H0, H1, H2, H3, H4,   i, j, K, l, N, M, s, t, T,`
`+      W;`
`+`
`+  utf8encode =  (typeof utf8encode == 'undefined') ? true : utf8encode;`
`+`
`+  // convert string to UTF-8, as SHA only deals with byte-streams`
`+  if (utf8encode) msg = Utf8.encode(msg);`
`+`
`+  // constants [§4.2.1]`
`+  K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];`
`+`
`+  // PREPROCESSING`
`+`
`+  msg += String.fromCharCode(0x80);  // add trailing '1' bit (+ 0's padding) to string [§5.1.1]`
`+`
`+  // convert string msg into 512-bit/16-integer blocks arrays of ints [§5.2.1]`
`+  l = msg.length/4 + 2;  // length (in 32-bit integers) of msg + ‘1’ + appended length`
`+  N = Math.ceil(l/16);   // number of 16-integer-blocks required to hold 'l' ints`
`+  M = new Array(N);`
`+`
`+  for (i = 0; i < N; i += 1) {`
`+    M[i] = new Array(16);`
`+    for (j = 0; j < 16; j += 1) {  // encode 4 chars per integer, big-endian encoding`
`+      M[i][j] = (msg.charCodeAt(i*64+j*4)<<24) | (msg.charCodeAt(i*64+j*4+1)<<16) |`
`+        (msg.charCodeAt(i*64+j*4+2)<<8) | (msg.charCodeAt(i*64+j*4+3));`
`+    } // note running off the end of msg is ok 'cos bitwise ops on NaN return 0`
`+  }`
`+  // add length (in bits) into final pair of 32-bit integers (big-endian) [§5.1.1]`
`+  // note: most significant word would be (len-1)*8 >>> 32, but since JS converts`
`+  // bitwise-op args to 32 bits, we need to simulate this by arithmetic operators`
`+  M[N-1][14] = ((msg.length-1)*8) / Math.pow(2, 32); M[N-1][14] = Math.floor(M[N-1][14]);`
`+  M[N-1][15] = ((msg.length-1)*8) & 0xffffffff;`
`+`
`+  // set initial hash value [§5.3.1]`
`+  H0 = 0x67452301;`
`+  H1 = 0xefcdab89;`
`+  H2 = 0x98badcfe;`
`+  H3 = 0x10325476;`
`+  H4 = 0xc3d2e1f0;`
`+`
`+  // HASH COMPUTATION [§6.1.2]`
`+`
`+  W = new Array(80);`
`+  for (i = 0; i < N; i += 1) {`
`+`
`+    // 1 - prepare message schedule 'W'`
`+    for (t = 0;  t < 16; t += 1) {`
`+      W[t] = M[i][t];`
`+    }`
`+    for (t = 16; t < 80; t += 1) {`
`+      W[t] = Sha1.ROTL(W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16], 1);`
`+    }`
`+`
`+    // 2 - initialise five working variables a, b, c, d, e with previous hash value`
`+    a = H0; b = H1; c = H2; d = H3; e = H4;`
`+`
`+    // 3 - main loop`
`+    for (t = 0; t < 80; t += 1) {`
`+      s = Math.floor(t/20); // seq for blocks of 'f' functions and 'K' constants`
`+      T = (Sha1.ROTL(a,5) + Sha1.f(s,b,c,d) + e + K[s] + W[t]) & 0xffffffff;`
`+      e = d;`
`+      d = c;`
`+      c = Sha1.ROTL(b, 30);`
`+      b = a;`
`+      a = T;`
`+    }`
`+`
`+    // 4 - compute the new intermediate hash value`
`+    H0 = (H0+a) & 0xffffffff;  // note 'addition modulo 2^32'`
`+    H1 = (H1+b) & 0xffffffff;`
`+    H2 = (H2+c) & 0xffffffff;`
`+    H3 = (H3+d) & 0xffffffff;`
`+    H4 = (H4+e) & 0xffffffff;`
`+  }`
`+`
`+  return Sha1.toHexStr(H0) + Sha1.toHexStr(H1) +`
`+    Sha1.toHexStr(H2) + Sha1.toHexStr(H3) + Sha1.toHexStr(H4);`
`+};`
`+`
`+//`
`+// function 'f' [§4.1.1]`
`+//`
`+Sha1.f = function(s, x, y, z)  {`
`+  switch (s) {`
`+  case 0: return (x & y) ^ (~x & z);           // Ch()`
`+  case 1: return x ^ y ^ z;                    // Parity()`
`+  case 2: return (x & y) ^ (x & z) ^ (y & z);  // Maj()`
`+  case 3: return x ^ y ^ z;                    // Parity()`
`+  }`
`+};`
`+`
`+//`
`+// rotate left (circular left shift) value x by n positions [§3.2.5]`
`+//`
`+Sha1.ROTL = function(x, n) {`
`+  return (x<<n) | (x>>>(32-n));`
`+};`
`+`
`+//`
`+// hexadecimal representation of a number`
`+//   (note toString(16) is implementation-dependant, and`
`+//   in IE returns signed numbers when used on full words)`
`+//`
`+Sha1.toHexStr = function(n) {`
`+  var s="", v;`
`+  for (var i=7; i>=0; i--) { v = (n>>>(i*4)) & 0xf; s += v.toString(16); }`
`+  return s;`
`+};`
`+`
`+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */`
`+`
`+// node.js`
`+if (exports) {`
`+  exports.hash = Sha1.hash;`
`+  exports.ROTL = Sha1.ROTL;`
`+  exports.toHexStr = Sha1.toHexStr;`
`+}`