RubyGems - k4compiler - Versions diffs - 0.0.1 - Mend

k4compiler 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1898) hide show

data/third_party/closure-library/closure/goog/crypt/crypt_perf.html ADDED Viewed

@@ -0,0 +1,85 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2009 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<!--
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <title>Closure Performance Tests - UTF8 encoding and decoding</title>
+  <link rel="stylesheet" type="text/css"
+        href="../testing/performancetable.css"/>
+  <script src="../base.js"></script>
+  <script>
+    goog.require('goog.crypt');
+    goog.require('goog.string');
+    goog.require('goog.testing.PerformanceTable');
+    goog.require('goog.testing.jsunit');
+  </script>
+</head>
+<body>
+  <h1>Closure Performance Tests - UTF8 encoding and decoding</h1>
+  <p>
+    <strong>User-agent:</strong>
+    <script>document.write(navigator.userAgent);</script>
+  </p>
+  <div id="perfTable"></div>
+  <hr>
+  <script>
+    var table = new goog.testing.PerformanceTable(
+        goog.dom.getElement('perfTable'));
+    var STRING_LENGTH = 100000;
+    function testDecodeAscii() {
+      var arr = [];
+      for (var i = 0; i < STRING_LENGTH; i++) {
+        arr.push(120);
+      }
+      table.run(goog.partial(goog.crypt.utf8ByteArrayToString, arr),
+          'Decode UTF8 byte array with ASCII characters (1 byte / character)');
+    }
+    function testDecodeLatin() {
+      var arr = [];
+      for (var i = 0; i < STRING_LENGTH; i++) {
+        arr.push(195, 182);
+      }
+      table.run(goog.partial(goog.crypt.utf8ByteArrayToString, arr),
+          'Decode UTF8 byte array with Latin characters (2 bytes / character)');
+    }
+    function testDecodeLeftArrow() {
+      var arr = [];
+      for (var i = 0; i < STRING_LENGTH; i++) {
+        arr.push(226, 134, 144);
+      }
+      table.run(goog.partial(goog.crypt.utf8ByteArrayToString, arr),
+          'Decode UTF8 byte array with left arrows (3 bytes / character)');
+    }
+    function testEncodeAscii() {
+      var str = goog.string.repeat('x', STRING_LENGTH);
+      table.run(goog.partial(goog.crypt.stringToUtf8ByteArray, str),
+          'Encode ASCII string (1 byte / character)');
+    }
+    function testEncodeLatin() {
+      var str = goog.string.repeat('\u00F6', STRING_LENGTH);
+      table.run(goog.partial(goog.crypt.stringToUtf8ByteArray, str),
+          'Encode Latin string (2 bytes / character)');
+    }
+    function testEncodeLeftArrow() {
+      var str = goog.string.repeat('\u2190', STRING_LENGTH);
+      table.run(goog.partial(goog.crypt.stringToUtf8ByteArray, str),
+          'Encode left arrows (3 bytes / character)');
+    }
+  </script>
+</body>
+</html>

data/third_party/closure-library/closure/goog/crypt/crypt_test.html ADDED Viewed

