text: (function(dependencies, chunks, undefined, global) {
      
      var cache = [],
          cacheCallbacks = {};
      
  
      function Module() {
          this.id = null;
          this.filename = null;
          this.dirname = null;
          this.exports = {};
          this.loaded = false;
      }
  
      Module.prototype.require = require;
  
      function require(index) {
          var module = cache[index],
              callback, exports;
  
          if (module !== undefined) {
              return module.exports;
          } else {
              callback = dependencies[index];
  
              cache[index] = module = new Module();
              exports = module.exports;
  
              callback.call(exports, require, exports, module, undefined, global);
              module.loaded = true;
  
              return module.exports;
          }
      }
  
      require.resolve = function(path) {
          return path;
      };
  
      
      require.async = function async(index, callback) {
          var module = cache[index],
              callbacks, node;
  
          if (module) {
              callback(module.exports);
          } else if ((callbacks = cacheCallbacks[index])) {
              callbacks[callbacks.length] = callback;
          } else {
              node = document.createElement("script");
              callbacks = cacheCallbacks[index] = [callback];
  
              node.type = "text/javascript";
              node.charset = "utf-8";
              node.async = true;
  
              function onLoad() {
                  var i = -1,
                      il = callbacks.length - 1;
  
                  while (i++ < il) {
                      callbacks[i](require(index));
                  }
                  delete cacheCallbacks[index];
              }
  
              if (node.attachEvent && !(node.attachEvent.toString && node.attachEvent.toString().indexOf("[native code") < 0)) {
                  node.attachEvent("onreadystatechange", onLoad);
              } else {
                  node.addEventListener("load", onLoad, false);
              }
  
              node.src = chunks[index];
  
              document.head.appendChild(node);
          }
      };
  
      global["NGCCTPyI-OEYa-4AmY-tBpC-DFUZLl5yINaNI"] = function(asyncDependencies) {
          var i = -1,
              il = asyncDependencies.length - 1,
              dependency, index;
  
          while (i++ < il) {
              dependency = asyncDependencies[i];
              index = dependency[0];
  
              if (dependencies[index] === null) {
                  dependencies[index] = dependency[1];
              }
          }
      };
  
      
  
      if (typeof(define) === "function" && define.amd) {
          define([], function() {
              return require(0);
          });
      } else if (typeof(module) !== "undefined" && module.exports) {
          module.exports = require(0);
      } else {
          
          require(0);
          
      }
  }([
  function(require, exports, module, undefined, global) {
  /*@=-/var/www/html/node/async_json/example/src/index.js-=@*/
  global.asyncJSON = require(1);
  
  
  console.time("async");
  asyncJSON.stringify({
      key: "value"
  }, function onStringify(error, json) {
      if (error) {
          throw error;
      } else {
          asyncJSON.parse(json, function onParse(error, json) {
              if (error) {
                  throw error;
              } else {
                  console.timeEnd("async");
              }
          });
      }
  });
  
  
  console.time("sync");
  JSON.parse(JSON.stringify({
      key: "value"
  }));
  console.timeEnd("sync");
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/async_json@0.0.2/src/index.js-=@*/
  var isFunction = require(2),
      isObject = require(3),
      extend = require(4),
      messenger = require(5);
  
  
  var asyncJSON = exports;
  
  
  asyncJSON.parse = function parse(value, reviver, callback) {
      if (isFunction(reviver)) {
          callback = reviver;
          reviver = undefined;
      }
  
      if (isObject(reviver)) {
          messenger.emit("parse", value, function onParse(error, json) {
              if (error) {
                  callback(error);
              } else {
                  callback(undefined, extend(reviver, json));
              }
          });
      } else {
          messenger.emit("parse", value, callback);
      }
  };
  
  asyncJSON.stringify = function stringify(value, replacer, space, callback) {
      if (isFunction(space)) {
          callback = space;
          space = undefined;
      }
      if (isFunction(replacer)) {
          callback = replacer;
          replacer = undefined;
          space = undefined;
      }
  
      messenger.emit("stringify", {
          value: value,
          replacer: replacer,
          space: space
      }, callback);
  };
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_function@0.0.1/src/index.js-=@*/
  var objectToString = Object.prototype.toString,
      isFunction;
  
  
  if (objectToString.call(function() {}) === "[object Object]") {
      isFunction = function isFunction(value) {
          return value instanceof Function;
      };
  } else if (typeof(/./) === "function" || (typeof(Uint8Array) !== "undefined" && typeof(Uint8Array) !== "function")) {
      isFunction = function isFunction(value) {
          return objectToString.call(value) === "[object Function]";
      };
  } else {
      isFunction = function isFunction(value) {
          return typeof(value) === "function" || false;
      };
  }
  
  
  module.exports = isFunction;
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_object@0.0.1/src/index.js-=@*/
  var isNull = require(6);
  
  
  module.exports = isObject;
  
  
  function isObject(value) {
      var type = typeof(value);
      return type === "function" || (!isNull(value) && type === "object") || false;
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/extend@0.0.1/src/index.js-=@*/
  var keys = require(7);
  
  
  module.exports = extend;
  
  
  function extend(out) {
      var i = 0,
          il = arguments.length - 1;
  
      while (i++ < il) {
          baseExtend(out, arguments[i]);
      }
  
      return out;
  }
  
  function baseExtend(a, b) {
      var objectKeys = keys(b),
          i = -1,
          il = objectKeys.length - 1,
          key;
  
      while (i++ < il) {
          key = objectKeys[i];
          a[key] = b[key];
      }
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/async_json@0.0.2/src/messenger.js-=@*/
  var environment = require(16),
      Messenger = require(17),
      MessengerWorkerAdapter = require(18),
      messengerAdapter;
  
  
  var messenger;
  
  
  if (typeof(Worker) === "undefined" || environment.node) {
      messengerAdapter = require(19);
      require(20);
      messenger = new Messenger(messengerAdapter.client);
  } else {
      messenger = new Messenger(new MessengerWorkerAdapter(require(21)));
  }
  
  
  module.exports = messenger;
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_null@0.0.1/src/index.js-=@*/
  module.exports = isNull;
  
  
  function isNull(value) {
      return value === null;
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/keys@0.0.1/src/index.js-=@*/
  var has = require(8),
      isNative = require(9),
      isNullOrUndefined = require(10),
      isObject = require(3);
  
  
  var nativeKeys = Object.keys;
  
  
  module.exports = keys;
  
  
  function keys(value) {
      if (isNullOrUndefined(value)) {
          return [];
      } else {
          return nativeKeys(isObject(value) ? value : Object(value));
      }
  }
  
  if (!isNative(nativeKeys)) {
      nativeKeys = function keys(value) {
          var localHas = has,
              out = [],
              i = 0,
              key;
  
          for (key in value) {
              if (localHas(value, key)) {
                  out[i++] = key;
              }
          }
  
          return out;
      };
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/has@0.0.1/src/index.js-=@*/
  var isNative = require(9),
      getPrototypeOf = require(11),
      isNullOrUndefined = require(10);
  
  
  var nativeHasOwnProp = Object.prototype.hasOwnProperty,
      baseHas;
  
  
  module.exports = has;
  
  
  function has(object, key) {
      if (isNullOrUndefined(object)) {
          return false;
      } else {
          return baseHas(object, key);
      }
  }
  
  if (isNative(nativeHasOwnProp)) {
      baseHas = function baseHas(object, key) {
          if (object.hasOwnProperty) {
              return object.hasOwnProperty(key);
          } else {
              return nativeHasOwnProp.call(object, key);
          }
      };
  } else {
      baseHas = function baseHas(object, key) {
          var proto = getPrototypeOf(object);
  
          if (isNullOrUndefined(proto)) {
              return key in object;
          } else {
              return (key in object) && (!(key in proto) || proto[key] !== object[key]);
          }
      };
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_native@0.0.2/src/index.js-=@*/
  var isFunction = require(2),
      isNullOrUndefined = require(10),
      escapeRegExp = require(12);
  
  
  var reHostCtor = /^\[object .+?Constructor\]$/,
  
      functionToString = Function.prototype.toString,
  
      reNative = RegExp("^" +
          escapeRegExp(Object.prototype.toString)
          .replace(/toString|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
      ),
  
      isHostObject;
  
  
  module.exports = isNative;
  
  
  function isNative(value) {
      return !isNullOrUndefined(value) && (
          isFunction(value) ?
          reNative.test(functionToString.call(value)) : (
              typeof(value) === "object" && (
                  (isHostObject(value) ? reNative : reHostCtor).test(value) || false
              )
          )
      ) || false;
  }
  
  try {
      String({
          "toString": 0
      } + "");
  } catch (e) {
      isHostObject = function isHostObject() {
          return false;
      };
  }
  
  isHostObject = function isHostObject(value) {
      return !isFunction(value.toString) && typeof(value + "") === "string";
  };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_null_or_undefined@0.0.1/src/index.js-=@*/
  var isNull = require(6),
      isUndefined = require(13);
  
  
  module.exports = isNullOrUndefined;
  
  /**
    isNullOrUndefined accepts any value and returns true
    if the value is null or undefined. For all other values
    false is returned.
    
    @param {Any}        any value to test
    @returns {Boolean}  the boolean result of testing value
  
    @example
      isNullOrUndefined(null);   // returns true
      isNullOrUndefined(undefined);   // returns true
      isNullOrUndefined("string");    // returns false
  **/
  function isNullOrUndefined(value) {
      return isNull(value) || isUndefined(value);
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/get_prototype_of@0.0.1/src/index.js-=@*/
  var isObject = require(3),
      isNative = require(9),
      isNullOrUndefined = require(10);
  
  
  var nativeGetPrototypeOf = Object.getPrototypeOf,
      baseGetPrototypeOf;
  
  
  module.exports = getPrototypeOf;
  
  
  function getPrototypeOf(value) {
      if (isNullOrUndefined(value)) {
          return null;
      } else {
          return baseGetPrototypeOf(value);
      }
  }
  
  if (isNative(nativeGetPrototypeOf)) {
      baseGetPrototypeOf = function baseGetPrototypeOf(value) {
          return nativeGetPrototypeOf(isObject(value) ? value : Object(value)) || null;
      };
  } else {
      if ("".__proto__ === String.prototype) {
          baseGetPrototypeOf = function baseGetPrototypeOf(value) {
              return value.__proto__ || null;
          };
      } else {
          baseGetPrototypeOf = function baseGetPrototypeOf(value) {
              return value.constructor ? value.constructor.prototype : null;
          };
      }
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/escape_regexp@0.0.1/src/index.js-=@*/
  var toString = require(14);
  
  
  var reRegExpChars = /[.*+?\^${}()|\[\]\/\\]/g,
      reHasRegExpChars = new RegExp(reRegExpChars.source);
  
  
  module.exports = escapeRegExp;
  
  
  function escapeRegExp(string) {
      string = toString(string);
      return (
          (string && reHasRegExpChars.test(string)) ?
          string.replace(reRegExpChars, "\\$&") :
          string
      );
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_undefined@0.0.1/src/index.js-=@*/
  module.exports = isUndefined;
  
  
  function isUndefined(value) {
      return value === void(0);
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/to_string@0.0.1/src/index.js-=@*/
  var isString = require(15),
      isNullOrUndefined = require(10);
  
  
  module.exports = toString;
  
  
  function toString(value) {
      if (isString(value)) {
          return value;
      } else if (isNullOrUndefined(value)) {
          return "";
      } else {
          return value + "";
      }
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_string@0.0.1/src/index.js-=@*/
  module.exports = isString;
  
  
  function isString(value) {
      return typeof(value) === "string" || false;
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/environment@0.0.2/src/index.js-=@*/
  var Buffer = require(22).Buffer;
  var process = require(23);
  var environment = exports,
  
      hasWindow = typeof(window) !== "undefined",
      userAgent = hasWindow ? window.navigator.userAgent : "";
  
  
  environment.worker = typeof(importScripts) !== "undefined";
  
  environment.browser = environment.worker || !!(
      hasWindow &&
      typeof(navigator) !== "undefined" &&
      window.document
  );
  
  environment.node = (!hasWindow &&
      typeof(process) !== "undefined" &&
      typeof(process.versions) !== "undefined" &&
      typeof(process.versions.node) !== "undefined" &&
      typeof(Buffer) !== "undefined"
  );
  
  environment.mobile = environment.browser && /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent.toLowerCase());
  
  environment.window = (
      hasWindow ? window :
      typeof(global) !== "undefined" ? global :
      typeof(self) !== "undefined" ? self : {}
  );
  
  environment.pixelRatio = environment.window.devicePixelRatio || 1;
  
  environment.document = typeof(document) !== "undefined" ? document : {};
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/messenger@0.0.2/src/index.js-=@*/
  var has = require(8),
      uuid = require(27);
  
  
  var MessengerPrototype;
  
  
  module.exports = Messenger;
  
  
  function Messenger(adapter) {
      var _this = this;
  
      this.__id = uuid.v4();
      this.__messageId = 0;
      this.__callbacks = {};
      this.__listeners = {};
  
      this.__adapter = adapter;
  
      adapter.addMessageListener(function onMessage(data) {
          _this.onMessage(data);
      });
  }
  MessengerPrototype = Messenger.prototype;
  
  MessengerPrototype.onMessage = function(message) {
      var id = message.id,
          name = message.name,
          callbacks = this.__callbacks,
          callback = callbacks[id],
          listeners, adapter;
  
      if (name) {
          listeners = this.__listeners;
          adapter = this.__adapter;
  
          if (has(listeners, name)) {
              Messenger_send(this, listeners[name], message.data, function sendCallback(error, data) {
                  adapter.postMessage({
                      id: id,
                      error: error || undefined,
                      data: data
                  });
              });
          }
      } else {
          if (callback && isMatch(id, this.__id)) {
              callback(message.error, message.data, this);
              delete callbacks[id];
          }
      }
  };
  
  MessengerPrototype.send = function(name, data, callback) {
      var callbacks = this.__callbacks,
          id = this.__id + "." + (this.__messageId++).toString(36);
  
      if (callback && !has(callbacks, id)) {
          callbacks[id] = callback;
      }
  
      this.__adapter.postMessage({
          id: id,
          name: name,
          data: data
      });
  };
  
  MessengerPrototype.emit = MessengerPrototype.send;
  
  MessengerPrototype.on = function(name, callback) {
      var listeners = this.__listeners,
          listener = listeners[name] || (listeners[name] = []);
  
      listener[listener.length] = callback;
  };
  
  MessengerPrototype.off = function(name, callback) {
      var listeners = this.__listeners,
          listener, i;
  
      if (has(listeners, name)) {
          listener = listeners[name];
          i = listener.length;
  
          while (i--) {
              if (listener[i] === callback) {
                  listener.splice(i, 1);
              }
          }
  
          if (listener.length === 0) {
              delete listeners[name];
          }
      }
  };
  
  function Messenger_send(_this, listeners, data, callback) {
      var index = 0,
          length = listeners.length,
          called = false;
  
      function done(error, data) {
          if (called === false) {
              called = true;
              callback(error, data);
          }
      }
  
      function next(error, data) {
          if (error || index === length) {
              done(error, data);
          } else {
              listeners[index++](data, next, _this);
          }
      }
  
      next(undefined, data);
  }
  
  function isMatch(messageId, id) {
      return messageId.split(".")[0] === id;
  }
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/messenger_worker_adapter@0.0.1/src/index.js-=@*/
  var isString = require(15),
      environment = require(55);
  
  
  var MessengerWorkerAdapterPrototype,
      globalWorker;
  
  
  if (environment.worker) {
      globalWorker = self;
  }
  
  
  module.exports = MessengerWorkerAdapter;
  
  
  function MessengerWorkerAdapter(url) {
      this.__worker = environment.worker ? globalWorker : (isString(url) ? new Worker(url) : url);
  }
  MessengerWorkerAdapterPrototype = MessengerWorkerAdapter.prototype;
  
  MessengerWorkerAdapterPrototype.addMessageListener = function(callback) {
      this.__worker.addEventListener("message", function onMessage(e) {
          callback(JSON.parse(e.data));
      });
  };
  
  MessengerWorkerAdapterPrototype.postMessage = function(data) {
      this.__worker.postMessage(JSON.stringify(data));
  };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/async_json@0.0.2/src/messengerAdapter.js-=@*/
  var createMessengerAdapter = require(56);
  
  
  module.exports = createMessengerAdapter();
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/async_json@0.0.2/src/nextTick.js-=@*/
  var process = require(23);
  var Messenger = require(17),
      messengerAdapter = require(19);
  
  
  var messenger = new Messenger(messengerAdapter.server);
  
  
  messenger.on("parse", function onParse(data, callback) {
      process.nextTick(function onNextTick() {
          var json;
  
          try {
              json = JSON.parse(data);
          } catch (e) {
              callback(e);
          }
  
          callback(undefined, json);
      });
  });
  
  messenger.on("stringify", function onStringify(data, callback) {
      process.nextTick(function onNextTick() {
          var string;
  
          try {
              string = JSON.stringify(data.value, data.replacer, data.space);
          } catch (e) {
              callback(e);
          }
  
          callback(undefined, string);
      });
  });
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/async_json@0.0.2/src/worker.js-=@*/
  var blob = new Blob([
      "var worker = this;",
  
      "worker.onmessage = function onMessage(e) {",
      "var jsonData = JSON.parse(e.data),",
      "data = jsonData.data,",
      "message = {",
      "id: jsonData.id,",
      "data: null,",
      "error: null",
      "};",
  
      "if (jsonData.name === \"parse\") {",
      "try {",
      "message.data = JSON.parse(data);",
      "} catch(e) {",
      "message.error = e;",
      "}",
      "} else {",
      "try {",
      "message.data = JSON.stringify(data.value, data.replacer, data.space);",
      "} catch(e) {",
      "message.error = e;",
      "}",
      "}",
  
      "worker.postMessage(JSON.stringify(message));",
      "};"
  ]);
  
  
  module.exports = new Worker(window.URL.createObjectURL(blob));
  },
  function(require, exports, module, undefined, global) {
  /*@=-buffer@3.6.0/index.js-=@*/
  /*!
   * The buffer module from node.js, for the browser.
   *
   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
   * @license  MIT
   */
  /* eslint-disable no-proto */
  
  'use strict'
  
  var base64 = require(24)
  var ieee754 = require(25)
  var isArray = require(26)
  
  exports.Buffer = Buffer
  exports.SlowBuffer = SlowBuffer
  exports.INSPECT_MAX_BYTES = 50
  Buffer.poolSize = 8192 // not used by this implementation
  
  var rootParent = {}
  
  /**
   * If `Buffer.TYPED_ARRAY_SUPPORT`:
   *   === true    Use Uint8Array implementation (fastest)
   *   === false   Use Object implementation (most compatible, even IE6)
   *
   * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
   * Opera 11.6+, iOS 4.2+.
   *
   * Due to various browser bugs, sometimes the Object implementation will be used even
   * when the browser supports typed arrays.
   *
   * Note:
   *
   *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
   *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
   *
   *   - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property
   *     on objects.
   *
   *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
   *
   *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
   *     incorrect length in some situations.
  
   * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
   * get the Object implementation, which is slower but behaves correctly.
   */
  Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
    ? global.TYPED_ARRAY_SUPPORT
    : typedArraySupport()
  
  function typedArraySupport () {
    function Bar () {}
    try {
      var arr = new Uint8Array(1)
      arr.foo = function () { return 42 }
      arr.constructor = Bar
      return arr.foo() === 42 && // typed array instances can be augmented
          arr.constructor === Bar && // constructor can be set
          typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
          arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
    } catch (e) {
      return false
    }
  }
  
  function kMaxLength () {
    return Buffer.TYPED_ARRAY_SUPPORT
      ? 0x7fffffff
      : 0x3fffffff
  }
  
  /**
   * Class: Buffer
   * =============
   *
   * The Buffer constructor returns instances of `Uint8Array` that are augmented
   * with function properties for all the node `Buffer` API functions. We use
   * `Uint8Array` so that square bracket notation works as expected -- it returns
   * a single octet.
   *
   * By augmenting the instances, we can avoid modifying the `Uint8Array`
   * prototype.
   */
  function Buffer (arg) {
    if (!(this instanceof Buffer)) {
      // Avoid going through an ArgumentsAdaptorTrampoline in the common case.
      if (arguments.length > 1) return new Buffer(arg, arguments[1])
      return new Buffer(arg)
    }
  
    if (!Buffer.TYPED_ARRAY_SUPPORT) {
      this.length = 0
      this.parent = undefined
    }
  
    // Common case.
    if (typeof arg === 'number') {
      return fromNumber(this, arg)
    }
  
    // Slightly less common case.
    if (typeof arg === 'string') {
      return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')
    }
  
    // Unusual.
    return fromObject(this, arg)
  }
  
  function fromNumber (that, length) {
    that = allocate(that, length < 0 ? 0 : checked(length) | 0)
    if (!Buffer.TYPED_ARRAY_SUPPORT) {
      for (var i = 0; i < length; i++) {
        that[i] = 0
      }
    }
    return that
  }
  
  function fromString (that, string, encoding) {
    if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'
  
    // Assumption: byteLength() return value is always < kMaxLength.
    var length = byteLength(string, encoding) | 0
    that = allocate(that, length)
  
    that.write(string, encoding)
    return that
  }
  
  function fromObject (that, object) {
    if (Buffer.isBuffer(object)) return fromBuffer(that, object)
  
    if (isArray(object)) return fromArray(that, object)
  
    if (object == null) {
      throw new TypeError('must start with number, buffer, array or string')
    }
  
    if (typeof ArrayBuffer !== 'undefined') {
      if (object.buffer instanceof ArrayBuffer) {
        return fromTypedArray(that, object)
      }
      if (object instanceof ArrayBuffer) {
        return fromArrayBuffer(that, object)
      }
    }
  
    if (object.length) return fromArrayLike(that, object)
  
    return fromJsonObject(that, object)
  }
  
  function fromBuffer (that, buffer) {
    var length = checked(buffer.length) | 0
    that = allocate(that, length)
    buffer.copy(that, 0, 0, length)
    return that
  }
  
  function fromArray (that, array) {
    var length = checked(array.length) | 0
    that = allocate(that, length)
    for (var i = 0; i < length; i += 1) {
      that[i] = array[i] & 255
    }
    return that
  }
  
  // Duplicate of fromArray() to keep fromArray() monomorphic.
  function fromTypedArray (that, array) {
    var length = checked(array.length) | 0
    that = allocate(that, length)
    // Truncating the elements is probably not what people expect from typed
    // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
    // of the old Buffer constructor.
    for (var i = 0; i < length; i += 1) {
      that[i] = array[i] & 255
    }
    return that
  }
  
  function fromArrayBuffer (that, array) {
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      // Return an augmented `Uint8Array` instance, for best performance
      array.byteLength
      that = Buffer._augment(new Uint8Array(array))
    } else {
      // Fallback: Return an object instance of the Buffer class
      that = fromTypedArray(that, new Uint8Array(array))
    }
    return that
  }
  
  function fromArrayLike (that, array) {
    var length = checked(array.length) | 0
    that = allocate(that, length)
    for (var i = 0; i < length; i += 1) {
      that[i] = array[i] & 255
    }
    return that
  }
  
  // Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
  // Returns a zero-length buffer for inputs that don't conform to the spec.
  function fromJsonObject (that, object) {
    var array
    var length = 0
  
    if (object.type === 'Buffer' && isArray(object.data)) {
      array = object.data
      length = checked(array.length) | 0
    }
    that = allocate(that, length)
  
    for (var i = 0; i < length; i += 1) {
      that[i] = array[i] & 255
    }
    return that
  }
  
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    Buffer.prototype.__proto__ = Uint8Array.prototype
    Buffer.__proto__ = Uint8Array
  } else {
    // pre-set for values that may exist in the future
    Buffer.prototype.length = undefined
    Buffer.prototype.parent = undefined
  }
  
  function allocate (that, length) {
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      // Return an augmented `Uint8Array` instance, for best performance
      that = Buffer._augment(new Uint8Array(length))
      that.__proto__ = Buffer.prototype
    } else {
      // Fallback: Return an object instance of the Buffer class
      that.length = length
      that._isBuffer = true
    }
  
    var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1
    if (fromPool) that.parent = rootParent
  
    return that
  }
  
  function checked (length) {
    // Note: cannot use `length < kMaxLength` here because that fails when
    // length is NaN (which is otherwise coerced to zero.)
    if (length >= kMaxLength()) {
      throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                           'size: 0x' + kMaxLength().toString(16) + ' bytes')
    }
    return length | 0
  }
  
  function SlowBuffer (subject, encoding) {
    if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)
  
    var buf = new Buffer(subject, encoding)
    delete buf.parent
    return buf
  }
  
  Buffer.isBuffer = function isBuffer (b) {
    return !!(b != null && b._isBuffer)
  }
  
  Buffer.compare = function compare (a, b) {
    if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
      throw new TypeError('Arguments must be Buffers')
    }
  
    if (a === b) return 0
  
    var x = a.length
    var y = b.length
  
    var i = 0
    var len = Math.min(x, y)
    while (i < len) {
      if (a[i] !== b[i]) break
  
      ++i
    }
  
    if (i !== len) {
      x = a[i]
      y = b[i]
    }
  
    if (x < y) return -1
    if (y < x) return 1
    return 0
  }
  
  Buffer.isEncoding = function isEncoding (encoding) {
    switch (String(encoding).toLowerCase()) {
      case 'hex':
      case 'utf8':
      case 'utf-8':
      case 'ascii':
      case 'binary':
      case 'base64':
      case 'raw':
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return true
      default:
        return false
    }
  }
  
  Buffer.concat = function concat (list, length) {
    if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')
  
    if (list.length === 0) {
      return new Buffer(0)
    }
  
    var i
    if (length === undefined) {
      length = 0
      for (i = 0; i < list.length; i++) {
        length += list[i].length
      }
    }
  
    var buf = new Buffer(length)
    var pos = 0
    for (i = 0; i < list.length; i++) {
      var item = list[i]
      item.copy(buf, pos)
      pos += item.length
    }
    return buf
  }
  
  function byteLength (string, encoding) {
    if (typeof string !== 'string') string = '' + string
  
    var len = string.length
    if (len === 0) return 0
  
    // Use a for loop to avoid recursion
    var loweredCase = false
    for (;;) {
      switch (encoding) {
        case 'ascii':
        case 'binary':
        // Deprecated
        case 'raw':
        case 'raws':
          return len
        case 'utf8':
        case 'utf-8':
          return utf8ToBytes(string).length
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return len * 2
        case 'hex':
          return len >>> 1
        case 'base64':
          return base64ToBytes(string).length
        default:
          if (loweredCase) return utf8ToBytes(string).length // assume utf8
          encoding = ('' + encoding).toLowerCase()
          loweredCase = true
      }
    }
  }
  Buffer.byteLength = byteLength
  
  function slowToString (encoding, start, end) {
    var loweredCase = false
  
    start = start | 0
    end = end === undefined || end === Infinity ? this.length : end | 0
  
    if (!encoding) encoding = 'utf8'
    if (start < 0) start = 0
    if (end > this.length) end = this.length
    if (end <= start) return ''
  
    while (true) {
      switch (encoding) {
        case 'hex':
          return hexSlice(this, start, end)
  
        case 'utf8':
        case 'utf-8':
          return utf8Slice(this, start, end)
  
        case 'ascii':
          return asciiSlice(this, start, end)
  
        case 'binary':
          return binarySlice(this, start, end)
  
        case 'base64':
          return base64Slice(this, start, end)
  
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return utf16leSlice(this, start, end)
  
        default:
          if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
          encoding = (encoding + '').toLowerCase()
          loweredCase = true
      }
    }
  }
  
  Buffer.prototype.toString = function toString () {
    var length = this.length | 0
    if (length === 0) return ''
    if (arguments.length === 0) return utf8Slice(this, 0, length)
    return slowToString.apply(this, arguments)
  }
  
  Buffer.prototype.equals = function equals (b) {
    if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
    if (this === b) return true
    return Buffer.compare(this, b) === 0
  }
  
  Buffer.prototype.inspect = function inspect () {
    var str = ''
    var max = exports.INSPECT_MAX_BYTES
    if (this.length > 0) {
      str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
      if (this.length > max) str += ' ... '
    }
    return '<Buffer ' + str + '>'
  }
  
  Buffer.prototype.compare = function compare (b) {
    if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
    if (this === b) return 0
    return Buffer.compare(this, b)
  }
  
  Buffer.prototype.indexOf = function indexOf (val, byteOffset) {
    if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff
    else if (byteOffset < -0x80000000) byteOffset = -0x80000000
    byteOffset >>= 0
  
    if (this.length === 0) return -1
    if (byteOffset >= this.length) return -1
  
    // Negative offsets start from the end of the buffer
    if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)
  
    if (typeof val === 'string') {
      if (val.length === 0) return -1 // special case: looking for empty string always fails
      return String.prototype.indexOf.call(this, val, byteOffset)
    }
    if (Buffer.isBuffer(val)) {
      return arrayIndexOf(this, val, byteOffset)
    }
    if (typeof val === 'number') {
      if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {
        return Uint8Array.prototype.indexOf.call(this, val, byteOffset)
      }
      return arrayIndexOf(this, [ val ], byteOffset)
    }
  
    function arrayIndexOf (arr, val, byteOffset) {
      var foundIndex = -1
      for (var i = 0; byteOffset + i < arr.length; i++) {
        if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
          if (foundIndex === -1) foundIndex = i
          if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex
        } else {
          foundIndex = -1
        }
      }
      return -1
    }
  
    throw new TypeError('val must be string, number or Buffer')
  }
  
  // `get` is deprecated
  Buffer.prototype.get = function get (offset) {
    console.log('.get() is deprecated. Access using array indexes instead.')
    return this.readUInt8(offset)
  }
  
  // `set` is deprecated
  Buffer.prototype.set = function set (v, offset) {
    console.log('.set() is deprecated. Access using array indexes instead.')
    return this.writeUInt8(v, offset)
  }
  
  function hexWrite (buf, string, offset, length) {
    offset = Number(offset) || 0
    var remaining = buf.length - offset
    if (!length) {
      length = remaining
    } else {
      length = Number(length)
      if (length > remaining) {
        length = remaining
      }
    }
  
    // must be an even number of digits
    var strLen = string.length
    if (strLen % 2 !== 0) throw new Error('Invalid hex string')
  
    if (length > strLen / 2) {
      length = strLen / 2
    }
    for (var i = 0; i < length; i++) {
      var parsed = parseInt(string.substr(i * 2, 2), 16)
      if (isNaN(parsed)) throw new Error('Invalid hex string')
      buf[offset + i] = parsed
    }
    return i
  }
  
  function utf8Write (buf, string, offset, length) {
    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
  }
  
  function asciiWrite (buf, string, offset, length) {
    return blitBuffer(asciiToBytes(string), buf, offset, length)
  }
  
  function binaryWrite (buf, string, offset, length) {
    return asciiWrite(buf, string, offset, length)
  }
  
  function base64Write (buf, string, offset, length) {
    return blitBuffer(base64ToBytes(string), buf, offset, length)
  }
  
  function ucs2Write (buf, string, offset, length) {
    return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
  }
  
  Buffer.prototype.write = function write (string, offset, length, encoding) {
    // Buffer#write(string)
    if (offset === undefined) {
      encoding = 'utf8'
      length = this.length
      offset = 0
    // Buffer#write(string, encoding)
    } else if (length === undefined && typeof offset === 'string') {
      encoding = offset
      length = this.length
      offset = 0
    // Buffer#write(string, offset[, length][, encoding])
    } else if (isFinite(offset)) {
      offset = offset | 0
      if (isFinite(length)) {
        length = length | 0
        if (encoding === undefined) encoding = 'utf8'
      } else {
        encoding = length
        length = undefined
      }
    // legacy write(string, encoding, offset, length) - remove in v0.13
    } else {
      var swap = encoding
      encoding = offset
      offset = length | 0
      length = swap
    }
  
    var remaining = this.length - offset
    if (length === undefined || length > remaining) length = remaining
  
    if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
      throw new RangeError('attempt to write outside buffer bounds')
    }
  
    if (!encoding) encoding = 'utf8'
  
    var loweredCase = false
    for (;;) {
      switch (encoding) {
        case 'hex':
          return hexWrite(this, string, offset, length)
  
        case 'utf8':
        case 'utf-8':
          return utf8Write(this, string, offset, length)
  
        case 'ascii':
          return asciiWrite(this, string, offset, length)
  
        case 'binary':
          return binaryWrite(this, string, offset, length)
  
        case 'base64':
          // Warning: maxLength not taken into account in base64Write
          return base64Write(this, string, offset, length)
  
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return ucs2Write(this, string, offset, length)
  
        default:
          if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
          encoding = ('' + encoding).toLowerCase()
          loweredCase = true
      }
    }
  }
  
  Buffer.prototype.toJSON = function toJSON () {
    return {
      type: 'Buffer',
      data: Array.prototype.slice.call(this._arr || this, 0)
    }
  }
  
  function base64Slice (buf, start, end) {
    if (start === 0 && end === buf.length) {
      return base64.fromByteArray(buf)
    } else {
      return base64.fromByteArray(buf.slice(start, end))
    }
  }
  
  function utf8Slice (buf, start, end) {
    end = Math.min(buf.length, end)
    var res = []
  
    var i = start
    while (i < end) {
      var firstByte = buf[i]
      var codePoint = null
      var bytesPerSequence = (firstByte > 0xEF) ? 4
        : (firstByte > 0xDF) ? 3
        : (firstByte > 0xBF) ? 2
        : 1
  
      if (i + bytesPerSequence <= end) {
        var secondByte, thirdByte, fourthByte, tempCodePoint
  
        switch (bytesPerSequence) {
          case 1:
            if (firstByte < 0x80) {
              codePoint = firstByte
            }
            break
          case 2:
            secondByte = buf[i + 1]
            if ((secondByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
              if (tempCodePoint > 0x7F) {
                codePoint = tempCodePoint
              }
            }
            break
          case 3:
            secondByte = buf[i + 1]
            thirdByte = buf[i + 2]
            if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
              if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
                codePoint = tempCodePoint
              }
            }
            break
          case 4:
            secondByte = buf[i + 1]
            thirdByte = buf[i + 2]
            fourthByte = buf[i + 3]
            if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
              if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                codePoint = tempCodePoint
              }
            }
        }
      }
  
      if (codePoint === null) {
        // we did not generate a valid codePoint so insert a
        // replacement char (U+FFFD) and advance only 1 byte
        codePoint = 0xFFFD
        bytesPerSequence = 1
      } else if (codePoint > 0xFFFF) {
        // encode to utf16 (surrogate pair dance)
        codePoint -= 0x10000
        res.push(codePoint >>> 10 & 0x3FF | 0xD800)
        codePoint = 0xDC00 | codePoint & 0x3FF
      }
  
      res.push(codePoint)
      i += bytesPerSequence
    }
  
    return decodeCodePointsArray(res)
  }
  
  // Based on http://stackoverflow.com/a/22747272/680742, the browser with
  // the lowest limit is Chrome, with 0x10000 args.
  // We go 1 magnitude less, for safety
  var MAX_ARGUMENTS_LENGTH = 0x1000
  
  function decodeCodePointsArray (codePoints) {
    var len = codePoints.length
    if (len <= MAX_ARGUMENTS_LENGTH) {
      return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
    }
  
    // Decode in chunks to avoid "call stack size exceeded".
    var res = ''
    var i = 0
    while (i < len) {
      res += String.fromCharCode.apply(
        String,
        codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
      )
    }
    return res
  }
  
  function asciiSlice (buf, start, end) {
    var ret = ''
    end = Math.min(buf.length, end)
  
    for (var i = start; i < end; i++) {
      ret += String.fromCharCode(buf[i] & 0x7F)
    }
    return ret
  }
  
  function binarySlice (buf, start, end) {
    var ret = ''
    end = Math.min(buf.length, end)
  
    for (var i = start; i < end; i++) {
      ret += String.fromCharCode(buf[i])
    }
    return ret
  }
  
  function hexSlice (buf, start, end) {
    var len = buf.length
  
    if (!start || start < 0) start = 0
    if (!end || end < 0 || end > len) end = len
  
    var out = ''
    for (var i = start; i < end; i++) {
      out += toHex(buf[i])
    }
    return out
  }
  
  function utf16leSlice (buf, start, end) {
    var bytes = buf.slice(start, end)
    var res = ''
    for (var i = 0; i < bytes.length; i += 2) {
      res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
    }
    return res
  }
  
  Buffer.prototype.slice = function slice (start, end) {
    var len = this.length
    start = ~~start
    end = end === undefined ? len : ~~end
  
    if (start < 0) {
      start += len
      if (start < 0) start = 0
    } else if (start > len) {
      start = len
    }
  
    if (end < 0) {
      end += len
      if (end < 0) end = 0
    } else if (end > len) {
      end = len
    }
  
    if (end < start) end = start
  
    var newBuf
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      newBuf = Buffer._augment(this.subarray(start, end))
    } else {
      var sliceLen = end - start
      newBuf = new Buffer(sliceLen, undefined)
      for (var i = 0; i < sliceLen; i++) {
        newBuf[i] = this[i + start]
      }
    }
  
    if (newBuf.length) newBuf.parent = this.parent || this
  
    return newBuf
  }
  
  /*
   * Need to make sure that buffer isn't trying to write out of bounds.
   */
  function checkOffset (offset, ext, length) {
    if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
    if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
  }
  
  Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
    offset = offset | 0
    byteLength = byteLength | 0
    if (!noAssert) checkOffset(offset, byteLength, this.length)
  
    var val = this[offset]
    var mul = 1
    var i = 0
    while (++i < byteLength && (mul *= 0x100)) {
      val += this[offset + i] * mul
    }
  
    return val
  }
  
  Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
    offset = offset | 0
    byteLength = byteLength | 0
    if (!noAssert) {
      checkOffset(offset, byteLength, this.length)
    }
  
    var val = this[offset + --byteLength]
    var mul = 1
    while (byteLength > 0 && (mul *= 0x100)) {
      val += this[offset + --byteLength] * mul
    }
  
    return val
  }
  
  Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 1, this.length)
    return this[offset]
  }
  
  Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 2, this.length)
    return this[offset] | (this[offset + 1] << 8)
  }
  
  Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 2, this.length)
    return (this[offset] << 8) | this[offset + 1]
  }
  
  Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length)
  
    return ((this[offset]) |
        (this[offset + 1] << 8) |
        (this[offset + 2] << 16)) +
        (this[offset + 3] * 0x1000000)
  }
  
  Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length)
  
    return (this[offset] * 0x1000000) +
      ((this[offset + 1] << 16) |
      (this[offset + 2] << 8) |
      this[offset + 3])
  }
  
  Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
    offset = offset | 0
    byteLength = byteLength | 0
    if (!noAssert) checkOffset(offset, byteLength, this.length)
  
    var val = this[offset]
    var mul = 1
    var i = 0
    while (++i < byteLength && (mul *= 0x100)) {
      val += this[offset + i] * mul
    }
    mul *= 0x80
  
    if (val >= mul) val -= Math.pow(2, 8 * byteLength)
  
    return val
  }
  
  Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
    offset = offset | 0
    byteLength = byteLength | 0
    if (!noAssert) checkOffset(offset, byteLength, this.length)
  
    var i = byteLength
    var mul = 1
    var val = this[offset + --i]
    while (i > 0 && (mul *= 0x100)) {
      val += this[offset + --i] * mul
    }
    mul *= 0x80
  
    if (val >= mul) val -= Math.pow(2, 8 * byteLength)
  
    return val
  }
  
  Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 1, this.length)
    if (!(this[offset] & 0x80)) return (this[offset])
    return ((0xff - this[offset] + 1) * -1)
  }
  
  Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 2, this.length)
    var val = this[offset] | (this[offset + 1] << 8)
    return (val & 0x8000) ? val | 0xFFFF0000 : val
  }
  
  Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 2, this.length)
    var val = this[offset + 1] | (this[offset] << 8)
    return (val & 0x8000) ? val | 0xFFFF0000 : val
  }
  
  Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length)
  
    return (this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16) |
      (this[offset + 3] << 24)
  }
  
  Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length)
  
    return (this[offset] << 24) |
      (this[offset + 1] << 16) |
      (this[offset + 2] << 8) |
      (this[offset + 3])
  }
  
  Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length)
    return ieee754.read(this, offset, true, 23, 4)
  }
  
  Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length)
    return ieee754.read(this, offset, false, 23, 4)
  }
  
  Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 8, this.length)
    return ieee754.read(this, offset, true, 52, 8)
  }
  
  Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 8, this.length)
    return ieee754.read(this, offset, false, 52, 8)
  }
  
  function checkInt (buf, value, offset, ext, max, min) {
    if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
    if (value > max || value < min) throw new RangeError('value is out of bounds')
    if (offset + ext > buf.length) throw new RangeError('index out of range')
  }
  
  Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
    value = +value
    offset = offset | 0
    byteLength = byteLength | 0
    if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
  
    var mul = 1
    var i = 0
    this[offset] = value & 0xFF
    while (++i < byteLength && (mul *= 0x100)) {
      this[offset + i] = (value / mul) & 0xFF
    }
  
    return offset + byteLength
  }
  
  Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
    value = +value
    offset = offset | 0
    byteLength = byteLength | 0
    if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
  
    var i = byteLength - 1
    var mul = 1
    this[offset + i] = value & 0xFF
    while (--i >= 0 && (mul *= 0x100)) {
      this[offset + i] = (value / mul) & 0xFF
    }
  
    return offset + byteLength
  }
  
  Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
    if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
    this[offset] = (value & 0xff)
    return offset + 1
  }
  
  function objectWriteUInt16 (buf, value, offset, littleEndian) {
    if (value < 0) value = 0xffff + value + 1
    for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
      buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
        (littleEndian ? i : 1 - i) * 8
    }
  }
  
  Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value & 0xff)
      this[offset + 1] = (value >>> 8)
    } else {
      objectWriteUInt16(this, value, offset, true)
    }
    return offset + 2
  }
  
  Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value >>> 8)
      this[offset + 1] = (value & 0xff)
    } else {
      objectWriteUInt16(this, value, offset, false)
    }
    return offset + 2
  }
  
  function objectWriteUInt32 (buf, value, offset, littleEndian) {
    if (value < 0) value = 0xffffffff + value + 1
    for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
      buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
    }
  }
  
  Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      this[offset + 3] = (value >>> 24)
      this[offset + 2] = (value >>> 16)
      this[offset + 1] = (value >>> 8)
      this[offset] = (value & 0xff)
    } else {
      objectWriteUInt32(this, value, offset, true)
    }
    return offset + 4
  }
  
  Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value >>> 24)
      this[offset + 1] = (value >>> 16)
      this[offset + 2] = (value >>> 8)
      this[offset + 3] = (value & 0xff)
    } else {
      objectWriteUInt32(this, value, offset, false)
    }
    return offset + 4
  }
  
  Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) {
      var limit = Math.pow(2, 8 * byteLength - 1)
  
      checkInt(this, value, offset, byteLength, limit - 1, -limit)
    }
  
    var i = 0
    var mul = 1
    var sub = value < 0 ? 1 : 0
    this[offset] = value & 0xFF
    while (++i < byteLength && (mul *= 0x100)) {
      this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
    }
  
    return offset + byteLength
  }
  
  Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) {
      var limit = Math.pow(2, 8 * byteLength - 1)
  
      checkInt(this, value, offset, byteLength, limit - 1, -limit)
    }
  
    var i = byteLength - 1
    var mul = 1
    var sub = value < 0 ? 1 : 0
    this[offset + i] = value & 0xFF
    while (--i >= 0 && (mul *= 0x100)) {
      this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
    }
  
    return offset + byteLength
  }
  
  Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
    if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
    if (value < 0) value = 0xff + value + 1
    this[offset] = (value & 0xff)
    return offset + 1
  }
  
  Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value & 0xff)
      this[offset + 1] = (value >>> 8)
    } else {
      objectWriteUInt16(this, value, offset, true)
    }
    return offset + 2
  }
  
  Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value >>> 8)
      this[offset + 1] = (value & 0xff)
    } else {
      objectWriteUInt16(this, value, offset, false)
    }
    return offset + 2
  }
  
  Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value & 0xff)
      this[offset + 1] = (value >>> 8)
      this[offset + 2] = (value >>> 16)
      this[offset + 3] = (value >>> 24)
    } else {
      objectWriteUInt32(this, value, offset, true)
    }
    return offset + 4
  }
  
  Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
    value = +value
    offset = offset | 0
    if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
    if (value < 0) value = 0xffffffff + value + 1
    if (Buffer.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value >>> 24)
      this[offset + 1] = (value >>> 16)
      this[offset + 2] = (value >>> 8)
      this[offset + 3] = (value & 0xff)
    } else {
      objectWriteUInt32(this, value, offset, false)
    }
    return offset + 4
  }
  
  function checkIEEE754 (buf, value, offset, ext, max, min) {
    if (value > max || value < min) throw new RangeError('value is out of bounds')
    if (offset + ext > buf.length) throw new RangeError('index out of range')
    if (offset < 0) throw new RangeError('index out of range')
  }
  
  function writeFloat (buf, value, offset, littleEndian, noAssert) {
    if (!noAssert) {
      checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
    }
    ieee754.write(buf, value, offset, littleEndian, 23, 4)
    return offset + 4
  }
  
  Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
    return writeFloat(this, value, offset, true, noAssert)
  }
  
  Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
    return writeFloat(this, value, offset, false, noAssert)
  }
  
  function writeDouble (buf, value, offset, littleEndian, noAssert) {
    if (!noAssert) {
      checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
    }
    ieee754.write(buf, value, offset, littleEndian, 52, 8)
    return offset + 8
  }
  
  Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
    return writeDouble(this, value, offset, true, noAssert)
  }
  
  Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
    return writeDouble(this, value, offset, false, noAssert)
  }
  
  // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
  Buffer.prototype.copy = function copy (target, targetStart, start, end) {
    if (!start) start = 0
    if (!end && end !== 0) end = this.length
    if (targetStart >= target.length) targetStart = target.length
    if (!targetStart) targetStart = 0
    if (end > 0 && end < start) end = start
  
    // Copy 0 bytes; we're done
    if (end === start) return 0
    if (target.length === 0 || this.length === 0) return 0
  
    // Fatal error conditions
    if (targetStart < 0) {
      throw new RangeError('targetStart out of bounds')
    }
    if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
    if (end < 0) throw new RangeError('sourceEnd out of bounds')
  
    // Are we oob?
    if (end > this.length) end = this.length
    if (target.length - targetStart < end - start) {
      end = target.length - targetStart + start
    }
  
    var len = end - start
    var i
  
    if (this === target && start < targetStart && targetStart < end) {
      // descending copy from end
      for (i = len - 1; i >= 0; i--) {
        target[i + targetStart] = this[i + start]
      }
    } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
      // ascending copy from start
      for (i = 0; i < len; i++) {
        target[i + targetStart] = this[i + start]
      }
    } else {
      target._set(this.subarray(start, start + len), targetStart)
    }
  
    return len
  }
  
  // fill(value, start=0, end=buffer.length)
  Buffer.prototype.fill = function fill (value, start, end) {
    if (!value) value = 0
    if (!start) start = 0
    if (!end) end = this.length
  
    if (end < start) throw new RangeError('end < start')
  
    // Fill 0 bytes; we're done
    if (end === start) return
    if (this.length === 0) return
  
    if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
    if (end < 0 || end > this.length) throw new RangeError('end out of bounds')
  
    var i
    if (typeof value === 'number') {
      for (i = start; i < end; i++) {
        this[i] = value
      }
    } else {
      var bytes = utf8ToBytes(value.toString())
      var len = bytes.length
      for (i = start; i < end; i++) {
        this[i] = bytes[i % len]
      }
    }
  
    return this
  }
  
  /**
   * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
   * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
   */
  Buffer.prototype.toArrayBuffer = function toArrayBuffer () {
    if (typeof Uint8Array !== 'undefined') {
      if (Buffer.TYPED_ARRAY_SUPPORT) {
        return (new Buffer(this)).buffer
      } else {
        var buf = new Uint8Array(this.length)
        for (var i = 0, len = buf.length; i < len; i += 1) {
          buf[i] = this[i]
        }
        return buf.buffer
      }
    } else {
      throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
    }
  }
  
  // HELPER FUNCTIONS
  // ================
  
  var BP = Buffer.prototype
  
  /**
   * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
   */
  Buffer._augment = function _augment (arr) {
    arr.constructor = Buffer
    arr._isBuffer = true
  
    // save reference to original Uint8Array set method before overwriting
    arr._set = arr.set
  
    // deprecated
    arr.get = BP.get
    arr.set = BP.set
  
    arr.write = BP.write
    arr.toString = BP.toString
    arr.toLocaleString = BP.toString
    arr.toJSON = BP.toJSON
    arr.equals = BP.equals
    arr.compare = BP.compare
    arr.indexOf = BP.indexOf
    arr.copy = BP.copy
    arr.slice = BP.slice
    arr.readUIntLE = BP.readUIntLE
    arr.readUIntBE = BP.readUIntBE
    arr.readUInt8 = BP.readUInt8
    arr.readUInt16LE = BP.readUInt16LE
    arr.readUInt16BE = BP.readUInt16BE
    arr.readUInt32LE = BP.readUInt32LE
    arr.readUInt32BE = BP.readUInt32BE
    arr.readIntLE = BP.readIntLE
    arr.readIntBE = BP.readIntBE
    arr.readInt8 = BP.readInt8
    arr.readInt16LE = BP.readInt16LE
    arr.readInt16BE = BP.readInt16BE
    arr.readInt32LE = BP.readInt32LE
    arr.readInt32BE = BP.readInt32BE
    arr.readFloatLE = BP.readFloatLE
    arr.readFloatBE = BP.readFloatBE
    arr.readDoubleLE = BP.readDoubleLE
    arr.readDoubleBE = BP.readDoubleBE
    arr.writeUInt8 = BP.writeUInt8
    arr.writeUIntLE = BP.writeUIntLE
    arr.writeUIntBE = BP.writeUIntBE
    arr.writeUInt16LE = BP.writeUInt16LE
    arr.writeUInt16BE = BP.writeUInt16BE
    arr.writeUInt32LE = BP.writeUInt32LE
    arr.writeUInt32BE = BP.writeUInt32BE
    arr.writeIntLE = BP.writeIntLE
    arr.writeIntBE = BP.writeIntBE
    arr.writeInt8 = BP.writeInt8
    arr.writeInt16LE = BP.writeInt16LE
    arr.writeInt16BE = BP.writeInt16BE
    arr.writeInt32LE = BP.writeInt32LE
    arr.writeInt32BE = BP.writeInt32BE
    arr.writeFloatLE = BP.writeFloatLE
    arr.writeFloatBE = BP.writeFloatBE
    arr.writeDoubleLE = BP.writeDoubleLE
    arr.writeDoubleBE = BP.writeDoubleBE
    arr.fill = BP.fill
    arr.inspect = BP.inspect
    arr.toArrayBuffer = BP.toArrayBuffer
  
    return arr
  }
  
  var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
  
  function base64clean (str) {
    // Node strips out invalid characters like \n and \t from the string, base64-js does not
    str = stringtrim(str).replace(INVALID_BASE64_RE, '')
    // Node converts strings with length < 2 to ''
    if (str.length < 2) return ''
    // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
    while (str.length % 4 !== 0) {
      str = str + '='
    }
    return str
  }
  
  function stringtrim (str) {
    if (str.trim) return str.trim()
    return str.replace(/^\s+|\s+$/g, '')
  }
  
  function toHex (n) {
    if (n < 16) return '0' + n.toString(16)
    return n.toString(16)
  }
  
  function utf8ToBytes (string, units) {
    units = units || Infinity
    var codePoint
    var length = string.length
    var leadSurrogate = null
    var bytes = []
  
    for (var i = 0; i < length; i++) {
      codePoint = string.charCodeAt(i)
  
      // is surrogate component
      if (codePoint > 0xD7FF && codePoint < 0xE000) {
        // last char was a lead
        if (!leadSurrogate) {
          // no lead yet
          if (codePoint > 0xDBFF) {
            // unexpected trail
            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
            continue
          } else if (i + 1 === length) {
            // unpaired lead
            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
            continue
          }
  
          // valid lead
          leadSurrogate = codePoint
  
          continue
        }
  
        // 2 leads in a row
        if (codePoint < 0xDC00) {
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          leadSurrogate = codePoint
          continue
        }
  
        // valid surrogate pair
        codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
      } else if (leadSurrogate) {
        // valid bmp char, but last char was a lead
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
      }
  
      leadSurrogate = null
  
      // encode utf8
      if (codePoint < 0x80) {
        if ((units -= 1) < 0) break
        bytes.push(codePoint)
      } else if (codePoint < 0x800) {
        if ((units -= 2) < 0) break
        bytes.push(
          codePoint >> 0x6 | 0xC0,
          codePoint & 0x3F | 0x80
        )
      } else if (codePoint < 0x10000) {
        if ((units -= 3) < 0) break
        bytes.push(
          codePoint >> 0xC | 0xE0,
          codePoint >> 0x6 & 0x3F | 0x80,
          codePoint & 0x3F | 0x80
        )
      } else if (codePoint < 0x110000) {
        if ((units -= 4) < 0) break
        bytes.push(
          codePoint >> 0x12 | 0xF0,
          codePoint >> 0xC & 0x3F | 0x80,
          codePoint >> 0x6 & 0x3F | 0x80,
          codePoint & 0x3F | 0x80
        )
      } else {
        throw new Error('Invalid code point')
      }
    }
  
    return bytes
  }
  
  function asciiToBytes (str) {
    var byteArray = []
    for (var i = 0; i < str.length; i++) {
      // Node's code seems to be doing this and not & 0x7F..
      byteArray.push(str.charCodeAt(i) & 0xFF)
    }
    return byteArray
  }
  
  function utf16leToBytes (str, units) {
    var c, hi, lo
    var byteArray = []
    for (var i = 0; i < str.length; i++) {
      if ((units -= 2) < 0) break
  
      c = str.charCodeAt(i)
      hi = c >> 8
      lo = c % 256
      byteArray.push(lo)
      byteArray.push(hi)
    }
  
    return byteArray
  }
  
  function base64ToBytes (str) {
    return base64.toByteArray(base64clean(str))
  }
  
  function blitBuffer (src, dst, offset, length) {
    for (var i = 0; i < length; i++) {
      if ((i + offset >= dst.length) || (i >= src.length)) break
      dst[i + offset] = src[i]
    }
    return i
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-process@0.11.9/browser.js-=@*/
  // shim for using process in browser
  var process = module.exports = {};
  
  // cached from whatever global is present so that test runners that stub it
  // don't break things.  But we need to wrap it in a try catch in case it is
  // wrapped in strict mode code which doesn't define any globals.  It's inside a
  // function because try/catches deoptimize in certain engines.
  
  var cachedSetTimeout;
  var cachedClearTimeout;
  
  function defaultSetTimout() {
      throw new Error('setTimeout has not been defined');
  }
  function defaultClearTimeout () {
      throw new Error('clearTimeout has not been defined');
  }
  (function () {
      try {
          if (typeof setTimeout === 'function') {
              cachedSetTimeout = setTimeout;
          } else {
              cachedSetTimeout = defaultSetTimout;
          }
      } catch (e) {
          cachedSetTimeout = defaultSetTimout;
      }
      try {
          if (typeof clearTimeout === 'function') {
              cachedClearTimeout = clearTimeout;
          } else {
              cachedClearTimeout = defaultClearTimeout;
          }
      } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
      }
  } ())
  function runTimeout(fun) {
      if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
      }
      // if setTimeout wasn't available but was latter defined
      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
      } catch(e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
              return cachedSetTimeout.call(null, fun, 0);
          } catch(e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
              return cachedSetTimeout.call(this, fun, 0);
          }
      }
  
  
  }
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }
  
  
  
  }
  var queue = [];
  var draining = false;
  var currentQueue;
  var queueIndex = -1;
  
  function cleanUpNextTick() {
      if (!draining || !currentQueue) {
          return;
      }
      draining = false;
      if (currentQueue.length) {
          queue = currentQueue.concat(queue);
      } else {
          queueIndex = -1;
      }
      if (queue.length) {
          drainQueue();
      }
  }
  
  function drainQueue() {
      if (draining) {
          return;
      }
      var timeout = runTimeout(cleanUpNextTick);
      draining = true;
  
      var len = queue.length;
      while(len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
              if (currentQueue) {
                  currentQueue[queueIndex].run();
              }
          }
          queueIndex = -1;
          len = queue.length;
      }
      currentQueue = null;
      draining = false;
      runClearTimeout(timeout);
  }
  
  process.nextTick = function (fun) {
      var args = new Array(arguments.length - 1);
      if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
              args[i - 1] = arguments[i];
          }
      }
      queue.push(new Item(fun, args));
      if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
      }
  };
  
  // v8 likes predictible objects
  function Item(fun, array) {
      this.fun = fun;
      this.array = array;
  }
  Item.prototype.run = function () {
      this.fun.apply(null, this.array);
  };
  process.title = 'browser';
  process.browser = true;
  process.env = {};
  process.argv = [];
  process.version = ''; // empty string to avoid regexp issues
  process.versions = {};
  
  function noop() {}
  
  process.on = noop;
  process.addListener = noop;
  process.once = noop;
  process.off = noop;
  process.removeListener = noop;
  process.removeAllListeners = noop;
  process.emit = noop;
  
  process.binding = function (name) {
      throw new Error('process.binding is not supported');
  };
  
  process.cwd = function () { return '/' };
  process.chdir = function (dir) {
      throw new Error('process.chdir is not supported');
  };
  process.umask = function() { return 0; };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-base64-js@0.0.8/lib/b64.js-=@*/
  var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
  
  ;(function (exports) {
  	'use strict';
  
    var Arr = (typeof Uint8Array !== 'undefined')
      ? Uint8Array
      : Array
  
  	var PLUS   = '+'.charCodeAt(0)
  	var SLASH  = '/'.charCodeAt(0)
  	var NUMBER = '0'.charCodeAt(0)
  	var LOWER  = 'a'.charCodeAt(0)
  	var UPPER  = 'A'.charCodeAt(0)
  	var PLUS_URL_SAFE = '-'.charCodeAt(0)
  	var SLASH_URL_SAFE = '_'.charCodeAt(0)
  
  	function decode (elt) {
  		var code = elt.charCodeAt(0)
  		if (code === PLUS ||
  		    code === PLUS_URL_SAFE)
  			return 62 // '+'
  		if (code === SLASH ||
  		    code === SLASH_URL_SAFE)
  			return 63 // '/'
  		if (code < NUMBER)
  			return -1 //no match
  		if (code < NUMBER + 10)
  			return code - NUMBER + 26 + 26
  		if (code < UPPER + 26)
  			return code - UPPER
  		if (code < LOWER + 26)
  			return code - LOWER + 26
  	}
  
  	function b64ToByteArray (b64) {
  		var i, j, l, tmp, placeHolders, arr
  
  		if (b64.length % 4 > 0) {
  			throw new Error('Invalid string. Length must be a multiple of 4')
  		}
  
  		// the number of equal signs (place holders)
  		// if there are two placeholders, than the two characters before it
  		// represent one byte
  		// if there is only one, then the three characters before it represent 2 bytes
  		// this is just a cheap hack to not do indexOf twice
  		var len = b64.length
  		placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
  
  		// base64 is 4/3 + up to two characters of the original data
  		arr = new Arr(b64.length * 3 / 4 - placeHolders)
  
  		// if there are placeholders, only get up to the last complete 4 chars
  		l = placeHolders > 0 ? b64.length - 4 : b64.length
  
  		var L = 0
  
  		function push (v) {
  			arr[L++] = v
  		}
  
  		for (i = 0, j = 0; i < l; i += 4, j += 3) {
  			tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
  			push((tmp & 0xFF0000) >> 16)
  			push((tmp & 0xFF00) >> 8)
  			push(tmp & 0xFF)
  		}
  
  		if (placeHolders === 2) {
  			tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
  			push(tmp & 0xFF)
  		} else if (placeHolders === 1) {
  			tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
  			push((tmp >> 8) & 0xFF)
  			push(tmp & 0xFF)
  		}
  
  		return arr
  	}
  
  	function uint8ToBase64 (uint8) {
  		var i,
  			extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
  			output = "",
  			temp, length
  
  		function encode (num) {
  			return lookup.charAt(num)
  		}
  
  		function tripletToBase64 (num) {
  			return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
  		}
  
  		// go through the array every three bytes, we'll deal with trailing stuff later
  		for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
  			temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
  			output += tripletToBase64(temp)
  		}
  
  		// pad the end with zeros, but make sure to not forget the extra bytes
  		switch (extraBytes) {
  			case 1:
  				temp = uint8[uint8.length - 1]
  				output += encode(temp >> 2)
  				output += encode((temp << 4) & 0x3F)
  				output += '=='
  				break
  			case 2:
  				temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
  				output += encode(temp >> 10)
  				output += encode((temp >> 4) & 0x3F)
  				output += encode((temp << 2) & 0x3F)
  				output += '='
  				break
  		}
  
  		return output
  	}
  
  	exports.toByteArray = b64ToByteArray
  	exports.fromByteArray = uint8ToBase64
  }(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-ieee754@1.1.6/index.js-=@*/
  exports.read = function (buffer, offset, isLE, mLen, nBytes) {
    var e, m
    var eLen = nBytes * 8 - mLen - 1
    var eMax = (1 << eLen) - 1
    var eBias = eMax >> 1
    var nBits = -7
    var i = isLE ? (nBytes - 1) : 0
    var d = isLE ? -1 : 1
    var s = buffer[offset + i]
  
    i += d
  
    e = s & ((1 << (-nBits)) - 1)
    s >>= (-nBits)
    nBits += eLen
    for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
  
    m = e & ((1 << (-nBits)) - 1)
    e >>= (-nBits)
    nBits += mLen
    for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
  
    if (e === 0) {
      e = 1 - eBias
    } else if (e === eMax) {
      return m ? NaN : ((s ? -1 : 1) * Infinity)
    } else {
      m = m + Math.pow(2, mLen)
      e = e - eBias
    }
    return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
  }
  
  exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
    var e, m, c
    var eLen = nBytes * 8 - mLen - 1
    var eMax = (1 << eLen) - 1
    var eBias = eMax >> 1
    var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
    var i = isLE ? 0 : (nBytes - 1)
    var d = isLE ? 1 : -1
    var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
  
    value = Math.abs(value)
  
    if (isNaN(value) || value === Infinity) {
      m = isNaN(value) ? 1 : 0
      e = eMax
    } else {
      e = Math.floor(Math.log(value) / Math.LN2)
      if (value * (c = Math.pow(2, -e)) < 1) {
        e--
        c *= 2
      }
      if (e + eBias >= 1) {
        value += rt / c
      } else {
        value += rt * Math.pow(2, 1 - eBias)
      }
      if (value * c >= 2) {
        e++
        c /= 2
      }
  
      if (e + eBias >= eMax) {
        m = 0
        e = eMax
      } else if (e + eBias >= 1) {
        m = (value * c - 1) * Math.pow(2, mLen)
        e = e + eBias
      } else {
        m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
        e = 0
      }
    }
  
    for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
  
    e = (e << mLen) | m
    eLen += mLen
    for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
  
    buffer[offset + i - d] |= s * 128
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-isarray@1.0.0/index.js-=@*/
  var toString = {}.toString;
  
  module.exports = Array.isArray || function (arr) {
    return toString.call(arr) == '[object Array]';
  };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/index.js-=@*/
  var v1 = require(28),
      v3 = require(29),
      v4 = require(30),
      v5 = require(31);
  
  
  var V1 = 1,
      V2 = 2,
      V3 = 3,
      V4 = 4,
      V5 = 5;
  
  
  module.exports = uuid;
  
  
  uuid.V1 = V1;
  uuid.V2 = V2;
  uuid.V3 = V3;
  uuid.V4 = V4;
  uuid.V5 = V5;
  
  
  function uuid(type, options, buffer, offset) {
      var domain;
  
      switch (type) {
          case V3:
              domain = options;
              options = buffer;
              return v3(domain, options);
          case V4:
              return v4(options, buffer, offset);
          case V5:
              domain = options;
              options = buffer;
              return v5(domain, options);
          default:
              return v1(options, buffer, offset);
      }
  }
  
  
  uuid.v1 = v1;
  uuid.v2 = v1;
  uuid.v3 = v3;
  uuid.v4 = v4;
  uuid.v5 = v5;
  
  uuid.toString = require(32);
  uuid.parse = require(33);
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/v1.js-=@*/
  var now = require(34),
      isNullOrUndefinded = require(10),
      NativeUint8Array = require(35),
      nodeId = require(36),
      emptyObject = require(37),
      seedBytes = require(38),
      toString = require(32);
  
  
  var CLOCKSEQ = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff,
      LAST_MSECS = 0,
      LAST_NSECS = 0;
  
  
  module.exports = v1;
  
  
  function v1(options, buffer, offset) {
      var b = buffer || new NativeUint8Array(16),
          clockseq, msecs, nsecs, dt, tl, tmh, node, n;
  
      i = buffer && offset || 0;
      options = options || emptyObject;
  
      clockseq = isNullOrUndefinded(options.clockseq) ? CLOCKSEQ : options.clockseq;
      msecs = isNullOrUndefinded(options.msecs) ? now.stamp() : options.msecs;
      nsecs = isNullOrUndefinded(options.nsecs) ? LAST_NSECS + 1 : options.nsecs;
      dt = (msecs - LAST_MSECS) + (nsecs - LAST_NSECS) / 10000;
  
      if (dt < 0 && isNullOrUndefinded(options.clockseq)) {
          clockseq = clockseq + 1 & 0x3fff;
      }
      if ((dt < 0 || msecs > LAST_MSECS) && isNullOrUndefinded(options.nsecs)) {
          nsecs = 0;
      }
      if (nsecs >= 10000) {
          throw new Error("v1([options [, buffer [, offset]]]): Can't create more than 10M uuids/sec");
      }
  
      LAST_MSECS = msecs;
      LAST_NSECS = nsecs;
      CLOCKSEQ = clockseq;
  
      // Convert from unix epoch to gregorian epoch
      msecs += 12219292800000;
  
      tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
      b[i++] = tl >>> 24 & 0xff;
      b[i++] = tl >>> 16 & 0xff;
      b[i++] = tl >>> 8 & 0xff;
      b[i++] = tl & 0xff;
  
      tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
      b[i++] = tmh >>> 8 & 0xff;
      b[i++] = tmh & 0xff;
      b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
      b[i++] = tmh >>> 16 & 0xff;
  
      b[i++] = clockseq >>> 8 | 0x80;
      b[i++] = clockseq & 0xff;
  
      node = options.node || nodeId;
      n = -1;
      while (n++ < 5) {
          b[i + n] = node[n];
      }
  
      return buffer ? buffer : toString(b);
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/v3.js-=@*/
  var md5 = require(41),
      toString = require(32);
  
  
  var md5Options = {
      asBytes: true
  };
  
  
  module.exports = v3;
  
  
  function v3(domain /*, options */ ) {
      return toString(md5(domain, md5Options));
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/v4.js-=@*/
  var Buffer = require(22).Buffer;
  var isString = require(15),
      getRandomBytes = require(39),
      toString = require(32),
      emptyObject = require(37);
  
  
  module.exports = v4;
  
  
  function v4(options, buffer, offset) {
      var random, i;
  
      offset = buffer && offset || 0;
  
      if (isString(options)) {
          buffer = (options === "binary") ? new Buffer(16) : null;
          options = null;
      }
      options = options || emptyObject;
  
      random = options.random || (options.getRandomBytes || getRandomBytes)(16);
      random[6] = (random[6] & 0x0f) | 0x40;
      random[8] = (random[8] & 0x3f) | 0x80;
  
      if (buffer) {
          i = -1;
          while (i++ < 15) {
              buffer[offset + i] = random[i];
          }
      }
  
      return buffer || toString(random);
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/v5.js-=@*/
  var sha1 = require(52),
      toString = require(32);
  
  
  var sha1Options = {
      asBytes: true
  };
  
  
  module.exports = v5;
  
  
  function v5(domain /*, options */ ) {
      return toString(sha1(domain, sha1Options));
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/toString.js-=@*/
  var byteToHex = require(40);
  
  
  module.exports = toString;
  
  
  function toString(buffer, offset) {
      var i = offset || 0,
          localByteToHex = byteToHex;
  
      return (
          localByteToHex[buffer[i++]] + localByteToHex[buffer[i++]] +
          localByteToHex[buffer[i++]] + localByteToHex[buffer[i++]] + '-' +
          localByteToHex[buffer[i++]] + localByteToHex[buffer[i++]] + '-' +
          localByteToHex[buffer[i++]] + localByteToHex[buffer[i++]] + '-' +
          localByteToHex[buffer[i++]] + localByteToHex[buffer[i++]] + '-' +
          localByteToHex[buffer[i++]] + localByteToHex[buffer[i++]] +
          localByteToHex[buffer[i++]] + localByteToHex[buffer[i++]] +
          localByteToHex[buffer[i++]] + localByteToHex[buffer[i++]]
      );
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/parse.js-=@*/
  var hexToByte = require(54);
  
  
  var reByte = /[0-9a-f]{2}/g;
  
  
  module.exports = parse;
  
  
  function parse(string, buffer, offset) {
      var i;
  
      offset = buffer ? (offset || 0) : 0;
      i = offset;
  
      buffer = buffer || [];
      string.toLowerCase().replace(reByte, function(oct) {
          if (i < 16) {
              buffer[offset + i++] = hexToByte[oct];
          }
      });
  
      while (i < 16) {
          buffer[offset + i++] = 0;
      }
  
      return buffer;
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/now@0.0.3/src/browser.js-=@*/
  var Date_now = Date.now || function Date_now() {
          return (new Date()).getTime();
      },
      START_TIME = Date_now(),
      performance = global.performance || {};
  
  
  function now() {
      return performance.now();
  }
  
  performance.now = (
      performance.now ||
      performance.webkitNow ||
      performance.mozNow ||
      performance.msNow ||
      performance.oNow ||
      function now() {
          return Date_now() - START_TIME;
      }
  );
  
  now.getStartTime = function getStartTime() {
      return START_TIME;
  };
  
  now.stamp = function stamp() {
      return START_TIME + now();
  };
  
  now.hrtime = function hrtime(previousTimestamp) {
      var clocktime = now() * 1e-3,
          seconds = Math.floor(clocktime),
          nanoseconds = Math.floor((clocktime % 1) * 1e9);
  
      if (previousTimestamp) {
          seconds = seconds - previousTimestamp[0];
          nanoseconds = nanoseconds - previousTimestamp[1];
  
          if (nanoseconds < 0) {
              seconds--;
              nanoseconds += 1e9;
          }
      }
  
      return [seconds, nanoseconds];
  };
  
  
  START_TIME -= now();
  
  
  module.exports = now;
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/NativeUint8Array.js-=@*/
  module.exports = typeof(Uint8Array) !== "undefined" ? Uint8Array : Array;
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/nodeId.js-=@*/
  var seedBytes = require(38);
  
  
  module.exports = [
      seedBytes[0] | 0x01,
      seedBytes[1],
      seedBytes[2],
      seedBytes[3],
      seedBytes[4],
      seedBytes[5]
  ];
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/emptyObject.js-=@*/
  
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/seedBytes.js-=@*/
  var getRandomBytes = require(39);
  
  
  module.exports = getRandomBytes(16);
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/get_random_bytes@0.0.3/src/browser.js-=@*/
  var isFunction = require(2);
  
  
  var globalCrypto = global.crypto || global.msCrypto,
      NativeUint8Array = typeof(Uint8Array) !== "undefined" ? Uint8Array : Array,
      getRandomBytes;
  
  
  if (globalCrypto && isFunction(globalCrypto.getRandomValues)) {
      getRandomBytes = function getRandomBytes(size) {
          return globalCrypto.getRandomValues(new NativeUint8Array(size));
      };
  } else {
      getRandomBytes = function getRandomBytes(size) {
          var bytes = new NativeUint8Array(size),
              i = -1,
              il = size - 1,
              r;
  
          while (i++ < il) {
              if ((i & 0x03) === 0) {
                  r = Math.random() * 0x100000000;
              }
              bytes[i] = r >>> ((i & 0x03) << 3) & 0xff;
          }
  
          return bytes;
      };
  }
  
  
  module.exports = getRandomBytes;
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/byteToHex.js-=@*/
  module.exports = [];
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/md5@0.0.1/src/index.js-=@*/
  var Buffer = require(22).Buffer;
  var isArray = require(42),
      fastSlice = require(43),
      crypto = require(44),
      hex = require(45),
      utf8 = require(46),
      bin = require(47),
      words = require(48);
  
  
  module.exports = md5Wrap;
  
  
  function md5Wrap(message, options) {
      var digestbytes;
  
      if (message == null) {
          throw new TypeError("");
      } else {
          digestbytes = words.wordsToBytes(md5(message, options));
          return options && options.asBytes ? digestbytes : (
              options && options.asString ? bin.bytesToString(digestbytes) : hex.bytesToString(digestbytes)
          );
      }
  }
  
  function FF(a, b, c, d, x, s, t) {
      var n = a + (b & c | ~b & d) + (x >>> 0) + t;
      return ((n << s) | (n >>> (32 - s))) + b;
  }
  
  function GG(a, b, c, d, x, s, t) {
      var n = a + (b & d | c & ~d) + (x >>> 0) + t;
      return ((n << s) | (n >>> (32 - s))) + b;
  }
  
  function HH(a, b, c, d, x, s, t) {
      var n = a + (b ^ c ^ d) + (x >>> 0) + t;
      return ((n << s) | (n >>> (32 - s))) + b;
  }
  
  function II(a, b, c, d, x, s, t) {
      var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
      return ((n << s) | (n >>> (32 - s))) + b;
  }
  
  function md5(message, options) {
      var m, l, a, b, c, d, i, il, aa, bb, cc, dd;
  
      if (message.constructor === String) {
          if (options && options.encoding === "binary") {
              message = bin.stringToBytes(message);
          } else {
              message = utf8.stringToBytes(message);
          }
      } else if (Buffer.isBuffer(message)) {
          message = fastSlice(message, 0);
      } else if (!isArray(message)) {
          message = message.toString();
      }
  
      m = words.bytesToWords(message);
      l = message.length * 8;
      a = 1732584193;
      b = -271733879;
      c = -1732584194;
      d = 271733878;
  
      i = -1;
      il = m.length - 1;
      while (i++ < il) {
          m[i] = ((m[i] << 8) | (m[i] >>> 24)) & 0x00FF00FF | ((m[i] << 24) | (m[i] >>> 8)) & 0xFF00FF00;
      }
  
      m[l >>> 5] |= 0x80 << (l % 32);
      m[(((l + 64) >>> 9) << 4) + 14] = l;
  
      il = m.length;
      for (i = 0; i < il; i += 16) {
          aa = a;
          bb = b;
          cc = c;
          dd = d;
  
          a = FF(a, b, c, d, m[i + 0], 7, -680876936);
          d = FF(d, a, b, c, m[i + 1], 12, -389564586);
          c = FF(c, d, a, b, m[i + 2], 17, 606105819);
          b = FF(b, c, d, a, m[i + 3], 22, -1044525330);
          a = FF(a, b, c, d, m[i + 4], 7, -176418897);
          d = FF(d, a, b, c, m[i + 5], 12, 1200080426);
          c = FF(c, d, a, b, m[i + 6], 17, -1473231341);
          b = FF(b, c, d, a, m[i + 7], 22, -45705983);
          a = FF(a, b, c, d, m[i + 8], 7, 1770035416);
          d = FF(d, a, b, c, m[i + 9], 12, -1958414417);
          c = FF(c, d, a, b, m[i + 10], 17, -42063);
          b = FF(b, c, d, a, m[i + 11], 22, -1990404162);
          a = FF(a, b, c, d, m[i + 12], 7, 1804603682);
          d = FF(d, a, b, c, m[i + 13], 12, -40341101);
          c = FF(c, d, a, b, m[i + 14], 17, -1502002290);
          b = FF(b, c, d, a, m[i + 15], 22, 1236535329);
  
          a = GG(a, b, c, d, m[i + 1], 5, -165796510);
          d = GG(d, a, b, c, m[i + 6], 9, -1069501632);
          c = GG(c, d, a, b, m[i + 11], 14, 643717713);
          b = GG(b, c, d, a, m[i + 0], 20, -373897302);
          a = GG(a, b, c, d, m[i + 5], 5, -701558691);
          d = GG(d, a, b, c, m[i + 10], 9, 38016083);
          c = GG(c, d, a, b, m[i + 15], 14, -660478335);
          b = GG(b, c, d, a, m[i + 4], 20, -405537848);
          a = GG(a, b, c, d, m[i + 9], 5, 568446438);
          d = GG(d, a, b, c, m[i + 14], 9, -1019803690);
          c = GG(c, d, a, b, m[i + 3], 14, -187363961);
          b = GG(b, c, d, a, m[i + 8], 20, 1163531501);
          a = GG(a, b, c, d, m[i + 13], 5, -1444681467);
          d = GG(d, a, b, c, m[i + 2], 9, -51403784);
          c = GG(c, d, a, b, m[i + 7], 14, 1735328473);
          b = GG(b, c, d, a, m[i + 12], 20, -1926607734);
  
          a = HH(a, b, c, d, m[i + 5], 4, -378558);
          d = HH(d, a, b, c, m[i + 8], 11, -2022574463);
          c = HH(c, d, a, b, m[i + 11], 16, 1839030562);
          b = HH(b, c, d, a, m[i + 14], 23, -35309556);
          a = HH(a, b, c, d, m[i + 1], 4, -1530992060);
          d = HH(d, a, b, c, m[i + 4], 11, 1272893353);
          c = HH(c, d, a, b, m[i + 7], 16, -155497632);
          b = HH(b, c, d, a, m[i + 10], 23, -1094730640);
          a = HH(a, b, c, d, m[i + 13], 4, 681279174);
          d = HH(d, a, b, c, m[i + 0], 11, -358537222);
          c = HH(c, d, a, b, m[i + 3], 16, -722521979);
          b = HH(b, c, d, a, m[i + 6], 23, 76029189);
          a = HH(a, b, c, d, m[i + 9], 4, -640364487);
          d = HH(d, a, b, c, m[i + 12], 11, -421815835);
          c = HH(c, d, a, b, m[i + 15], 16, 530742520);
          b = HH(b, c, d, a, m[i + 2], 23, -995338651);
  
          a = II(a, b, c, d, m[i + 0], 6, -198630844);
          d = II(d, a, b, c, m[i + 7], 10, 1126891415);
          c = II(c, d, a, b, m[i + 14], 15, -1416354905);
          b = II(b, c, d, a, m[i + 5], 21, -57434055);
          a = II(a, b, c, d, m[i + 12], 6, 1700485571);
          d = II(d, a, b, c, m[i + 3], 10, -1894986606);
          c = II(c, d, a, b, m[i + 10], 15, -1051523);
          b = II(b, c, d, a, m[i + 1], 21, -2054922799);
          a = II(a, b, c, d, m[i + 8], 6, 1873313359);
          d = II(d, a, b, c, m[i + 15], 10, -30611744);
          c = II(c, d, a, b, m[i + 6], 15, -1560198380);
          b = II(b, c, d, a, m[i + 13], 21, 1309151649);
          a = II(a, b, c, d, m[i + 4], 6, -145523070);
          d = II(d, a, b, c, m[i + 11], 10, -1120210379);
          c = II(c, d, a, b, m[i + 2], 15, 718787259);
          b = II(b, c, d, a, m[i + 9], 21, -343485551);
  
          a = (a + aa) >>> 0;
          b = (b + bb) >>> 0;
          c = (c + cc) >>> 0;
          d = (d + dd) >>> 0;
      }
  
      return crypto.endian([a, b, c, d]);
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_array@0.0.1/src/index.js-=@*/
  var isNative = require(9),
      isLength = require(49),
      isObject = require(3);
  
  
  var objectToString = Object.prototype.toString,
      nativeIsArray = Array.isArray,
      isArray;
  
  
  if (isNative(nativeIsArray)) {
      isArray = nativeIsArray;
  } else {
      isArray = function isArray(value) {
          return (
              isObject(value) &&
              isLength(value.length) &&
              objectToString.call(value) === "[object Array]"
          ) || false;
      };
  }
  
  
  module.exports = isArray;
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/fast_slice@0.0.1/src/index.js-=@*/
  var clamp = require(51),
      isNumber = require(50);
  
  
  module.exports = fastSlice;
  
  
  function fastSlice(array, offset) {
      var length = array.length,
          newLength, i, il, result, j;
  
      offset = clamp(isNumber(offset) ? offset : 0, 0, length);
      i = offset - 1;
      il = length - 1;
      newLength = length - offset;
      result = new Array(newLength);
      j = 0;
  
      while (i++ < il) {
          result[j++] = array[i];
      }
  
      return result;
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/crypto_browser@0.0.1/src/index.js-=@*/
  var process = require(23);
  var isNumber = require(50),
      isFunction = require(2);
  
  
  var crypto = exports,
  
      NativeUint8Array = typeof(Uint8Array) !== "undefined" ? Uint8Array : Array,
      globalCrypto = global.crypto || global.msCrypto,
      randomBytes;
  
  
  crypto.rotl = function(n, b) {
      return (n << b) | (n >>> (32 - b));
  };
  
  crypto.rotr = function(n, b) {
      return (n << (32 - b)) | (n >>> b);
  };
  
  function endian(n) {
      return crypto.rotl(n, 8) & 0x00FF00FF | crypto.rotl(n, 24) & 0xFF00FF00;
  }
  
  function endianArray(array) {
      var i = -1,
          il = array.length - 1;
  
      while (i++ < il) {
          array[i] = endian(array[i]);
      }
  
      return array;
  }
  
  crypto.endian = function(n) {
      if (isNumber(n)) {
          return endian(n);
      } else {
          return endianArray(n);
      }
  };
  
  if (globalCrypto && isFunction(globalCrypto.getRandomValues)) {
      randomBytes = function(size) {
          return crypto.getRandomValues(new NativeUint8Array(size));
      };
  } else {
      randomBytes = function(size) {
          var bytes = new NativeUint8Array(size),
              i = size;
  
          while (i--) {
              bytes[i] = (Math.random() * 256) | 0;
          }
  
          return bytes;
      };
  }
  
  crypto.randomBytes = function(size, callback) {
      if (!isNumber(size)) {
          throw new TypeError("randomBytes(size[, callback]) size must be a number");
      } else {
          if (isFunction(callback)) {
              process.nextTick(function() {
                  callback(undefined, randomBytes(size));
              });
              return undefined;
          } else {
              return randomBytes(size);
          }
      }
  };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/hex_encoding@0.0.1/src/index.js-=@*/
  var hex = exports,
      NativeUint8Array = typeof(Uint8Array) !== "undefined" ? Uint8Array : Array;
  
  
  hex.stringToBytes = function(str) {
      var length = str.length,
          i = 0,
          il = length,
          bytes = new NativeUint8Array(length * 0.5),
          index = 0;
  
      while (i < il) {
          bytes[index] = parseInt(str.substr(i, 2), 16);
          index += 1;
          i += 2;
      }
  
      return bytes;
  };
  
  hex.bytesToString = function(bytes) {
      var str = "",
          i = -1,
          il = bytes.length - 1;
  
      while (i++ < il) {
          str += (bytes[i] >>> 4).toString(16);
          str += (bytes[i] & 0xF).toString(16);
      }
  
      return str;
  };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/utf8_encoding@0.0.1/src/index.js-=@*/
  var bin = require(47);
  
  
  var utf8 = exports;
  
  
  utf8.stringToBytes = function(str) {
      return bin.stringToBytes(unescape(encodeURIComponent(str)));
  };
  
  utf8.bytesToString = function(bytes) {
      return decodeURIComponent(escape(bin.bytesToString(bytes)));
  };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/bin_encoding@0.0.1/src/index.js-=@*/
  var bin = exports,
      NativeUint8Array = typeof(Uint8Array) !== "undefined" ? Uint8Array : Array;
  
  
  bin.stringToBytes = function(str) {
      var length = str.length,
          i = -1,
          il = length - 1,
          bytes = new NativeUint8Array(length),
          index = 0;
  
      while (i++ < il) {
          bytes[index] = str.charCodeAt(i) & 0xFF;
          index += 1;
      }
  
      return bytes;
  };
  
  bin.bytesToString = function(bytes) {
      var str = "",
          i = -1,
          il = bytes.length - 1;
  
      while (i++ < il) {
          str += String.fromCharCode(bytes[i]);
      }
  
      return str;
  };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/words_encoding@0.0.1/src/index.js-=@*/
  var words = exports;
  
  
  words.wordsToBytes = function(words) {
      var bytes = [],
          i = 0,
          il = words.length * 32;
  
      while (i < il) {
          bytes.push((words[i >>> 5] >>> (24 - i % 32)) & 0xFF);
          i += 8;
      }
  
      return bytes;
  };
  
  words.bytesToWords = function(bytes) {
      var words = [],
          i = -1,
          il = bytes.length - 1,
          b = 0;
  
      while (i++ < il) {
          words[b >>> 5] |= bytes[i] << (24 - b % 32);
          b += 8;
      }
  
      return words;
  };
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_length@0.0.1/src/index.js-=@*/
  var isNumber = require(50);
  
  
  var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
  
  
  module.exports = isLength;
  
  
  function isLength(value) {
      return isNumber(value) && value > -1 && value % 1 === 0 && value <= MAX_SAFE_INTEGER;
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_number@0.0.1/src/index.js-=@*/
  module.exports = isNumber;
  
  
  function isNumber(value) {
      return typeof(value) === "number" || false;
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/clamp@0.0.1/src/index.js-=@*/
  module.exports = clamp;
  
  
  function clamp(x, min, max) {
      if (x < min) {
          return min;
      } else if (x > max) {
          return max;
      } else {
          return x;
      }
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/sha1@0.0.3/src/index.js-=@*/
  var isArrayLike = require(53),
      isString = require(15),
      fastSlice = require(43),
      hex = require(45),
      utf8 = require(46),
      bin = require(47),
      words = require(48);
  
  
  var ARRAY = new Array(80);
  
  
  module.exports = sha1Wrap;
  
  
  function sha1Wrap(message, options) {
      var digestbytes = words.wordsToBytes(sha1(message));
  
      return (
          options && options.asBytes ? digestbytes :
          options && options.asString ? bin.bytesToString(digestbytes) :
          hex.bytesToString(digestbytes)
      );
  }
  
  sha1Wrap.blocksize = 16;
  sha1Wrap.digestsize = 20;
  
  function sha1(message) {
      var m, l, w, H0, H1, H2, H3, H4, a, b, c, d, e, i, il, j, n, t;
  
      if (isString(String)) {
          message = utf8.stringToBytes(message);
      } else if (isArrayLike(message)) {
          message = fastSlice(message, 0);
      } else {
          message = message.toString();
      }
  
      m = words.bytesToWords(message);
      l = message.length * 8;
      w = ARRAY;
      H0 = 1732584193;
      H1 = -271733879;
      H2 = -1732584194;
      H3 = 271733878;
      H4 = -1009589776;
  
      m[l >> 5] |= 0x80 << (24 - l % 32);
      m[((l + 64 >>> 9) << 4) + 15] = l;
  
      for (i = 0, il = m.length; i < il; i += 16) {
          a = H0;
          b = H1;
          c = H2;
          d = H3;
          e = H4;
  
          for (j = 0; j < 80; j++) {
              if (j < 16) {
                  w[j] = m[i + j];
              } else {
                  n = w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16];
                  w[j] = (n << 1) | (n >>> 31);
              }
  
              t = ((H0 << 5) | (H0 >>> 27)) + H4 + (w[j] >>> 0) + (
                  j < 20 ? (H1 & H2 | ~H1 & H3) + 1518500249 :
                  j < 40 ? (H1 ^ H2 ^ H3) + 1859775393 :
                  j < 60 ? (H1 & H2 | H1 & H3 | H2 & H3) - 1894007588 :
                  (H1 ^ H2 ^ H3) - 899497514
              );
  
              H4 = H3;
              H3 = H2;
              H2 = (H1 << 30) | (H1 >>> 2);
              H1 = H0;
              H0 = t;
          }
  
          H0 += a;
          H1 += b;
          H2 += c;
          H3 += d;
          H4 += e;
      }
  
      return [H0, H1, H2, H3, H4];
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/is_array_like@0.0.2/src/index.js-=@*/
  var isLength = require(49),
      isFunction = require(2),
      isObject = require(3);
  
  
  module.exports = isArrayLike;
  
  
  function isArrayLike(value) {
      return !isFunction(value) && isObject(value) && isLength(value.length);
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/uuid@0.0.2/src/hexToByte.js-=@*/
  var byteToHex = require(40);
  
  
  var hexToByte = exports,
      i, il;
  
  
  for (i = 0, il = 256; i < il; i++) {
      byteToHex[i] = (i + 0x100).toString(16).substr(1);
      hexToByte[byteToHex[i]] = i;
  }
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/environment@0.0.1/src/index.js-=@*/
  var environment = exports,
  
      hasWindow = typeof(window) !== "undefined",
      userAgent = hasWindow ? window.navigator.userAgent : "";
  
  
  environment.worker = typeof(importScripts) !== "undefined";
  
  environment.browser = environment.worker || !!(
      hasWindow &&
      typeof(navigator) !== "undefined" &&
      window.document
  );
  
  environment.node = !environment.worker && !environment.browser;
  
  environment.mobile = environment.browser && /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent.toLowerCase());
  
  environment.window = (
      hasWindow ? window :
      typeof(global) !== "undefined" ? global :
      typeof(self) !== "undefined" ? self : {}
  );
  
  environment.pixelRatio = environment.window.devicePixelRatio || 1;
  
  environment.document = typeof(document) !== "undefined" ? document : {};
  
  },
  function(require, exports, module, undefined, global) {
  /*@=-@nathanfaucett/messenger_adapter@0.0.1/src/index.js-=@*/
  var MessengerAdapterPrototype;
  
  
  module.exports = createMessengerAdapter;
  
  
  function createMessengerAdapter() {
      var client = new MessengerAdapter(),
          server = new MessengerAdapter();
  
      client.socket = server;
      server.socket = client;
  
      return {
          client: client,
          server: server
      };
  }
  
  function MessengerAdapter() {
      this.socket = null;
      this.__listeners = [];
  }
  MessengerAdapterPrototype = MessengerAdapter.prototype;
  
  MessengerAdapterPrototype.addMessageListener = function(callback) {
      var listeners = this.__listeners;
      listeners[listeners.length] = callback;
  };
  
  MessengerAdapterPrototype.onMessage = function(data) {
      var listeners = this.__listeners,
          i = -1,
          il = listeners.length - 1;
  
      while (i++ < il) {
          listeners[i](data);
      }
  };
  
  MessengerAdapterPrototype.postMessage = function(data) {
      this.socket.onMessage(data);
  };
  
  }], {}, void(0), (new Function("return this;"))()));
  