@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2008 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>Closure Unit Tests - goog.crypt</title>
+<script src="../base.js"></script>
+<script>
+  goog.require('goog.crypt');
+  goog.require('goog.testing.jsunit');
+</script>
+</head>
+<body>
+<script>
+var UTF8_RANGES_BYTE_ARRAY = [
+    0x00,
+    0x7F,
+    0xC2, 0x80,
+    0xDF, 0xBF,
+    0xE0, 0xA0, 0x80,
+    0xEF, 0xBF, 0xBF];
+var UTF8_RANGES_STRING = '\u0000\u007F\u0080\u07FF\u0800\uFFFF';
+function testStringToUtf8ByteArray() {
+  // Known encodings taken from Java's String.getBytes("UTF8")
+  assertArrayEquals('ASCII',
+      [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100],
+      goog.crypt.stringToUtf8ByteArray('Hello, world'));
+  assertArrayEquals('Latin',
+      [83, 99, 104, 195, 182, 110],
+      goog.crypt.stringToUtf8ByteArray('Sch\u00f6n'));
+  assertArrayEquals('limits of the first 3 UTF-8 character ranges',
+      UTF8_RANGES_BYTE_ARRAY,
+      goog.crypt.stringToUtf8ByteArray(UTF8_RANGES_STRING));
+}
+function testUtf8ByteArrayToString() {
+  // Known encodings taken from Java's String.getBytes("UTF8")
+  assertEquals('ASCII', 'Hello, world', goog.crypt.utf8ByteArrayToString(
+      [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100]));
+  assertEquals('Latin', 'Sch\u00f6n', goog.crypt.utf8ByteArrayToString(
+      [83, 99, 104, 195, 182, 110]));
+  assertEquals('limits of the first 3 UTF-8 character ranges',
+      UTF8_RANGES_STRING,
+      goog.crypt.utf8ByteArrayToString(UTF8_RANGES_BYTE_ARRAY));
+}
+function testByteArrayToString() {
+  assertEquals('', goog.crypt.byteArrayToString([]));
+  assertEquals('abc', goog.crypt.byteArrayToString([97, 98, 99]));
+}
+function testHexToByteArray() {
+  assertElementsEquals(
+      [202, 254, 222, 173],
+      // Java magic number
+      goog.crypt.hexToByteArray('cafedead'));
+  assertElementsEquals(
+      [222, 173, 190, 239],
+      // IBM magic number
+      goog.crypt.hexToByteArray('DEADBEEF'));
+}
+function testByteArrayToHex() {
+  assertEquals(
+      // Java magic number
+      'cafedead',
+      goog.crypt.byteArrayToHex([202, 254, 222, 173]));
+  assertEquals(
+      // IBM magic number
+      'deadbeef',
+      goog.crypt.byteArrayToHex([222, 173, 190, 239]));
+}
+function testXorByteArray() {
+  assertElementsEquals(
+      [20, 83, 96, 66],
+      goog.crypt.xorByteArray([202, 254, 222, 173], [222, 173, 190, 239]));
+}
+</script>
+</body>
+</html>

data/third_party/closure-library/closure/goog/crypt/hash.js ADDED Viewed

@@ -0,0 +1,62 @@
+// Copyright 2011 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * @fileoverview Abstract cryptographic hash interface.
+ *
+ * See goog.crypt.Sha1 and goog.crypt.Md5 for sample implementations.
+ *
+ */
+goog.provide('goog.crypt.Hash');
+/**
+ * Create a cryptographic hash instance.
+ *
+ * @constructor
+ */
+goog.crypt.Hash = function() {};
+/**
+ * Resets the internal accumulator.
+ */
+goog.crypt.Hash.prototype.reset = goog.abstractMethod;
+/**
+ * Adds a byte array (array with values in [0-255] range) or a string (might
+ * only contain 8-bit, i.e., Latin1 characters) to the internal accumulator.
+ *
+ * Many hash functions operate on blocks of data and implement optimizations
+ * when a full chunk of data is readily available. Hence it is often preferable
+ * to provide large chunks of data (a kilobyte or more) than to repeatedly
+ * call the update method with few tens of bytes. If this is not possible, or
+ * not feasible, it might be good to provide data in multiplies of hash block
+ * size (often 64 bytes). Please see the implementation and performance tests
+ * of your favourite hash.
+ *
+ * @param {Array.<number>|Uint8Array|string} bytes Data used for the update.
+ * @param {number=} opt_length Number of bytes to use.
+ */
+goog.crypt.Hash.prototype.update = goog.abstractMethod;
+/**
+ * @return {!Array.<number>} The finalized hash computed
+ *     from the internal accumulator.
+ */
+goog.crypt.Hash.prototype.digest = goog.abstractMethod;

data/third_party/closure-library/closure/goog/crypt/hash32.js ADDED Viewed

@@ -0,0 +1,184 @@
+// Copyright 2008 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * @fileoverview Implementation of 32-bit hashing functions.
+ *
+ * This is a direct port from the Google Java Hash class
+ *
+ */
+goog.provide('goog.crypt.hash32');
+goog.require('goog.crypt');
+/**
+ * Default seed used during hashing, digits of pie.
+ * See SEED32 in http://go/base.hash.java
+ * @type {number}
+ */
+goog.crypt.hash32.SEED32 = 314159265;
+/**
+ * Arbitrary constant used during hashing.
+ * See CONSTANT32 in http://go/base.hash.java
+ * @type {number}
+ */
+goog.crypt.hash32.CONSTANT32 = -1640531527;
+/**
+ * Hashes a string to a 32-bit value.
+ * @param {string} str String to hash.
+ * @return {number} 32-bit hash.
+ */
+goog.crypt.hash32.encodeString = function(str) {
+  return goog.crypt.hash32.encodeByteArray(goog.crypt.stringToByteArray(str));
+};
+/**
+ * Hashes a string to a 32-bit value, converting the string to UTF-8 before
+ * doing the encoding.
+ * @param {string} str String to hash.
+ * @return {number} 32-bit hash.
+ */
+goog.crypt.hash32.encodeStringUtf8 = function(str) {
+  return goog.crypt.hash32.encodeByteArray(
+      goog.crypt.stringToUtf8ByteArray(str));
+};
+/**
+ * Hashes an integer to a 32-bit value.
+ * @param {number} value Number to hash.
+ * @return {number} 32-bit hash.
+ */
+goog.crypt.hash32.encodeInteger = function(value) {
+  // TODO(user): Does this make sense in JavaScript with doubles?  Should we
+  // force the value to be in the correct range?
+  return goog.crypt.hash32.mix32_({
+    a: value,
+    b: goog.crypt.hash32.CONSTANT32,
+    c: goog.crypt.hash32.SEED32
+  });
+};
+/**
+ * Hashes a "byte" array to a 32-bit value using the supplied seed.
+ * @param {Array.<number>} bytes Array of bytes.
+ * @param {number=} opt_offset The starting position to use for hash
+ * computation.
+ * @param {number=} opt_length Number of bytes that are used for hashing.
+ * @param {number=} opt_seed The seed.
+ * @return {number} 32-bit hash.
+ */
+goog.crypt.hash32.encodeByteArray = function(
+    bytes, opt_offset, opt_length, opt_seed) {
+  var offset = opt_offset || 0;
+  var length = opt_length || bytes.length;
+  var seed = opt_seed || goog.crypt.hash32.SEED32;
+  var mix = {
+    a: goog.crypt.hash32.CONSTANT32,
+    b: goog.crypt.hash32.CONSTANT32,
+    c: seed
+  };
+  var keylen;
+  for (keylen = length; keylen >= 12; keylen -= 12, offset += 12) {
+    mix.a += goog.crypt.hash32.wordAt_(bytes, offset);
+    mix.b += goog.crypt.hash32.wordAt_(bytes, offset + 4);
+    mix.c += goog.crypt.hash32.wordAt_(bytes, offset + 8);
+    goog.crypt.hash32.mix32_(mix);
+  }
+  // Hash any remaining bytes
+  mix.c += length;
+  switch (keylen) {  // deal with rest.  Some cases fall through
+    case 11: mix.c += (bytes[offset + 10]) << 24;
+    case 10: mix.c += (bytes[offset + 9] & 0xff) << 16;
+    case 9 : mix.c += (bytes[offset + 8] & 0xff) << 8;
+      // the first byte of c is reserved for the length
+    case 8 :
+      mix.b += goog.crypt.hash32.wordAt_(bytes, offset + 4);
+      mix.a += goog.crypt.hash32.wordAt_(bytes, offset);
+      break;
+    case 7 : mix.b += (bytes[offset + 6] & 0xff) << 16;
+    case 6 : mix.b += (bytes[offset + 5] & 0xff) << 8;
+    case 5 : mix.b += (bytes[offset + 4] & 0xff);
+    case 4 :
+      mix.a += goog.crypt.hash32.wordAt_(bytes, offset);
+      break;
+    case 3 : mix.a += (bytes[offset + 2] & 0xff) << 16;
+    case 2 : mix.a += (bytes[offset + 1] & 0xff) << 8;
+    case 1 : mix.a += (bytes[offset + 0] & 0xff);
+      // case 0 : nothing left to add
+  }
+  return goog.crypt.hash32.mix32_(mix);
+};
+/**
+ * Performs an inplace mix of an object with the integer properties (a, b, c)
+ * and returns the final value of c.
+ * @param {Object} mix Object with properties, a, b, and c.
+ * @return {number} The end c-value for the mixing.
+ * @private
+ */
+goog.crypt.hash32.mix32_ = function(mix) {
+  var a = mix.a, b = mix.b, c = mix.c;
+  a -= b; a -= c; a ^= c >>> 13;
+  b -= c; b -= a; b ^= a << 8;
+  c -= a; c -= b; c ^= b >>> 13;
+  a -= b; a -= c; a ^= c >>> 12;
+  b -= c; b -= a; b ^= a << 16;
+  c -= a; c -= b; c ^= b >>> 5;
+  a -= b; a -= c; a ^= c >>> 3;
+  b -= c; b -= a; b ^= a << 10;
+  c -= a; c -= b; c ^= b >>> 15;
+  mix.a = a; mix.b = b; mix.c = c;
+  return c;
+};
+/**
+ * Returns the word at a given offset.  Treating an array of bytes a word at a
+ * time is far more efficient than byte-by-byte.
+ * @param {Array.<number>} bytes Array of bytes.
+ * @param {number} offset Offset in the byte array.
+ * @return {number} Integer value for the word.
+ * @private
+ */
+goog.crypt.hash32.wordAt_ = function(bytes, offset) {
+  var a = goog.crypt.hash32.toSigned_(bytes[offset + 0]);
+  var b = goog.crypt.hash32.toSigned_(bytes[offset + 1]);
+  var c = goog.crypt.hash32.toSigned_(bytes[offset + 2]);
+  var d = goog.crypt.hash32.toSigned_(bytes[offset + 3]);
+  return a + (b << 8) + (c << 16) + (d << 24);
+};
+/**
+ * Converts an unsigned "byte" to signed, that is, convert a value in the range
+ * (0, 2^8-1) to (-2^7, 2^7-1) in order to be compatible with Java's byte type.
+ * @param {number} n Unsigned "byte" value.
+ * @return {number} Signed "byte" value.
+ * @private
+ */
+goog.crypt.hash32.toSigned_ = function(n) {
+  return n > 127 ? n - 256 : n;
+};

data/third_party/closure-library/closure/goog/crypt/hash32_test.html ADDED Viewed

@@ -0,0 +1,287 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2008 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>Closure Unit Tests - goog.crypt.hash32</title>
+<script src="../base.js"></script>
+<script>
+  goog.require('goog.crypt.hash32');
+  goog.require('goog.testing.jsunit');
+</script>
+</head>
+<body>
+<script>
+  // NOTE: This test uses a custom test case, see end of script block
+  // Test data based on known input/output pairs generated using
+  // http://go/hash.java
+  function testEncodeInteger() {
+    assertEquals(898813988, goog.crypt.hash32.encodeInteger(305419896));
+  }
+  function testEncodeByteArray() {
+    assertEquals(-1497024495,
+        goog.crypt.hash32.encodeByteArray([10, 20, 30, 40]));
+    assertEquals(-961586214,
+        goog.crypt.hash32.encodeByteArray([3, 1, 4, 1, 5, 9]));
+    assertEquals(-1482202299,
+        goog.crypt.hash32.encodeByteArray([127, 0, 0, 0, 123, 45]));
+    assertEquals(170907881,
+        goog.crypt.hash32.encodeByteArray([9, 1, 1]));
+  }
+  function testKnownByteArrays() {
+    for (var i = 0; i < byteArrays.length; i++) {
+      assertEquals(byteArrays[i],
+          goog.crypt.hash32.encodeByteArray(createByteArray(i)));
+    }
+  }
+  function testEncodeString() {
+    assertEquals(-937588052, goog.crypt.hash32.encodeString('Hello, world'));
+    assertEquals(62382810, goog.crypt.hash32.encodeString('Sch\xF6n'));
+  }
+  function testEncodeStringUtf8() {
+    assertEquals(-937588052,
+        goog.crypt.hash32.encodeStringUtf8('Hello, world'));
+    assertEquals(-833263351, goog.crypt.hash32.encodeStringUtf8('Sch\xF6n'));
+    assertEquals(-1771620293, goog.crypt.hash32.encodeStringUtf8(
+        '\u043A\u0440'));
+  }
+  function testEncodeString_ascii() {
+    assertEquals('For ascii characters UTF8 should be the same',
+        goog.crypt.hash32.encodeStringUtf8('abc123'),
+        goog.crypt.hash32.encodeString('abc123'));
+    assertEquals('For ascii characters UTF8 should be the same',
+        goog.crypt.hash32.encodeStringUtf8('The,quick.brown-fox'),
+        goog.crypt.hash32.encodeString('The,quick.brown-fox'));
+    assertNotEquals('For non-ascii characters UTF-8 encoding is different',
+        goog.crypt.hash32.encodeStringUtf8('Sch\xF6n'),
+        goog.crypt.hash32.encodeString('Sch\xF6n'));
+  }
+  function testEncodeString_poe() {
+    var poe = "Once upon a midnight dreary, while I pondered weak and weary," +
+        "Over many a quaint and curious volume of forgotten lore," +
+        "While I nodded, nearly napping, suddenly there came a tapping," +
+        "As of some one gently rapping, rapping at my chamber door." +
+        "`'Tis some visitor,' I muttered, `tapping at my chamber door -" +
+        "Only this, and nothing more.'" +
+        "Ah, distinctly I remember it was in the bleak December," +
+        "And each separate dying ember wrought its ghost upon the floor." +
+        "Eagerly I wished the morrow; - vainly I had sought to borrow" +
+        "From my books surcease of sorrow - sorrow for the lost Lenore -" +
+        "For the rare and radiant maiden whom the angels named Lenore -" +
+        "Nameless here for evermore." +
+        "And the silken sad uncertain rustling of each purple curtain" +
+        "Thrilled me - filled me with fantastic terrors never felt before;" +
+        "So that now, to still the beating of my heart, I stood repeating" +
+        "`'Tis some visitor entreating entrance at my chamber door -" +
+        "Some late visitor entreating entrance at my chamber door; -" +
+        "This it is, and nothing more,'" +
+        "Presently my soul grew stronger; hesitating then no longer," +
+        "`Sir,' said I, `or Madam, truly your forgiveness I implore;" +
+        "But the fact is I was napping, and so gently you came rapping," +
+        "And so faintly you came tapping, tapping at my chamber door," +
+        "That I scarce was sure I heard you' - here I opened wide the door; -" +
+        "Darkness there, and nothing more." +
+        "Deep into that darkness peering, long I stood there wondering, " +
+        "fearing," +
+        "Doubting, dreaming dreams no mortal ever dared to dream before" +
+        "But the silence was unbroken, and the darkness gave no token," +
+        "And the only word there spoken was the whispered word, `Lenore!'" +
+        "This I whispered, and an echo murmured back the word, `Lenore!'" +
+        "Merely this and nothing more." +
+        "Back into the chamber turning, all my soul within me burning," +
+        "Soon again I heard a tapping somewhat louder than before." +
+        "`Surely,\' said I, `surely that is something at my window lattice;" +
+        "Let me see then, what thereat is, and this mystery explore -" +
+        "Let my heart be still a moment and this mystery explore; -" +
+        "'Tis the wind and nothing more!'";
+    assertEquals(147608747, goog.crypt.hash32.encodeString(poe));
+    assertEquals(147608747, goog.crypt.hash32.encodeStringUtf8(poe));
+  }
+  function testBenchmarking() {
+    if (!testCase) return;
+    // Not a real test, just outputs some timing
+    function makeString(n) {
+      var str = [];
+      for (var i = 0; i < n; i++) {
+        str.push(String.fromCharCode(Math.round(Math.random() * 500)));
+      }
+      return str.join('');
+    }
+    for (var i = 0; i < 50000; i+= 10000) {
+      var str = makeString(i);
+      var start = goog.now();
+      var hash = goog.crypt.hash32.encodeString(str);
+      var diff = goog.now() - start;
+      testCase.saveMessage(
+          'testBenchmarking : hashing ' + i + ' chars in ' + diff + 'ms');
+    }
+  }
+  function createByteArray(n) {
+    var arr = [];
+    for (var i = 0; i < n; i++) {
+      arr.push(i);
+    }
+    return arr;
+  }
+  var byteArrays = {
+    0: 1539411136,
+    1: 1773524747,
+    2: -254958930,
+    3: 1532114172,
+    4: 1923165449,
+    5: 1611874589,
+    6: 1502126780,
+    7: -751745251,
+    8: -292491321,
+    9: 1106193218,
+    10: -722791438,
+    11: -2130666060,
+    12: -259304553,
+    13: 871461192,
+    14: 865773084,
+    15: 1615738330,
+    16: -1836636447,
+    17: -485722519,
+    18: -120832227,
+    19: 1954449704,
+    20: 491312921,
+    21: -1955462668,
+    22: 168565425,
+    23: -105893922,
+    24: 620486614,
+    25: -1789602428,
+    26: 1765793554,
+    27: 1723370948,
+    28: -1275405721,
+    29: 140421019,
+    30: -1438726307,
+    31: 538438903,
+    32: -729123980,
+    33: 1213490939,
+    34: -1814248478,
+    35: 1943703398,
+    36: 1603073219,
+    37: -2139639543,
+    38: -694153941,
+    39: 137511516,
+    40: -249943726,
+    41: -1166126060,
+    42: 53464833,
+    43: -915350862,
+    44: 1306585409,
+    45: 1064798289,
+    46: 335555913,
+    47: 224485496,
+    48: 275599760,
+    49: 409559869,
+    50: 673770580,
+    51: -2113819879,
+    52: -791338727,
+    53: -1716479479,
+    54: 1795018816,
+    55: 2020139343,
+    56: -1652827750,
+    57: -1509632558,
+    58: 751641995,
+    59: -217881377,
+    60: -476546900,
+    61: -1893349644,
+    62: -729290332,
+    63: 1359899321,
+    64: 1811814306,
+    65: 2100363086,
+    66: -794920327,
+    67: -1667555017,
+    68: -549980099,
+    69: -21170740,
+    70: -1324143722,
+    71: 1406730195,
+    72: 2111381574,
+    73: -1667480052,
+    74: 1071811178,
+    75: -1080194099,
+    76: -181186882,
+    77: 268677507,
+    78: -546766334,
+    79: 555953522,
+    80: -981311675,
+    81: 1988867392,
+    82: 773172547,
+    83: 1160806722,
+    84: -1455460187,
+    85: 83493600,
+    86: 155365142,
+    87: 1714618071,
+    88: 1487712615,
+    89: -810670278,
+    90: 2031655097,
+    91: 1286349470,
+    92: -1873594211,
+    93: 1875867480,
+    94: -1096259787,
+    95: -1054968610,
+    96: -1723043458,
+    97: 1278708307,
+    98: -601104085,
+    99: 1497928579,
+    100: 1329732615,
+    101: -1281696190,
+    102: 1471511953,
+    103: -62666299,
+    104: 807569747,
+    105: -1927974759,
+    106: 1462243717,
+    107: -862975602,
+    108: 824369927,
+    109: -1448816781,
+    110: 1434162022,
+    111: -881501413,
+    112: -1554381107,
+    113: -1730883204,
+    114: 431236217,
+    115: 1877278608,
+    116: -673864625,
+    117: 143000665,
+    118: -596902829,
+    119: 1038860559,
+    120: 805884326,
+    121: -1536181710,
+    122: -1357373256,
+    123: 1405134250,
+    124: -860816481,
+    125: 1393578269,
+    126: -810682545,
+    127: -635515639
+  };
+  var testCase;
+  if (G_testRunner) {
+    testCase = new goog.testing.TestCase(document.title);
+    testCase.autoDiscoverTests();
+    G_testRunner.initialize(testCase);
+  }
+</script>
+</body>
+</html>