miniLockLib.js

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.miniLockLib = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  var BLAKE2s, OriginalBLAKE2s,
    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    hasProp = {}.hasOwnProperty;

  OriginalBLAKE2s = require("blake2s-js");

  module.exports = BLAKE2s = (function(superClass) {
    extend(BLAKE2s, superClass);

    function BLAKE2s(params) {
      OriginalBLAKE2s.call(this, params.length, params.key);
    }

    BLAKE2s.prototype.update = function(input) {
      OriginalBLAKE2s.prototype.update.call(this, input);
      return this;
    };

    return BLAKE2s;

  })(OriginalBLAKE2s);

}).call(this);

},{"blake2s-js":13}],2:[function(require,module,exports){
(function (Buffer){
// Generated by CoffeeScript 1.10.0
(function() {
  var Blob;

  module.exports = Blob = (function() {
    function Blob(input, options) {
      var i, len, part;
      if (options == null) {
        options = {};
      }
      switch (input != null ? input.constructor : void 0) {
        case void 0:
          this.buffer = new Buffer(0);
          break;
        case Buffer:
          this.buffer = input;
          break;
        case Number:
          this.buffer = new Buffer(input);
          break;
        case Array:
          this.buffer = new Buffer(0);
          for (i = 0, len = input.length; i < len; i++) {
            part = input[i];
            this.buffer = Buffer.concat([this.buffer, new Buffer(part)]);
          }
      }
      this.type = options.type;
      this.size = this.buffer.length;
    }

    Blob.prototype.slice = function(start, end) {
      return new Blob(this.buffer.slice(start, end));
    };

    return Blob;

  })();

}).call(this);

}).call(this,require("buffer").Buffer)
},{"buffer":15}],3:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  var DecryptOperation,
    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

  module.exports = DecryptOperation = (function() {
    var Blob, ID, NaCl, byteArrayToNumber, decodeBase64, encodeUTF8, ref;

    NaCl = require("tweetnacl");

    NaCl.stream = require("nacl-stream").stream;

    ref = NaCl.util, encodeUTF8 = ref.encodeUTF8, decodeBase64 = ref.decodeBase64;

    ID = require("./ID");

    byteArrayToNumber = require("./util").byteArrayToNumber;

    Blob = (typeof window !== "undefined" && window !== null ? window.Blob : void 0) || require("./Blob");

    DecryptOperation.prototype.chunkSize = 1024 * 1024;

    DecryptOperation.prototype.readSliceOfData = require("./readSliceOfData");

    function DecryptOperation(params) {
      if (params == null) {
        params = {};
      }
      this.start = bind(this.start, this);
      this.data = params.data, this.keys = params.keys, this.callback = params.callback;
      this.decryptedBytes = [];
      if (params.start != null) {
        this.start();
      }
    }

    DecryptOperation.prototype.start = function(callback) {
      var ref1, ref2;
      if (callback != null) {
        this.callback = callback;
      }
      if (((ref1 = this.callback) != null ? ref1.constructor : void 0) !== Function) {
        throw "Can’t start decrypt operation without a callback function.";
      }
      switch (false) {
        case this.data !== void 0:
          this.callback("Can’t decrypt without a Blob of data.");
          break;
        case ((ref2 = this.keys) != null ? ref2.secretKey : void 0) !== void 0:
          this.callback("Can’t decrypt without a set of keys.");
          break;
        default:
          this.startedAt = Date.now();
          this.run();
      }
      return this;
    };

    DecryptOperation.prototype.run = function() {
      return this.readHeader((function(_this) {
        return function(error, header, sizeOfHeader) {
          return _this["decryptVersion" + header.version + "Attributes"](function(error, attributes, startOfEncryptedDataBytes) {
            if (error === void 0) {
              return _this.decryptData(startOfEncryptedDataBytes, function(error, blob) {
                return _this.end(error, blob, attributes, header, sizeOfHeader);
              });
            } else {
              return _this.end(error, void 0, attributes, header, sizeOfHeader);
            }
          });
        };
      })(this));
    };

    DecryptOperation.prototype.end = function(error, blob, attributes, header, sizeOfHeader) {
      if (this.streamDecryptor != null) {
        this.streamDecryptor.clean();
      }
      this.endedAt = Date.now();
      this.duration = this.endedAt - this.startedAt;
      if (error) {
        return this.onerror(error, header, sizeOfHeader);
      } else {
        return this.oncomplete(blob, attributes, header, sizeOfHeader);
      }
    };

    DecryptOperation.prototype.oncomplete = function(blob, attributes, header, sizeOfHeader) {
      return this.callback(void 0, {
        data: blob,
        name: attributes.name,
        type: attributes.type,
        time: attributes.time,
        senderID: this.permit.senderID,
        recipientID: this.permit.recipientID,
        fileKey: this.permit.fileInfo.fileKey,
        fileNonce: this.permit.fileInfo.fileNonce,
        fileHash: this.permit.fileInfo.fileHash,
        duration: this.duration,
        startedAt: this.startedAt,
        endedAt: this.endedAt
      }, header, sizeOfHeader);
    };

    DecryptOperation.prototype.onerror = function(error, header, sizeOfHeader) {
      return this.callback(error, void 0, header, sizeOfHeader);
    };

    DecryptOperation.prototype.decryptVersion1Attributes = function(callback) {
      return this.constructMap((function(_this) {
        return function(error, map) {
          if (error) {
            return callback(error);
          }
          return _this.constructStreamDecryptor(function(error) {
            var ciphertextBytes, end, start;
            if (error) {
              return callback(error);
            }
            ciphertextBytes = map.ciphertextBytes;
            start = ciphertextBytes.start;
            end = ciphertextBytes.start + 256 + 4 + 16;
            return _this.readSliceOfData(start, end, function(error, sliceOfBytes) {
              var attributes, byte, decryptedBytes, nameAsBytes;
              if (error) {
                return callback(error);
              }
              if (decryptedBytes = _this.streamDecryptor.decryptChunk(sliceOfBytes, false)) {
                nameAsBytes = (function() {
                  var i, len, results;
                  results = [];
                  for (i = 0, len = decryptedBytes.length; i < len; i++) {
                    byte = decryptedBytes[i];
                    if (byte !== 0) {
                      results.push(byte);
                    }
                  }
                  return results;
                })();
                attributes = {
                  name: encodeUTF8(nameAsBytes)
                };
                return callback(void 0, attributes, end);
              } else {
                return callback("Failed to decrypt version 1 file attributes.");
              }
            });
          });
        };
      })(this));
    };

    DecryptOperation.prototype.decryptVersion2Attributes = function(callback) {
      return this.constructMap((function(_this) {
        return function(error, map) {
          if (error) {
            return callback(error);
          }
          return _this.constructStreamDecryptor(function(error) {
            var ciphertextBytes, end, start;
            if (error) {
              return callback(error);
            }
            ciphertextBytes = map.ciphertextBytes;
            start = ciphertextBytes.start;
            end = ciphertextBytes.start + 256 + 128 + 24 + 4 + 16;
            return _this.readSliceOfData(start, end, function(error, sliceOfBytes) {
              var attributes, byte, decryptedBytes, decryptedNameBytes, decryptedTimeBytes, decryptedTypeBytes, nameAsBytes, timeAsBytes, typeAsBytes;
              if (error) {
                return callback(error);
              }
              if (decryptedBytes = _this.streamDecryptor.decryptChunk(sliceOfBytes, false)) {
                decryptedNameBytes = decryptedBytes.subarray(0, 256);
                nameAsBytes = (function() {
                  var i, len, results;
                  results = [];
                  for (i = 0, len = decryptedNameBytes.length; i < len; i++) {
                    byte = decryptedNameBytes[i];
                    if (byte !== 0) {
                      results.push(byte);
                    }
                  }
                  return results;
                })();
                decryptedTypeBytes = decryptedBytes.subarray(256, 256 + 128);
                typeAsBytes = (function() {
                  var i, len, results;
                  results = [];
                  for (i = 0, len = decryptedTypeBytes.length; i < len; i++) {
                    byte = decryptedTypeBytes[i];
                    if (byte !== 0) {
                      results.push(byte);
                    }
                  }
                  return results;
                })();
                decryptedTimeBytes = decryptedBytes.subarray(256 + 128, 256 + 128 + 24);
                timeAsBytes = (function() {
                  var i, len, results;
                  results = [];
                  for (i = 0, len = decryptedTimeBytes.length; i < len; i++) {
                    byte = decryptedTimeBytes[i];
                    if (byte !== 0) {
                      results.push(byte);
                    }
                  }
                  return results;
                })();
                attributes = {
                  name: encodeUTF8(nameAsBytes),
                  type: encodeUTF8(typeAsBytes),
                  time: encodeUTF8(timeAsBytes)
                };
                return callback(void 0, attributes, end);
              } else {
                return callback("Failed to decrypt version 2 file attributes.");
              }
            });
          });
        };
      })(this));
    };

    DecryptOperation.prototype.decryptData = function(position, callback) {
      return this.constructStreamDecryptor((function(_this) {
        return function(error) {
          var endPosition, startPosition;
          if (error) {
            return callback(error);
          }
          startPosition = position;
          endPosition = position + _this.chunkSize + 4 + 16;
          return _this.readSliceOfData(startPosition, endPosition, function(error, sliceOfBytes) {
            var decryptedBytes, isLast;
            isLast = position + sliceOfBytes.length === _this.data.size;
            decryptedBytes = _this.streamDecryptor.decryptChunk(sliceOfBytes, isLast);
            if (decryptedBytes) {
              _this.decryptedBytes.push(decryptedBytes);
              if (isLast) {
                return callback(void 0, new Blob(_this.decryptedBytes));
              } else {
                return _this.decryptData(endPosition, callback);
              }
            } else {
              return callback("Failed to decrypt slice of data at [" + startPosition + ".." + endPosition + "]");
            }
          });
        };
      })(this));
    };

    DecryptOperation.prototype.constructMap = function(callback) {
      return this.readHeader((function(_this) {
        return function(error, header, sizeOfHeader) {
          var ciphertextBytes, headerBytes, magicBytes, sizeOfHeaderBytes;
          if ((error === void 0) && (sizeOfHeader != null)) {
            magicBytes = {
              start: 0,
              end: 8
            };
            sizeOfHeaderBytes = {
              start: 8,
              end: 12
            };
            headerBytes = {
              start: 12,
              end: 12 + sizeOfHeader
            };
            ciphertextBytes = {
              start: headerBytes.end,
              end: _this.data.size
            };
          }
          return callback(error, {
            magicBytes: magicBytes,
            sizeOfHeaderBytes: sizeOfHeaderBytes,
            headerBytes: headerBytes,
            ciphertextBytes: ciphertextBytes
          });
        };
      })(this));
    };

    DecryptOperation.prototype.constructStreamDecryptor = function(callback) {
      return this.decryptUniqueNonceAndPermit((function(_this) {
        return function(error, uniqueNonce, permit) {
          if (uniqueNonce && permit) {
            _this.uniqueNonce = uniqueNonce;
            _this.permit = permit;
            _this.fileKey = permit.fileInfo.fileKey;
            _this.fileNonce = permit.fileInfo.fileNonce;
            _this.streamDecryptor = NaCl.stream.createDecryptor(_this.fileKey, _this.fileNonce, _this.chunkSize);
            _this.constructStreamDecryptor = function(callback) {
              return callback(void 0);
            };
            return _this.constructStreamDecryptor(callback);
          } else {
            return callback(error);
          }
        };
      })(this));
    };

    DecryptOperation.prototype.decryptUniqueNonceAndPermit = function(callback) {
      return this.readHeader((function(_this) {
        return function(error, header) {
          var permit, returned, uniqueNonce;
          if (error) {
            return callback(error);
          } else {
            returned = _this.findUniqueNonceAndPermit(header);
            if (returned) {
              uniqueNonce = returned[0], permit = returned[1];
              return callback(void 0, uniqueNonce, permit);
            } else {
              return callback("Can’t decrypt this file with this set of keys.");
            }
          }
        };
      })(this));
    };

    DecryptOperation.prototype.findUniqueNonceAndPermit = function(header) {
      var decodedEncryptedPermit, encodedEncryptedPermit, encodedUniqueNonce, ephemeral, permit, ref1, uniqueNonce;
      ephemeral = decodeBase64(header.ephemeral);
      ref1 = header.decryptInfo;
      for (encodedUniqueNonce in ref1) {
        encodedEncryptedPermit = ref1[encodedUniqueNonce];
        uniqueNonce = decodeBase64(encodedUniqueNonce);
        decodedEncryptedPermit = decodeBase64(encodedEncryptedPermit);
        permit = this.decryptPermit(decodedEncryptedPermit, uniqueNonce, ephemeral);
        if (permit) {
          return [uniqueNonce, permit];
        }
      }
      return void 0;
    };

    DecryptOperation.prototype.decryptPermit = function(decodedEncryptedPermit, uniqueNonce, ephemeral) {
      var decodedEncryptedFileInfo, decryptedPermit, decryptedPermitAsBytes, decryptedPermitAsString, senderPublicKey;
      decryptedPermitAsBytes = NaCl.box.open(decodedEncryptedPermit, uniqueNonce, ephemeral, this.keys.secretKey);
      if (decryptedPermitAsBytes) {
        decryptedPermitAsString = encodeUTF8(decryptedPermitAsBytes);
        decryptedPermit = JSON.parse(decryptedPermitAsString);
        decodedEncryptedFileInfo = decodeBase64(decryptedPermit.fileInfo);
        senderPublicKey = ID.decode(decryptedPermit.senderID);
        decryptedPermit.fileInfo = this.decryptFileInfo(decodedEncryptedFileInfo, uniqueNonce, senderPublicKey);
        return decryptedPermit;
      } else {
        return void 0;
      }
    };

    DecryptOperation.prototype.decryptFileInfo = function(decodedEncryptedFileInfo, uniqueNonce, senderPublicKey) {
      var decryptedFileInfo, decryptedFileInfoAsBytes, decryptedFileInfoAsString;
      decryptedFileInfoAsBytes = NaCl.box.open(decodedEncryptedFileInfo, uniqueNonce, senderPublicKey, this.keys.secretKey);
      if (decryptedFileInfoAsBytes) {
        decryptedFileInfoAsString = encodeUTF8(decryptedFileInfoAsBytes);
        decryptedFileInfo = JSON.parse(decryptedFileInfoAsString);
        return {
          fileHash: decodeBase64(decryptedFileInfo.fileHash),
          fileKey: decodeBase64(decryptedFileInfo.fileKey),
          fileNonce: decodeBase64(decryptedFileInfo.fileNonce)
        };
      } else {
        return void 0;
      }
    };

    DecryptOperation.prototype.readHeader = function(callback) {
      return this.readSizeOfHeader((function(_this) {
        return function(error, sizeOfHeader) {
          if (error) {
            return callback(error);
          }
          return _this.readSliceOfData(12, 12 + sizeOfHeader, function(error, sliceOfBytes) {
            var header, headerAsString;
            if (error) {
              return callback(error);
            }
            headerAsString = encodeUTF8(sliceOfBytes);
            header = JSON.parse(headerAsString);
            return callback(void 0, header, sizeOfHeader);
          });
        };
      })(this));
    };

    DecryptOperation.prototype.readSizeOfHeader = function(callback) {
      return this.readSliceOfData(8, 12, (function(_this) {
        return function(error, sliceOfBytes) {
          var sizeOfHeader;
          if (error) {
            return callback(error);
          }
          sizeOfHeader = byteArrayToNumber(sliceOfBytes);
          return callback(error, sizeOfHeader);
        };
      })(this));
    };

    return DecryptOperation;

  })();

}).call(this);

},{"./Blob":2,"./ID":6,"./readSliceOfData":10,"./util":11,"nacl-stream":21,"tweetnacl":23}],4:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  var EmailAddressPattern;

  exports.isAcceptable = function(emailAddress) {
    return EmailAddressPattern.test(emailAddress);
  };

  EmailAddressPattern = /[-0-9A-Z.+_]+@[-0-9A-Z.+_]+\.[A-Z]{2,20}/i;

}).call(this);

},{}],5:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  var EncryptOperation,
    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
    slice = [].slice;

  module.exports = EncryptOperation = (function() {
    var BLAKE2s, Blob, ID, NaCl, numberToByteArray;

    NaCl = require("tweetnacl");

    NaCl.stream = require("nacl-stream").stream;

    BLAKE2s = require("./BLAKE2s");

    ID = require("./ID");

    numberToByteArray = require("./util").numberToByteArray;

    Blob = (typeof window !== "undefined" && window !== null ? window.Blob : void 0) || require("./Blob");

    EncryptOperation.prototype.chunkSize = 1024 * 1024;

    EncryptOperation.prototype.readSliceOfData = require("./readSliceOfData");

    function EncryptOperation(params) {
      if (params == null) {
        params = {};
      }
      this.end = bind(this.end, this);
      this.start = bind(this.start, this);
      this.data = params.data, this.keys = params.keys, this.name = params.name, this.type = params.type, this.time = params.time, this.miniLockIDs = params.miniLockIDs, this.version = params.version, this.callback = params.callback;
      if (this.version === void 0) {
        this.version = 1;
      }
      this.ephemeral = NaCl.box.keyPair();
      this.fileKey = NaCl.randomBytes(32);
      this.fileNonce = NaCl.randomBytes(24).subarray(0, 16);
      this.hash = new BLAKE2s({
        length: 32
      });
      this.ciphertextBytes = [];
      if (params.start != null) {
        this.start();
      }
    }

    EncryptOperation.prototype.start = function(callback) {
      var ref, ref1, ref2, ref3;
      if (callback != null) {
        this.callback = callback;
      }
      if (((ref = this.callback) != null ? ref.constructor : void 0) !== Function) {
        throw "Can’t start encrypt operation without callback function.";
      }
      switch (false) {
        case (this.data instanceof Blob) !== false:
          this.callback("Can’t encrypt without a Blob of data.");
          break;
        case !((((ref1 = this.keys) != null ? ref1.publicKey : void 0) === void 0) || (((ref2 = this.keys) != null ? ref2.secretKey : void 0) === void 0)):
          this.callback("Can’t encrypt without a set of keys.");
          break;
        case (this.miniLockIDs instanceof Array) !== false:
          this.callback("Can’t encrypt without an Array of miniLock IDs.");
          break;
        case !(this.name && this.name.length > 256):
          this.callback("Can’t encrypt because file name is too long. 256-characters max please.");
          break;
        case !(this.type && this.type.length > 128):
          this.callback("Can’t encrypt because media type is too long. 128-characters max please.");
          break;
        case ((ref3 = this.version) === 1 || ref3 === 2) !== false:
          this.callback("Can’t encrypt because version " + this.version + " is not supported. Version 1 or 2 please.");
          break;
        default:
          this.startedAt = Date.now();
          if (this.time === void 0) {
            this.time = this.startedAt;
          }
          this.run();
      }
      return this;
    };

    EncryptOperation.prototype.run = function() {
      this.encryptAttributes(this.version);
      return this.encryptData(0, (function(_this) {
        return function(error, dataWasEncrypted) {
          var fileFormat;
          if (dataWasEncrypted != null) {
            _this.constructHeader();
            fileFormat = ["miniLock", _this.sizeOfHeaderIn4Bytes, _this.headerJSONBytes].concat(slice.call(_this.ciphertextBytes));
            return _this.end(error, new Blob(fileFormat, {
              type: "application/minilock"
            }));
          } else {
            return _this.end(error);
          }
        };
      })(this));
    };

    EncryptOperation.prototype.end = function(error, blob) {
      if (this.streamEncryptor != null) {
        this.streamEncryptor.clean();
      }
      this.endedAt = Date.now();
      this.duration = this.endedAt - this.startedAt;
      if (error) {
        return this.onerror(error);
      } else {
        return this.oncomplete(blob);
      }
    };

    EncryptOperation.prototype.oncomplete = function(blob) {
      return this.callback(void 0, {
        data: blob,
        name: this.name + ".minilock",
        type: this.type,
        time: this.time,
        senderID: ID.encode(this.keys.publicKey),
        duration: this.duration,
        startedAt: this.startedAt,
        endedAt: this.endedAt
      });
    };

    EncryptOperation.prototype.onerror = function(error) {
      return this.callback(error);
    };

    EncryptOperation.prototype.encryptAttributes = function(version) {
      var bytes, encryptedBytes;
      this.constructStreamEncryptor();
      bytes = (function() {
        switch (version) {
          case 1:
            return new Uint8Array(256);
          case 2:
            return new Uint8Array(256 + 128 + 24);
          default:
            throw "EncryptOperation does not support version " + version + ". Version 1 or 2 please.";
        }
      })();
      bytes.set(this.fixedSizeDecodedName(), 0);
      if (version === 2) {
        bytes.set(this.fixedSizeDecodedType(), 256);
      }
      if (version === 2) {
        bytes.set(this.fixedSizeDecodedTime(), 256 + 128);
      }
      if (encryptedBytes = this.streamEncryptor.encryptChunk(bytes, false)) {
        this.hash.update(encryptedBytes);
        return this.ciphertextBytes.push(encryptedBytes);
      } else {
        throw "EncryptOperation failed to record file attributes.";
      }
    };

    EncryptOperation.prototype.encryptData = function(position, callback) {
      this.constructStreamEncryptor();
      return this.readSliceOfData(position, position + this.chunkSize, (function(_this) {
        return function(error, sliceOfBytes) {
          var encryptedBytes, isLastSlice;
          if (error) {
            return callback(error);
          }
          isLastSlice = position + sliceOfBytes.length === _this.data.size;
          if (encryptedBytes = _this.streamEncryptor.encryptChunk(sliceOfBytes, isLastSlice)) {
            _this.hash.update(encryptedBytes);
            _this.ciphertextBytes.push(encryptedBytes);
            if (isLastSlice) {
              _this.hash.digest();
              return callback(void 0, _this.hash.isFinished);
            } else {
              return _this.encryptData(position + _this.chunkSize, callback);
            }
          } else {
            return callback("Failed to encrypt slice of data at [" + position + ".." + (position + _this.chunkSize) + "]");
          }
        };
      })(this));
    };

    EncryptOperation.prototype.constructHeader = function() {
      var headerJSON;
      this.header = {
        version: this.version,
        ephemeral: NaCl.util.encodeBase64(this.ephemeral.publicKey),
        decryptInfo: this.encodedEncryptedPermits()
      };
      headerJSON = JSON.stringify(this.header);
      this.sizeOfHeaderIn4Bytes = numberToByteArray(headerJSON.length);
      this.headerJSONBytes = NaCl.util.decodeUTF8(headerJSON);
      return this.header;
    };

    EncryptOperation.prototype.constructStreamEncryptor = function() {
      return this.streamEncryptor != null ? this.streamEncryptor : this.streamEncryptor = NaCl.stream.createEncryptor(this.fileKey, this.fileNonce, this.chunkSize);
    };

    EncryptOperation.prototype.fixedSizeDecodedName = function() {
      var decodedName, fixedSize;
      fixedSize = new Uint8Array(256);
      if (this.name) {
        decodedName = NaCl.util.decodeUTF8(this.name);
        if (decodedName.length > fixedSize.length) {
          throw "Can’t set fixed size decoded name because input is too long.";
        }
        fixedSize.set(decodedName);
      }
      return fixedSize;
    };

    EncryptOperation.prototype.fixedSizeDecodedType = function() {
      var decodedType, fixedSize;
      fixedSize = new Uint8Array(128);
      if (this.type) {
        decodedType = NaCl.util.decodeUTF8(this.type);
        if (decodedType.length > fixedSize.length) {
          throw "Can’t set fixed size decoded type because input is too long.";
        }
        fixedSize.set(decodedType);
      }
      return fixedSize;
    };

    EncryptOperation.prototype.fixedSizeDecodedTime = function() {
      var fixedSize, timestamp;
      fixedSize = new Uint8Array(24);
      if (this.time) {
        timestamp = (new Date(this.time)).toJSON();
        fixedSize.set(NaCl.util.decodeUTF8(timestamp));
      }
      return fixedSize;
    };

    EncryptOperation.prototype.encodedEncryptedPermits = function() {
      var encodedEncryptedPermit, encodedUniqueNonce, encryptedPermit, i, len, miniLockID, permits, ref, ref1, uniqueNonce;
      permits = {};
      ref = this.miniLockIDs;
      for (i = 0, len = ref.length; i < len; i++) {
        miniLockID = ref[i];
        ref1 = this.encryptedPermit(miniLockID), uniqueNonce = ref1[0], encryptedPermit = ref1[1];
        encodedUniqueNonce = NaCl.util.encodeBase64(uniqueNonce);
        encodedEncryptedPermit = NaCl.util.encodeBase64(encryptedPermit);
        permits[encodedUniqueNonce] = encodedEncryptedPermit;
      }
      return permits;
    };

    EncryptOperation.prototype.encryptedPermit = function(miniLockID) {
      var decodedPermitJSON, encryptedPermit, permit, recipientPublicKey, ref, uniqueNonce;
      ref = this.permit(miniLockID), uniqueNonce = ref[0], permit = ref[1];
      decodedPermitJSON = NaCl.util.decodeUTF8(JSON.stringify(permit));
      recipientPublicKey = ID.decode(miniLockID);
      encryptedPermit = NaCl.box(decodedPermitJSON, uniqueNonce, recipientPublicKey, this.ephemeral.secretKey);
      return [uniqueNonce, encryptedPermit];
    };

    EncryptOperation.prototype.permit = function(miniLockID) {
      var uniqueNonce;
      uniqueNonce = NaCl.randomBytes(24);
      return [
        uniqueNonce, {
          senderID: ID.encode(this.keys.publicKey),
          recipientID: miniLockID,
          fileInfo: NaCl.util.encodeBase64(this.encryptedFileInfo(miniLockID, uniqueNonce))
        }
      ];
    };

    EncryptOperation.prototype.encryptedFileInfo = function(miniLockID, uniqueNonce) {
      var decodedFileInfoJSON, recipientPublicKey;
      decodedFileInfoJSON = NaCl.util.decodeUTF8(JSON.stringify(this.permitFileInfo()));
      recipientPublicKey = ID.decode(miniLockID);
      return NaCl.box(decodedFileInfoJSON, uniqueNonce, recipientPublicKey, this.keys.secretKey);
    };

    EncryptOperation.prototype.permitFileInfo = function() {
      return {
        fileKey: NaCl.util.encodeBase64(this.fileKey),
        fileNonce: NaCl.util.encodeBase64(this.fileNonce),
        fileHash: NaCl.util.encodeBase64(this.hash.digest())
      };
    };

    return EncryptOperation;

  })();

}).call(this);

},{"./BLAKE2s":1,"./Blob":2,"./ID":6,"./readSliceOfData":10,"./util":11,"nacl-stream":21,"tweetnacl":23}],6:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  var BLAKE2s, Base58;

  Base58 = require("base-58");

  BLAKE2s = require("./BLAKE2s");

  exports.encode = function(publicKey) {
    var i, index, slots;
    if ((publicKey != null ? publicKey.length : void 0) === 32) {
      slots = new Uint8Array(33);
      for (index = i = 0; i <= 32; index = ++i) {
        slots[index] = publicKey[index];
      }
      slots[32] = (new BLAKE2s({
        length: 1
      })).update(publicKey).digest()[0];
      return Base58.encode(slots);
    } else {
      return void 0;
    }
  };

  exports.decode = function(miniLockID) {
    var encodedChecksum, publicKey, slots, trueChecksum;
    slots = Base58.decode(miniLockID);
    if (slots.length === 33) {
      publicKey = new Uint8Array(slots.subarray(0, 32));
      encodedChecksum = slots[32];
      trueChecksum = (new BLAKE2s({
        length: 1
      })).update(publicKey).digest()[0];
      if (encodedChecksum === trueChecksum) {
        return publicKey;
      }
    }
    return void 0;
  };

  exports.isAcceptable = function(miniLockID) {
    return /^[1-9A-Za-z]{40,55}$/.test(miniLockID) && (this.decode(miniLockID) != null);
  };

}).call(this);

},{"./BLAKE2s":1,"base-58":12}],7:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  var KeyPairOperation;

  module.exports = KeyPairOperation = (function() {
    var BLAKE2s, EmailAddress, NaCl, SecretPhrase, calculateCurve25519KeyPair, scrypt;

    BLAKE2s = require("./BLAKE2s");

    NaCl = require("tweetnacl");

    scrypt = require("scrypt-async");

    EmailAddress = require("./EmailAddress");

    SecretPhrase = require("./SecretPhrase");

    function KeyPairOperation(params) {
      this.secretPhrase = params.secretPhrase, this.emailAddress = params.emailAddress;
    }

    KeyPairOperation.prototype.secret = function() {
      return NaCl.util.decodeUTF8(this.secretPhrase);
    };

    KeyPairOperation.prototype.salt = function() {
      return NaCl.util.decodeUTF8(this.emailAddress);
    };

    KeyPairOperation.prototype.hashDigestOfSecret = function() {
      return (new BLAKE2s({
        length: 32
      })).update(this.secret()).digest();
    };

    KeyPairOperation.prototype.start = function(callback) {
      if ((callback != null ? callback.constructor : void 0) !== Function) {
        throw "Can’t make keys without a callback function.";
      }
      if (this.secretPhrase === void 0) {
        callback("Can’t make keys without a secret phrase.");
        return false;
      }
      if (SecretPhrase.isAcceptable(this.secretPhrase) === false) {
        callback("Can’t make keys because '" + this.secretPhrase + "' is not an acceptable secret phrase.");
        return false;
      }
      if (this.emailAddress === void 0) {
        callback("Can’t make keys without an email address.");
        return false;
      }
      if (EmailAddress.isAcceptable(this.emailAddress) === false) {
        callback("Can’t make keys because '" + this.emailAddress + "' is not an acceptable email address.");
        return false;
      }
      if (this.secretPhrase && this.emailAddress && callback) {
        calculateCurve25519KeyPair(this.hashDigestOfSecret(), this.salt(), function(keys) {
          return callback(void 0, keys);
        });
        return this;
      }
    };

    calculateCurve25519KeyPair = function(secret, salt, callback) {
      var dkLen, encoding, interruptStep, logN, r, whenKeysAreReady;
      whenKeysAreReady = function(encodedBytes) {
        var decodedBytes, keys;
        decodedBytes = NaCl.util.decodeBase64(encodedBytes);
        keys = NaCl.box.keyPair.fromSecretKey(decodedBytes);
        return callback(keys);
      };
      logN = 17;
      r = 8;
      dkLen = 32;
      interruptStep = 1000;
      encoding = "base64";
      return scrypt(secret, salt, logN, r, dkLen, interruptStep, whenKeysAreReady, encoding);
    };

    return KeyPairOperation;

  })();

}).call(this);

},{"./BLAKE2s":1,"./EmailAddress":4,"./SecretPhrase":8,"scrypt-async":22,"tweetnacl":23}],8:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  var Entropizer, entropizer;

  exports.isAcceptable = function(secretPhrase) {
    return (secretPhrase != null ? secretPhrase.length : void 0) >= 32 && entropizer.evaluate(secretPhrase) >= 200;
  };

  Entropizer = require("entropizer");

  entropizer = new Entropizer;

}).call(this);

},{"entropizer":20}],9:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  var miniLockLib;

  miniLockLib = module.exports;

  miniLockLib.makeKeyPair = function(secretPhrase, emailAddress, callback) {
    var operation;
    operation = new miniLockLib.KeyPairOperation({
      secretPhrase: secretPhrase,
      emailAddress: emailAddress
    });
    return operation.start(callback);
  };

  miniLockLib.encrypt = function(params, callback) {
    var operation;
    operation = new miniLockLib.EncryptOperation(params);
    return operation.start(callback);
  };

  miniLockLib.decrypt = function(params, callback) {
    var operation;
    operation = new miniLockLib.DecryptOperation(params);
    return operation.start(callback);
  };

  miniLockLib.SecretPhrase = require("./SecretPhrase");

  miniLockLib.EmailAddress = require("./EmailAddress");

  miniLockLib.ID = require("./ID");

  miniLockLib.KeyPairOperation = require("./KeyPairOperation");

  miniLockLib.EncryptOperation = require("./EncryptOperation");

  miniLockLib.DecryptOperation = require("./DecryptOperation");

  miniLockLib.Base58 = require("base-58");

  miniLockLib.BLAKE2s = require("./BLAKE2s");

  miniLockLib.Entropizer = require("entropizer");

  miniLockLib.NaCl = require("tweetnacl");

  miniLockLib.NaCl.stream = require("nacl-stream").stream;

  miniLockLib.scrypt = require("scrypt-async");

}).call(this);

},{"./BLAKE2s":1,"./DecryptOperation":3,"./EmailAddress":4,"./EncryptOperation":5,"./ID":6,"./KeyPairOperation":7,"./SecretPhrase":8,"base-58":12,"entropizer":20,"nacl-stream":21,"scrypt-async":22,"tweetnacl":23}],10:[function(require,module,exports){
(function (process){
// Generated by CoffeeScript 1.10.0
(function() {
  if (typeof window === "undefined") {
    module.exports = function(start, end, callback) {
      var blob, sliceOfBytes;
      blob = this.data.slice(start, end);
      sliceOfBytes = new Uint8Array(blob.buffer);
      return process.nextTick(function() {
        return callback(void 0, sliceOfBytes);
      });
    };
  } else {
    module.exports = function(start, end, callback) {
      if (this.fileReader == null) {
        this.fileReader = new FileReader;
      }
      this.fileReader.readAsArrayBuffer(this.data.slice(start, end));
      this.fileReader.onabort = function(event) {
        console.error("@fileReader.onabort", event);
        return callback("File read abort.");
      };
      this.fileReader.onerror = function(event) {
        console.error("@fileReader.onerror", event);
        return callback("File read error.");
      };
      return this.fileReader.onload = function(event) {
        var sliceOfBytes;
        sliceOfBytes = new Uint8Array(event.target.result);
        return callback(void 0, sliceOfBytes);
      };
    };
  }

}).call(this);

}).call(this,require('_process'))
},{"_process":19}],11:[function(require,module,exports){
// Generated by CoffeeScript 1.10.0
(function() {
  exports.numberToByteArray = function(n) {
    var byteArray, i, index;
    byteArray = new Uint8Array(4);
    for (index = i = 0; i <= 4; index = ++i) {
      byteArray[index] = n & 255;
      n = n >> 8;
    }
    return byteArray;
  };

  exports.byteArrayToNumber = function(byteArray) {
    var i, index, n;
    n = 0;
    for (index = i = 3; i >= 0; index = --i) {
      n += byteArray[index];
      if (index !== 0) {
        n = n << 8;
      }
    }
    return n;
  };

}).call(this);

},{}],12:[function(require,module,exports){
(function (Buffer){
// Generated by CoffeeScript 1.8.0
(function() {
  var ALPHABET, ALPHABET_MAP, Base58, i;

  Base58 = (typeof module !== "undefined" && module !== null ? module.exports : void 0) || (window.Base58 = {});

  ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

  ALPHABET_MAP = {};

  i = 0;

  while (i < ALPHABET.length) {
    ALPHABET_MAP[ALPHABET.charAt(i)] = i;
    i++;
  }

  Base58.encode = function(buffer) {
    var carry, digits, j;
    if (buffer.length === 0) {
      return "";
    }
    i = void 0;
    j = void 0;
    digits = [0];
    i = 0;
    while (i < buffer.length) {
      j = 0;
      while (j < digits.length) {
        digits[j] <<= 8;
        j++;
      }
      digits[0] += buffer[i];
      carry = 0;
      j = 0;
      while (j < digits.length) {
        digits[j] += carry;
        carry = (digits[j] / 58) | 0;
        digits[j] %= 58;
        ++j;
      }
      while (carry) {
        digits.push(carry % 58);
        carry = (carry / 58) | 0;
      }
      i++;
    }
    i = 0;
    while (buffer[i] === 0 && i < buffer.length - 1) {
      digits.push(0);
      i++;
    }
    return digits.reverse().map(function(digit) {
      return ALPHABET[digit];
    }).join("");
  };

  Base58.decode = function(string) {
    var bytes, c, carry, j;
    if (string.length === 0) {
      return new (typeof Uint8Array !== "undefined" && Uint8Array !== null ? Uint8Array : Buffer)(0);
    }
    i = void 0;
    j = void 0;
    bytes = [0];
    i = 0;
    while (i < string.length) {
      c = string[i];
      if (!(c in ALPHABET_MAP)) {
        throw "Base58.decode received unacceptable input. Character '" + c + "' is not in the Base58 alphabet.";
      }
      j = 0;
      while (j < bytes.length) {
        bytes[j] *= 58;
        j++;
      }
      bytes[0] += ALPHABET_MAP[c];
      carry = 0;
      j = 0;
      while (j < bytes.length) {
        bytes[j] += carry;
        carry = bytes[j] >> 8;
        bytes[j] &= 0xff;
        ++j;
      }
      while (carry) {
        bytes.push(carry & 0xff);
        carry >>= 8;
      }
      i++;
    }
    i = 0;
    while (string[i] === "1" && i < string.length - 1) {
      bytes.push(0);
      i++;
    }
    return new (typeof Uint8Array !== "undefined" && Uint8Array !== null ? Uint8Array : Buffer)(bytes.reverse());
  };

}).call(this);

}).call(this,require("buffer").Buffer)
},{"buffer":15}],13:[function(require,module,exports){
var BLAKE2s = (function() {

  var MAX_DIGEST_LENGTH = 32;
  var BLOCK_LENGTH = 64;
  var MAX_KEY_LENGTH = 32;

  var IV = new Uint32Array([
    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
  ]);

  function BLAKE2s(digestLength, key) {
    if (typeof digestLength === 'undefined')
      digestLength = MAX_DIGEST_LENGTH;

    if (digestLength <= 0 || digestLength > MAX_DIGEST_LENGTH)
      throw new Error('bad digestLength');

    this.digestLength = digestLength;

    if (typeof key === 'string')
      throw new TypeError('key must be a Uint8Array or an Array of bytes');

    var keyLength = key ? key.length : 0;
    if (keyLength > MAX_KEY_LENGTH) throw new Error('key is too long');

    this.isFinished = false;

    // Hash state.
    this.h = new Uint32Array(IV);

    // XOR part of parameter block.
    var param = [digestLength & 0xff, keyLength, 1, 1];
    this.h[0] ^= param[0] & 0xff | (param[1] & 0xff) << 8 | (param[2] & 0xff) << 16 | (param[3] & 0xff) << 24;

    // Buffer for data.
    this.x = new Uint8Array(BLOCK_LENGTH);
    this.nx = 0;

    // Byte counter.
    this.t0 = 0;
    this.t1 = 0;

    // Flags.
    this.f0 = 0;
    this.f1 = 0;

    // Fill buffer with key, if present.
    if (keyLength > 0) {
      for (var i = 0; i < keyLength; i++) this.x[i] = key[i];
      for (i = keyLength; i < BLOCK_LENGTH; i++) this.x[i] = 0;
      this.nx = BLOCK_LENGTH;
    }
  }

  BLAKE2s.prototype.processBlock = function(length) {
    this.t0 += length;
    if (this.t0 != this.t0 >>> 0) {
      this.t0 = 0;
      this.t1++;
    }

    var v0  = this.h[0],
        v1  = this.h[1],
        v2  = this.h[2],
        v3  = this.h[3],
        v4  = this.h[4],
        v5  = this.h[5],
        v6  = this.h[6],
        v7  = this.h[7],
        v8  = IV[0],
        v9  = IV[1],
        v10 = IV[2],
        v11 = IV[3],
        v12 = IV[4] ^ this.t0,
        v13 = IV[5] ^ this.t1,
        v14 = IV[6] ^ this.f0,
        v15 = IV[7] ^ this.f1;

    var x = this.x;
    var m0  = x[ 0] & 0xff | (x[ 1] & 0xff) << 8 | (x[ 2] & 0xff) << 16 | (x[ 3] & 0xff) << 24,
        m1  = x[ 4] & 0xff | (x[ 5] & 0xff) << 8 | (x[ 6] & 0xff) << 16 | (x[ 7] & 0xff) << 24,
        m2  = x[ 8] & 0xff | (x[ 9] & 0xff) << 8 | (x[10] & 0xff) << 16 | (x[11] & 0xff) << 24,
        m3  = x[12] & 0xff | (x[13] & 0xff) << 8 | (x[14] & 0xff) << 16 | (x[15] & 0xff) << 24,
        m4  = x[16] & 0xff | (x[17] & 0xff) << 8 | (x[18] & 0xff) << 16 | (x[19] & 0xff) << 24,
        m5  = x[20] & 0xff | (x[21] & 0xff) << 8 | (x[22] & 0xff) << 16 | (x[23] & 0xff) << 24,
        m6  = x[24] & 0xff | (x[25] & 0xff) << 8 | (x[26] & 0xff) << 16 | (x[27] & 0xff) << 24,
        m7  = x[28] & 0xff | (x[29] & 0xff) << 8 | (x[30] & 0xff) << 16 | (x[31] & 0xff) << 24,
        m8  = x[32] & 0xff | (x[33] & 0xff) << 8 | (x[34] & 0xff) << 16 | (x[35] & 0xff) << 24,
        m9  = x[36] & 0xff | (x[37] & 0xff) << 8 | (x[38] & 0xff) << 16 | (x[39] & 0xff) << 24,
        m10 = x[40] & 0xff | (x[41] & 0xff) << 8 | (x[42] & 0xff) << 16 | (x[43] & 0xff) << 24,
        m11 = x[44] & 0xff | (x[45] & 0xff) << 8 | (x[46] & 0xff) << 16 | (x[47] & 0xff) << 24,
        m12 = x[48] & 0xff | (x[49] & 0xff) << 8 | (x[50] & 0xff) << 16 | (x[51] & 0xff) << 24,
        m13 = x[52] & 0xff | (x[53] & 0xff) << 8 | (x[54] & 0xff) << 16 | (x[55] & 0xff) << 24,
        m14 = x[56] & 0xff | (x[57] & 0xff) << 8 | (x[58] & 0xff) << 16 | (x[59] & 0xff) << 24,
        m15 = x[60] & 0xff | (x[61] & 0xff) << 8 | (x[62] & 0xff) << 16 | (x[63] & 0xff) << 24;

    // Round 1.
    v0 += m0;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m2;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m4;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m6;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m5;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m7;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m3;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m1;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m8;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m10;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m12;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m14;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m13;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m15;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m11;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m9;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 2.
    v0 += m14;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m4;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m9;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m13;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m15;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m6;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m8;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m10;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m1;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m0;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m11;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m5;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m7;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m3;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m2;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m12;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 3.
    v0 += m11;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m12;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m5;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m15;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m2;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m13;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m0;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m8;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m10;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m3;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m7;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m9;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m1;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m4;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m6;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m14;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 4.
    v0 += m7;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m3;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m13;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m11;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m12;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m14;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m1;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m9;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m2;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m5;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m4;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m15;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m0;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m8;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m10;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m6;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 5.
    v0 += m9;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m5;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m2;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m10;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m4;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m15;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m7;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m0;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m14;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m11;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m6;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m3;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m8;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m13;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m12;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m1;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 6.
    v0 += m2;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m6;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m0;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m8;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m11;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m3;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m10;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m12;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m4;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m7;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m15;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m1;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m14;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m9;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m5;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m13;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 7.
    v0 += m12;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m1;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m14;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m4;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m13;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m10;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m15;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m5;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m0;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m6;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m9;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m8;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m2;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m11;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m3;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m7;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 8.
    v0 += m13;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m7;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m12;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m3;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m1;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m9;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m14;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m11;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m5;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m15;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m8;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m2;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m6;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m10;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m4;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m0;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 9.
    v0 += m6;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m14;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m11;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m0;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m3;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m8;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m9;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m15;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m12;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m13;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m1;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m10;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m4;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m5;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m7;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v0 += m2;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 7) | v5 >>> 7;

    // Round 10.
    v0 += m10;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v1 += m8;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v2 += m7;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v3 += m1;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v2 += m6;
    v2 += v6;
    v14 ^= v2;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v10 += v14;
    v6 ^= v10;
    v6 = v6 << (32 - 7) | v6 >>> 7;
    v3 += m5;
    v3 += v7;
    v15 ^= v3;
    v15 = v15 << (32 - 8) | v15 >>> 8;
    v11 += v15;
    v7 ^= v11;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v1 += m4;
    v1 += v5;
    v13 ^= v1;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v9 += v13;
    v5 ^= v9;
    v5 = v5 << (32 - 7) | v5 >>> 7;
    v0 += m2;
    v0 += v4;
    v12 ^= v0;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v8 += v12;
    v4 ^= v8;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v0 += m15;
    v0 += v5;
    v15 ^= v0;
    v15 = v15 << (32 - 16) | v15 >>> 16;
    v10 += v15;
    v5 ^= v10;
    v5 = v5 << (32 - 12) | v5 >>> 12;
    v1 += m9;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 16) | v12 >>> 16;
    v11 += v12;
    v6 ^= v11;
    v6 = v6 << (32 - 12) | v6 >>> 12;
    v2 += m3;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 16) | v13 >>> 16;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 12) | v7 >>> 12;
    v3 += m13;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 16) | v14 >>> 16;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 12) | v4 >>> 12;
    v2 += m12;
    v2 += v7;
    v13 ^= v2;
    v13 = v13 << (32 - 8) | v13 >>> 8;
    v8 += v13;
    v7 ^= v8;
    v7 = v7 << (32 - 7) | v7 >>> 7;
    v3 += m0;
    v3 += v4;
    v14 ^= v3;
    v14 = v14 << (32 - 8) | v14 >>> 8;
    v9 += v14;
    v4 ^= v9;
    v4 = v4 << (32 - 7) | v4 >>> 7;
    v1 += m14;
    v1 += v6;
    v12 ^= v1;
    v12 = v12 << (32 - 8) | v12 >>> 8;
    v11 += v12;
    v6 ^= v11;
    v6 = (v6 << (32 - 7)) | (v6 >>> 7);
    v0 += m11;
    v0 += v5;
    v15 ^= v0;
    v15 = (v15 << (32 - 8)) | (v15 >>> 8);
    v10 += v15;
    v5 ^= v10;
    v5 = (v5 << (32 - 7)) | (v5 >>> 7);

    this.h[0] ^= v0 ^ v8;
    this.h[1] ^= v1 ^ v9;
    this.h[2] ^= v2 ^ v10;
    this.h[3] ^= v3 ^ v11;
    this.h[4] ^= v4 ^ v12;
    this.h[5] ^= v5 ^ v13;
    this.h[6] ^= v6 ^ v14;
    this.h[7] ^= v7 ^ v15;
  };

  BLAKE2s.prototype.update = function(p, offset, length) {
    if (typeof p === 'string')
      throw new TypeError('update() accepts Uint8Array or an Array of bytes');
    if (this.isFinished)
      throw new Error('update() after calling digest()');

    if (typeof offset === 'undefined') { offset = 0; }
    if (typeof length === 'undefined') { length = p.length - offset; }

    if (length === 0) return;


    var i, left = 64 - this.nx;

    // Finish buffer.
    if (length > left) {
      for (i = 0; i < left; i++) {
        this.x[this.nx + i] = p[offset + i];
      }
      this.processBlock(64);
      offset += left;
      length -= left;
      this.nx = 0;
    }

    // Process message blocks.
    while (length > 64) {
      for (i = 0; i < 64; i++) {
        this.x[i] = p[offset + i];
      }
      this.processBlock(64);
      offset += 64;
      length -= 64;
      this.nx = 0;
    }

    // Copy leftovers to buffer.
    for (i = 0; i < length; i++) {
      this.x[this.nx + i] = p[offset + i];
    }
    this.nx += length;
  };

  BLAKE2s.prototype.digest = function() {
    var i;

    if (this.isFinished) return this.result;

    for (i = this.nx; i < 64; i++) this.x[i] = 0;

    // Set last block flag.
    this.f0 = 0xffffffff;

    //TODO in tree mode, set f1 to 0xffffffff.
    this.processBlock(this.nx);

    var d = new Uint8Array(32);
    for (i = 0; i < 8; i++) {
      var h = this.h[i];
      d[i * 4 + 0] = (h >>> 0) & 0xff;
      d[i * 4 + 1] = (h >>> 8) & 0xff;
      d[i * 4 + 2] = (h >>> 16) & 0xff;
      d[i * 4 + 3] = (h >>> 24) & 0xff;
    }
    this.result = new Uint8Array(d.subarray(0, this.digestLength));
    this.isFinished = true;
    return this.result;
  };

  BLAKE2s.prototype.hexDigest = function() {
    var hex = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
    var out = [];
    var d = this.digest();
    for (var i = 0; i < d.length; i++) {
      out.push(hex[(d[i] >> 4) & 0xf]);
      out.push(hex[d[i] & 0xf]);
    }
    return out.join('');
  };

  BLAKE2s.digestLength = MAX_DIGEST_LENGTH;
  BLAKE2s.blockLength = BLOCK_LENGTH;
  BLAKE2s.keyLength = MAX_KEY_LENGTH;

  return BLAKE2s;

})();

if (typeof module !== 'undefined' && module.exports) module.exports = BLAKE2s;

},{}],14:[function(require,module,exports){

},{}],15:[function(require,module,exports){
(function (global){
/*!
 * 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('base64-js')
var ieee754 = require('ieee754')
var isArray = require('isarray')

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.
 *
 *   - 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 () {
  try {
    var arr = new Uint8Array(1)
    arr.foo = function () { return 42 }
    return arr.foo() === 42 && // typed array instances can be augmented
        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
}

/**
 * The Buffer constructor returns instances of `Uint8Array` that have their
 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
 * returns a single octet.
 *
 * The `Uint8Array` prototype remains unmodified.
 */
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)
}

// TODO: Legacy, not needed anymore. Remove in next major version.
Buffer._augment = function (arr) {
  arr.__proto__ = Buffer.prototype
  return arr
}

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) {
  array.byteLength // this throws if `array` is not a valid ArrayBuffer

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    // Return an augmented `Uint8Array` instance, for best performance
    that = new Uint8Array(array)
    that.__proto__ = Buffer.prototype
  } 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
  if (typeof Symbol !== 'undefined' && Symbol.species &&
      Buffer[Symbol.species] === Buffer) {
    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
    Object.defineProperty(Buffer, Symbol.species, {
      value: null,
      configurable: true
    })
  }
} 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 = new Uint8Array(length)
    that.__proto__ = Buffer.prototype
  } else {
    // Fallback: Return an object instance of the Buffer class
    that.length = length
  }

  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
    }
  }
}

// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
// Buffer instances.
Buffer.prototype._isBuffer = 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')
}

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 = this.subarray(start, end)
    newBuf.__proto__ = Buffer.prototype
  } 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 (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 {
    Uint8Array.prototype.set.call(
      target,
      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
}

// HELPER FUNCTIONS
// ================

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
}

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"base64-js":16,"ieee754":17,"isarray":18}],16:[function(require,module,exports){
'use strict'

exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray

var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

function init () {
  var i
  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
  var len = code.length

  for (i = 0; i < len; i++) {
    lookup[i] = code[i]
  }

  for (i = 0; i < len; ++i) {
    revLookup[code.charCodeAt(i)] = i
  }
  revLookup['-'.charCodeAt(0)] = 62
  revLookup['_'.charCodeAt(0)] = 63
}

init()

function toByteArray (b64) {
  var i, j, l, tmp, placeHolders, arr
  var len = b64.length

  if (len % 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
  placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0

  // base64 is 4/3 + up to two characters of the original data
  arr = new Arr(len * 3 / 4 - placeHolders)

  // if there are placeholders, only get up to the last complete 4 chars
  l = placeHolders > 0 ? len - 4 : len

  var L = 0

  for (i = 0, j = 0; i < l; i += 4, j += 3) {
    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
    arr[L++] = (tmp & 0xFF0000) >> 16
    arr[L++] = (tmp & 0xFF00) >> 8
    arr[L++] = tmp & 0xFF
  }

  if (placeHolders === 2) {
    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
    arr[L++] = tmp & 0xFF
  } else if (placeHolders === 1) {
    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
    arr[L++] = (tmp >> 8) & 0xFF
    arr[L++] = tmp & 0xFF
  }

  return arr
}

function tripletToBase64 (num) {
  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
}

function encodeChunk (uint8, start, end) {
  var tmp
  var output = []
  for (var i = start; i < end; i += 3) {
    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
    output.push(tripletToBase64(tmp))
  }
  return output.join('')
}

function fromByteArray (uint8) {
  var tmp
  var len = uint8.length
  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
  var output = ''
  var parts = []
  var maxChunkLength = 16383 // must be multiple of 3

  // go through the array every three bytes, we'll deal with trailing stuff later
  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
  }

  // pad the end with zeros, but make sure to not forget the extra bytes
  if (extraBytes === 1) {
    tmp = uint8[len - 1]
    output += lookup[tmp >> 2]
    output += lookup[(tmp << 4) & 0x3F]
    output += '=='
  } else if (extraBytes === 2) {
    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
    output += lookup[tmp >> 10]
    output += lookup[(tmp >> 4) & 0x3F]
    output += lookup[(tmp << 2) & 0x3F]
    output += '='
  }

  parts.push(output)

  return parts.join('')
}

},{}],17:[function(require,module,exports){
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
}

},{}],18:[function(require,module,exports){
var toString = {}.toString;

module.exports = Array.isArray || function (arr) {
  return toString.call(arr) == '[object Array]';
};

},{}],19:[function(require,module,exports){
// shim for using process in browser

var process = module.exports = {};
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
    draining = false;
    if (currentQueue.length) {
        queue = currentQueue.concat(queue);
    } else {
        queueIndex = -1;
    }
    if (queue.length) {
        drainQueue();
    }
}

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = setTimeout(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;
    clearTimeout(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) {
        setTimeout(drainQueue, 0);
    }
};

// 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; };

},{}],20:[function(require,module,exports){
/*!
 * Entropizer - 0.1.3
 * Built: 2014-06-11 22:42
 * https://github.com/jreesuk/entropizer
 * 
 * Copyright (c) 2014 Jonathan Rees
 * Licensed under the MIT License
 */
(function() {
	'use strict';

	var defaultClasses = ['lowercase', 'uppercase', 'numeric', 'symbolsCommon', 'symbolsUncommon'],
		symbolsCommon = ' ,.?!',
		symbolsUncommon = '"£$%^&*()-_=+[]{};:\'@#~<>/\\|`¬¦';

	// Constructor
	function Entropizer(options) {
		var classes = (options && options.classes) || defaultClasses;
		this.classes = [];
		for (var i = 0; i < classes.length; i++) {
			this.classes.push(typeof classes[i] === 'string' ? Entropizer.classes[classes[i]] : classes[i]);
		}
	}

	// Preset character classes
	Entropizer.classes = {
		lowercase: { regex: /[a-z]/, size: 26 },
		uppercase: { regex: /[A-Z]/, size: 26 },
		numeric: { regex: /[0-9]/, size: 10 },
		symbols: { characters: symbolsCommon + symbolsUncommon },
		symbolsCommon: { characters: symbolsCommon },
		symbolsUncommon: { characters: symbolsUncommon },
		hexadecimal: { regex: /[a-fA-F0-9]/, size: 16 }
	};

	// Find the contribution of a character class to a password's alphabet
	Entropizer.prototype._evaluateClass = function(charClass, password) {
		var chars, i;
		if (charClass.regex && charClass.regex.test(password)) {
			return charClass.size;
		}
		else if (charClass.characters) {
			chars = charClass.characters;
			for (i = 0; i < chars.length; i++) {
				if (password.indexOf(chars.charAt(i)) > -1) {
					return chars.length;
				}
			}
		}
		return 0;
	};

	// Calculate the number of bits of entropy in a password
	Entropizer.prototype.evaluate = function(password) {
		var i, alphabetSize = 0;

		if (!password) {
			return 0;
		}

		// Find the alphabet of the password (the union of all the classes it uses)
		for (i = 0; i < this.classes.length; i++) {
			alphabetSize += this._evaluateClass(this.classes[i], password);
		}

		// If it's all unknown characters, return 0 instead of -Infinity
		if (alphabetSize === 0) {
			return 0;
		}

		return Math.log(alphabetSize) / Math.log(2) * password.length;
	};

	// AMD module
	if (typeof define === 'function' && define.amd) {
		define([], function() {
			return Entropizer;
		});
	}
	// CommonJS module
	else if (typeof module === 'object' && typeof module.exports === 'object') {
		module.exports = Entropizer;
	}
	// Define global if no module framework
	else if (typeof window === 'object') {
		window.Entropizer = Entropizer;
	}

})();
},{}],21:[function(require,module,exports){
/*
 * nacl-stream: streaming encryption based on TweetNaCl.js
 * Written by Dmitry Chestnykh in 2014. Public domain.
 * <https://github.com/dchest/nacl-stream-js>
 */
(function(root, f) {
  'use strict';
  if (typeof module !== 'undefined' && module.exports) module.exports.stream = f(require('tweetnacl/nacl-fast'));
  else root.nacl.stream = f(root.nacl);

}(this, function(nacl) {
  'use strict';

  if (!nacl) throw new Error('tweetnacl not loaded');

  var DEFAULT_MAX_CHUNK = 65535;

  var ZEROBYTES = nacl.lowlevel.crypto_secretbox_ZEROBYTES;
  var BOXZEROBYTES = nacl.lowlevel.crypto_secretbox_BOXZEROBYTES;
  var crypto_secretbox = nacl.lowlevel.crypto_secretbox;
  var crypto_secretbox_open = nacl.lowlevel.crypto_secretbox_open;

  function incrementChunkCounter(fullNonce) {
    for (var i = 16; i < 24; i++) {
      fullNonce[i]++;
      if (fullNonce[i]) break;
    }
  }

  function setLastChunkFlag(fullNonce) {
    fullNonce[23] |= 0x80;
  }

  function clean() {
    for (var i = 0; i < arguments.length; i++) {
      var arg = arguments[i];
      for (var j = 0; j < arg.length; j++) arg[j] = 0;
    }
  }

  function readChunkLength(data, offset) {
    offset |= 0;
    if (data.length < offset + 4) return -1;
    return data[offset] | data[offset+1] << 8 |
           data[offset+2] << 16 | data[offset+3] << 24;
  };


  function checkArgs(key, nonce, maxChunkLength) {
    if (key.length !== 32) throw new Error('bad key length, must be 32 bytes');
    if (nonce.length !== 16) throw new Error('bad nonce length, must be 16 bytes');
    if (maxChunkLength >= 0xffffffff) throw new Error('max chunk length is too large');
    if (maxChunkLength < 16) throw new Error('max chunk length is too small');
  }

  function StreamEncryptor(key, nonce, maxChunkLength) {
    checkArgs(key, nonce, maxChunkLength);
    this._key = key;
    this._fullNonce = new Uint8Array(24);
    this._fullNonce.set(nonce);
    this._maxChunkLength = maxChunkLength || DEFAULT_MAX_CHUNK;
    this._in = new Uint8Array(ZEROBYTES + this._maxChunkLength);
    this._out = new Uint8Array(ZEROBYTES + this._maxChunkLength);
    this._done = false;
  }

  StreamEncryptor.prototype.encryptChunk = function(chunk, isLast) {
    if (this._done) throw new Error('called encryptChunk after last chunk');
    var chunkLen = chunk.length;
    if (chunkLen > this._maxChunkLength)
      throw new Error('chunk is too large: ' + chunkLen + ' / ' + this._maxChunkLength);
    for (var i = 0; i < ZEROBYTES; i++) this._in[i] = 0;
    this._in.set(chunk, ZEROBYTES);
    if (isLast) {
      setLastChunkFlag(this._fullNonce);
      this._done = true;
    }
    crypto_secretbox(this._out, this._in, chunkLen + ZEROBYTES, this._fullNonce, this._key);
    incrementChunkCounter(this._fullNonce);
    var encryptedChunk = this._out.subarray(BOXZEROBYTES-4, BOXZEROBYTES-4 + chunkLen+16+4);
    encryptedChunk[0] = (chunkLen >>>  0) & 0xff;
    encryptedChunk[1] = (chunkLen >>>  8) & 0xff;
    encryptedChunk[2] = (chunkLen >>> 16) & 0xff;
    encryptedChunk[3] = (chunkLen >>> 24) & 0xff;
    return new Uint8Array(encryptedChunk);
  };

  StreamEncryptor.prototype.clean = function() {
    clean(this._fullNonce, this._in, this._out);
  };

  function StreamDecryptor(key, nonce, maxChunkLength) {
    checkArgs(key, nonce, maxChunkLength);
    this._key = key;
    this._fullNonce = new Uint8Array(24);
    this._fullNonce.set(nonce);
    this._maxChunkLength = maxChunkLength || DEFAULT_MAX_CHUNK;
    this._in = new Uint8Array(ZEROBYTES + this._maxChunkLength);
    this._out = new Uint8Array(ZEROBYTES + this._maxChunkLength);
    this._failed = false;
    this._done = false;
  }

  StreamDecryptor.prototype._fail = function() {
    this._failed = true;
    this.clean();
    return null;
  };

  StreamDecryptor.prototype.decryptChunk = function(encryptedChunk, isLast) {
    if (this._failed) return null;
    if (this._done) throw new Error('called decryptChunk after last chunk');
    var encryptedChunkLen = encryptedChunk.length;
    if (encryptedChunkLen < 4 + BOXZEROBYTES) return this._fail();
    var chunkLen = readChunkLength(encryptedChunk);
    if (chunkLen < 0 || chunkLen > this._maxChunkLength) return this._fail();
    if (chunkLen + 4 + BOXZEROBYTES !== encryptedChunkLen) return this._fail();
    for (var i = 0; i < BOXZEROBYTES; i++) this._in[i] = 0;
    for (i = 0; i < encryptedChunkLen-4; i++) this._in[BOXZEROBYTES+i] = encryptedChunk[i+4];
    if (isLast) {
      setLastChunkFlag(this._fullNonce);
      this._done = true;
    }
    if (crypto_secretbox_open(this._out, this._in, encryptedChunkLen+BOXZEROBYTES-4,
                this._fullNonce, this._key) !== 0) return this._fail();
    incrementChunkCounter(this._fullNonce);
    return new Uint8Array(this._out.subarray(ZEROBYTES, ZEROBYTES + chunkLen));
  };

  StreamDecryptor.prototype.clean = function() {
    clean(this._fullNonce, this._in, this._out);
  };

  return {
    createEncryptor: function(k, n, c) { return new StreamEncryptor(k, n, c); },
    createDecryptor: function(k, n, c) { return new StreamDecryptor(k, n, c); },
    readChunkLength: readChunkLength
  };

}));

},{"tweetnacl/nacl-fast":23}],22:[function(require,module,exports){
/*!
 * Fast "async" scrypt implementation in JavaScript.
 * Copyright (c) 2013-2015 Dmitry Chestnykh | BSD License
 * https://github.com/dchest/scrypt-async-js
 */

/*
 * Limitation: doesn't support parallelization parameter greater than 1.
 */

/**
 * scrypt(password, salt, logN, r, dkLen, [interruptStep], callback, [encoding])
 *
 * Derives a key from password and salt and calls callback
 * with derived key as the only argument.
 *
 * Calculations are interrupted with setImmediate (or zero setTimeout) at the
 * given interruptSteps to avoid freezing the browser. If interruptStep is not
 * given, it defaults to 1000. If it's zero, the callback is called immediately
 * after the calculation, avoiding setImmediate.
 *
 * @param {string|Array.<number>} password Password.
 * @param {string|Array.<number>} salt Salt.
 * @param {number}  logN  CPU/memory cost parameter (1 to 31).
 * @param {number}  r     Block size parameter.
 * @param {number}  dkLen Length of derived key.
 * @param {number?} interruptStep (optional) Steps to split calculation with timeouts (default 1000).
 * @param {function(string|Array.<number>)} callback Callback function.
 * @param {string?} encoding (optional) Result encoding ("base64", "hex", or null).
 *
 */
function scrypt(password, salt, logN, r, dkLen, interruptStep, callback, encoding) {
  'use strict';

  function SHA256(m) {
    /** @const */ var K = [
      0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
      0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
      0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
      0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
      0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
      0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
      0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
      0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
      0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
      0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
      0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
      0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
      0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
    ];

    var h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a,
        h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19,
        w = new Array(64);

    function blocks(p) {
      var off = 0, len = p.length;
      while (len >= 64) {
        var a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7,
            u, i, j, t1, t2;

        for (i = 0; i < 16; i++) {
          j = off + i*4;
          w[i] = ((p[j] & 0xff)<<24) | ((p[j+1] & 0xff)<<16) |
                 ((p[j+2] & 0xff)<<8) | (p[j+3] & 0xff);
        }

        for (i = 16; i < 64; i++) {
          u = w[i-2];
          t1 = ((u>>>17) | (u<<(32-17))) ^ ((u>>>19) | (u<<(32-19))) ^ (u>>>10);

          u = w[i-15];
          t2 = ((u>>>7) | (u<<(32-7))) ^ ((u>>>18) | (u<<(32-18))) ^ (u>>>3);

          w[i] = (((t1 + w[i-7]) | 0) + ((t2 + w[i-16]) | 0)) | 0;
        }

        for (i = 0; i < 64; i++) {
          t1 = ((((((e>>>6) | (e<<(32-6))) ^ ((e>>>11) | (e<<(32-11))) ^
               ((e>>>25) | (e<<(32-25)))) + ((e & f) ^ (~e & g))) | 0) +
               ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;

          t2 = ((((a>>>2) | (a<<(32-2))) ^ ((a>>>13) | (a<<(32-13))) ^
               ((a>>>22) | (a<<(32-22)))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;

          h = g;
          g = f;
          f = e;
          e = (d + t1) | 0;
          d = c;
          c = b;
          b = a;
          a = (t1 + t2) | 0;
        }

        h0 = (h0 + a) | 0;
        h1 = (h1 + b) | 0;
        h2 = (h2 + c) | 0;
        h3 = (h3 + d) | 0;
        h4 = (h4 + e) | 0;
        h5 = (h5 + f) | 0;
        h6 = (h6 + g) | 0;
        h7 = (h7 + h) | 0;

        off += 64;
        len -= 64;
      }
    }

    blocks(m);

    var i, bytesLeft = m.length % 64,
        bitLenHi = (m.length / 0x20000000) | 0,
        bitLenLo = m.length << 3,
        numZeros = (bytesLeft < 56) ? 56 : 120,
        p = m.slice(m.length - bytesLeft, m.length);

    p.push(0x80);
    for (i = bytesLeft + 1; i < numZeros; i++) p.push(0);
    p.push((bitLenHi>>>24) & 0xff);
    p.push((bitLenHi>>>16) & 0xff);
    p.push((bitLenHi>>>8)  & 0xff);
    p.push((bitLenHi>>>0)  & 0xff);
    p.push((bitLenLo>>>24) & 0xff);
    p.push((bitLenLo>>>16) & 0xff);
    p.push((bitLenLo>>>8)  & 0xff);
    p.push((bitLenLo>>>0)  & 0xff);

    blocks(p);

    return [
      (h0>>>24) & 0xff, (h0>>>16) & 0xff, (h0>>>8) & 0xff, (h0>>>0) & 0xff,
      (h1>>>24) & 0xff, (h1>>>16) & 0xff, (h1>>>8) & 0xff, (h1>>>0) & 0xff,
      (h2>>>24) & 0xff, (h2>>>16) & 0xff, (h2>>>8) & 0xff, (h2>>>0) & 0xff,
      (h3>>>24) & 0xff, (h3>>>16) & 0xff, (h3>>>8) & 0xff, (h3>>>0) & 0xff,
      (h4>>>24) & 0xff, (h4>>>16) & 0xff, (h4>>>8) & 0xff, (h4>>>0) & 0xff,
      (h5>>>24) & 0xff, (h5>>>16) & 0xff, (h5>>>8) & 0xff, (h5>>>0) & 0xff,
      (h6>>>24) & 0xff, (h6>>>16) & 0xff, (h6>>>8) & 0xff, (h6>>>0) & 0xff,
      (h7>>>24) & 0xff, (h7>>>16) & 0xff, (h7>>>8) & 0xff, (h7>>>0) & 0xff
    ];
  }

  function PBKDF2_HMAC_SHA256_OneIter(password, salt, dkLen) {
    // compress password if it's longer than hash block length
    password = password.length <= 64 ? password : SHA256(password);

    var i, innerLen = 64 + salt.length + 4,
        inner = new Array(innerLen),
        outerKey = new Array(64),
        dk = [];

    // inner = (password ^ ipad) || salt || counter
    for (i = 0; i < 64; i++) inner[i] = 0x36;
    for (i = 0; i < password.length; i++) inner[i] ^= password[i];
    for (i = 0; i < salt.length; i++) inner[64+i] = salt[i];
    for (i = innerLen - 4; i < innerLen; i++) inner[i] = 0;

    // outerKey = password ^ opad
    for (i = 0; i < 64; i++) outerKey[i] = 0x5c;
    for (i = 0; i < password.length; i++) outerKey[i] ^= password[i];

    // increments counter inside inner
    function incrementCounter() {
      for (var i = innerLen-1; i >= innerLen-4; i--) {
        inner[i]++;
        if (inner[i] <= 0xff) return;
        inner[i] = 0;
      }
    }

    // output blocks = SHA256(outerKey || SHA256(inner)) ...
    while (dkLen >= 32) {
      incrementCounter();
      dk = dk.concat(SHA256(outerKey.concat(SHA256(inner))));
      dkLen -= 32;
    }
    if (dkLen > 0) {
      incrementCounter();
      dk = dk.concat(SHA256(outerKey.concat(SHA256(inner))).slice(0, dkLen));
    }
    return dk;
  }

  function salsaXOR(tmp, B, bin, bout) {
    var j0  = tmp[0]  ^ B[bin++],
        j1  = tmp[1]  ^ B[bin++],
        j2  = tmp[2]  ^ B[bin++],
        j3  = tmp[3]  ^ B[bin++],
        j4  = tmp[4]  ^ B[bin++],
        j5  = tmp[5]  ^ B[bin++],
        j6  = tmp[6]  ^ B[bin++],
        j7  = tmp[7]  ^ B[bin++],
        j8  = tmp[8]  ^ B[bin++],
        j9  = tmp[9]  ^ B[bin++],
        j10 = tmp[10] ^ B[bin++],
        j11 = tmp[11] ^ B[bin++],
        j12 = tmp[12] ^ B[bin++],
        j13 = tmp[13] ^ B[bin++],
        j14 = tmp[14] ^ B[bin++],
        j15 = tmp[15] ^ B[bin++],
        u, i;

    var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
        x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
        x15 = j15;

    for (i = 0; i < 8; i += 2) {
      u =  x0 + x12;   x4 ^= u<<7  | u>>>(32-7);
      u =  x4 +  x0;   x8 ^= u<<9  | u>>>(32-9);
      u =  x8 +  x4;  x12 ^= u<<13 | u>>>(32-13);
      u = x12 +  x8;   x0 ^= u<<18 | u>>>(32-18);

      u =  x5 +  x1;   x9 ^= u<<7  | u>>>(32-7);
      u =  x9 +  x5;  x13 ^= u<<9  | u>>>(32-9);
      u = x13 +  x9;   x1 ^= u<<13 | u>>>(32-13);
      u =  x1 + x13;   x5 ^= u<<18 | u>>>(32-18);

      u = x10 +  x6;  x14 ^= u<<7  | u>>>(32-7);
      u = x14 + x10;   x2 ^= u<<9  | u>>>(32-9);
      u =  x2 + x14;   x6 ^= u<<13 | u>>>(32-13);
      u =  x6 +  x2;  x10 ^= u<<18 | u>>>(32-18);

      u = x15 + x11;   x3 ^= u<<7  | u>>>(32-7);
      u =  x3 + x15;   x7 ^= u<<9  | u>>>(32-9);
      u =  x7 +  x3;  x11 ^= u<<13 | u>>>(32-13);
      u = x11 +  x7;  x15 ^= u<<18 | u>>>(32-18);

      u =  x0 +  x3;   x1 ^= u<<7  | u>>>(32-7);
      u =  x1 +  x0;   x2 ^= u<<9  | u>>>(32-9);
      u =  x2 +  x1;   x3 ^= u<<13 | u>>>(32-13);
      u =  x3 +  x2;   x0 ^= u<<18 | u>>>(32-18);

      u =  x5 +  x4;   x6 ^= u<<7  | u>>>(32-7);
      u =  x6 +  x5;   x7 ^= u<<9  | u>>>(32-9);
      u =  x7 +  x6;   x4 ^= u<<13 | u>>>(32-13);
      u =  x4 +  x7;   x5 ^= u<<18 | u>>>(32-18);

      u = x10 +  x9;  x11 ^= u<<7  | u>>>(32-7);
      u = x11 + x10;   x8 ^= u<<9  | u>>>(32-9);
      u =  x8 + x11;   x9 ^= u<<13 | u>>>(32-13);
      u =  x9 +  x8;  x10 ^= u<<18 | u>>>(32-18);

      u = x15 + x14;  x12 ^= u<<7  | u>>>(32-7);
      u = x12 + x15;  x13 ^= u<<9  | u>>>(32-9);
      u = x13 + x12;  x14 ^= u<<13 | u>>>(32-13);
      u = x14 + x13;  x15 ^= u<<18 | u>>>(32-18);
    }

    B[bout++] = tmp[0]  = (x0  + j0)  | 0;
    B[bout++] = tmp[1]  = (x1  + j1)  | 0;
    B[bout++] = tmp[2]  = (x2  + j2)  | 0;
    B[bout++] = tmp[3]  = (x3  + j3)  | 0;
    B[bout++] = tmp[4]  = (x4  + j4)  | 0;
    B[bout++] = tmp[5]  = (x5  + j5)  | 0;
    B[bout++] = tmp[6]  = (x6  + j6)  | 0;
    B[bout++] = tmp[7]  = (x7  + j7)  | 0;
    B[bout++] = tmp[8]  = (x8  + j8)  | 0;
    B[bout++] = tmp[9]  = (x9  + j9)  | 0;
    B[bout++] = tmp[10] = (x10 + j10) | 0;
    B[bout++] = tmp[11] = (x11 + j11) | 0;
    B[bout++] = tmp[12] = (x12 + j12) | 0;
    B[bout++] = tmp[13] = (x13 + j13) | 0;
    B[bout++] = tmp[14] = (x14 + j14) | 0;
    B[bout++] = tmp[15] = (x15 + j15) | 0;
  }

  function blockCopy(dst, di, src, si, len) {
    while (len--) dst[di++] = src[si++];
  }

  function blockXOR(dst, di, src, si, len) {
    while (len--) dst[di++] ^= src[si++];
  }

  function blockMix(tmp, B, bin, bout, r) {
    blockCopy(tmp, 0, B, bin + (2*r-1)*16, 16);
    for (var i = 0; i < 2*r; i += 2) {
      salsaXOR(tmp, B, bin + i*16,      bout + i*8);
      salsaXOR(tmp, B, bin + i*16 + 16, bout + i*8 + r*16);
    }
  }

  function integerify(B, bi, r) {
    return B[bi+(2*r-1)*16];
  }

  function stringToUTF8Bytes(s) {
      var arr = [];
      for (var i = 0; i < s.length; i++) {
          var c = s.charCodeAt(i);
          if (c < 128) {
              arr.push(c);
          } else if (c > 127 && c < 2048) {
              arr.push((c>>6) | 192);
              arr.push((c & 63) | 128);
          } else {
              arr.push((c>>12) | 224);
              arr.push(((c>>6) & 63) | 128);
              arr.push((c & 63) | 128);
          }
      }
      return arr;
  }

  function bytesToHex(p) {
    /** @const */
    var enc = '0123456789abcdef'.split('');

    var len = p.length,
        arr = [],
        i = 0;

    for (; i < len; i++) {
        arr.push(enc[(p[i]>>>4) & 15]);
        arr.push(enc[(p[i]>>>0) & 15]);
    }
    return arr.join('');
  }

  function bytesToBase64(p) {
    /** @const */
    var enc = ('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' +
              '0123456789+/').split('');

    var len = p.length,
        arr = [],
        i = 0,
        a, b, c, t;

    while (i < len) {
      a = i < len ? p[i++] : 0;
      b = i < len ? p[i++] : 0;
      c = i < len ? p[i++] : 0;
      t = (a << 16) + (b << 8) + c;
      arr.push(enc[(t >>> 3 * 6) & 63]);
      arr.push(enc[(t >>> 2 * 6) & 63]);
      arr.push(enc[(t >>> 1 * 6) & 63]);
      arr.push(enc[(t >>> 0 * 6) & 63]);
    }
    if (len % 3 > 0) {
      arr[arr.length-1] = '=';
      if (len % 3 === 1) arr[arr.length-2] = '=';
    }
    return arr.join('');
  }


  // Generate key.

  // Set parallelization parameter to 1.
  var p = 1;

  if (logN < 1 || logN > 31)
    throw new Error('scrypt: logN not be between 1 and 31');

  var MAX_INT = (1<<31)>>>0,
      N = (1<<logN)>>>0,
      XY, V, B, tmp;

  if (r*p >= 1<<30 || r > MAX_INT/128/p || r > MAX_INT/256 || N > MAX_INT/128/r)
    throw new Error('scrypt: parameters are too large');

  // Decode strings.
  if (typeof password === 'string')
    password = stringToUTF8Bytes(password);
  if (typeof salt === 'string')
    salt = stringToUTF8Bytes(salt);

  if (typeof Int32Array !== 'undefined') {
    //XXX We can use Uint32Array, but Int32Array is faster in Safari.
    XY = new Int32Array(64*r);
    V = new Int32Array(32*N*r);
    tmp = new Int32Array(16);
  } else {
    XY = [];
    V = [];
    tmp = new Array(16);
  }
  B = PBKDF2_HMAC_SHA256_OneIter(password, salt, p*128*r);

  var xi = 0, yi = 32 * r;

  function smixStart() {
    for (var i = 0; i < 32*r; i++) {
      var j = i*4;
      XY[xi+i] = ((B[j+3] & 0xff)<<24) | ((B[j+2] & 0xff)<<16) |
                 ((B[j+1] & 0xff)<<8)  | ((B[j+0] & 0xff)<<0);
    }
  }

  function smixStep1(start, end) {
    for (var i = start; i < end; i += 2) {
      blockCopy(V, i*(32*r), XY, xi, 32*r);
      blockMix(tmp, XY, xi, yi, r);

      blockCopy(V, (i+1)*(32*r), XY, yi, 32*r);
      blockMix(tmp, XY, yi, xi, r);
    }
  }

  function smixStep2(start, end) {
    for (var i = start; i < end; i += 2) {
      var j = integerify(XY, xi, r) & (N-1);
      blockXOR(XY, xi, V, j*(32*r), 32*r);
      blockMix(tmp, XY, xi, yi, r);

      j = integerify(XY, yi, r) & (N-1);
      blockXOR(XY, yi, V, j*(32*r), 32*r);
      blockMix(tmp, XY, yi, xi, r);
    }
  }

  function smixFinish() {
    for (var i = 0; i < 32*r; i++) {
      var j = XY[xi+i];
      B[i*4+0] = (j>>>0)  & 0xff;
      B[i*4+1] = (j>>>8)  & 0xff;
      B[i*4+2] = (j>>>16) & 0xff;
      B[i*4+3] = (j>>>24) & 0xff;
    }
  }

  var nextTick = (typeof setImmediate !== 'undefined') ? setImmediate : setTimeout;

  function interruptedFor(start, end, step, fn, donefn) {
    (function performStep() {
      nextTick(function() {
        fn(start, start + step < end ? start + step : end);
        start += step;
        if (start < end)
          performStep();
        else
          donefn();
        });
    })();
  }

  function getResult(enc) {
      var result = PBKDF2_HMAC_SHA256_OneIter(password, B, dkLen);
      if (enc === 'base64')
        return bytesToBase64(result);
      else if (enc === 'hex')
        return bytesToHex(result);
      else
        return result;
  }

  if (typeof interruptStep === 'function') {
    // Called as: scrypt(...,      callback, [encoding])
    //  shifting: scrypt(..., interruptStep,  callback, [encoding])
    encoding = callback;
    callback = interruptStep;
    interruptStep = 1000;
  }

  if (interruptStep <= 0) {
    //
    // Blocking async variant, calls callback.
    //
    smixStart();
    smixStep1(0, N);
    smixStep2(0, N);
    smixFinish();
    callback(getResult(encoding));

  } else {
    //
    // Async variant with interruptions, calls callback.
    //
    smixStart();
    interruptedFor(0, N, interruptStep*2, smixStep1, function() {
      interruptedFor(0, N, interruptStep*2, smixStep2, function () {
        smixFinish();
        callback(getResult(encoding));
      });
    });
  }
}

if (typeof module !== 'undefined') module.exports = scrypt;

},{}],23:[function(require,module,exports){
(function (Buffer){
(function(nacl) {
'use strict';

// Ported in 2014 by Dmitry Chestnykh and Devi Mandiri.
// Public domain.
//
// Implementation derived from TweetNaCl version 20140427.
// See for details: http://tweetnacl.cr.yp.to/

var gf = function(init) {
  var i, r = new Float64Array(16);
  if (init) for (i = 0; i < init.length; i++) r[i] = init[i];
  return r;
};

//  Pluggable, initialized in high-level API below.
var randombytes = function(/* x, n */) { throw new Error('no PRNG'); };

var _0 = new Uint8Array(16);
var _9 = new Uint8Array(32); _9[0] = 9;

var gf0 = gf(),
    gf1 = gf([1]),
    _121665 = gf([0xdb41, 1]),
    D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]),
    D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]),
    X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]),
    Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]),
    I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);

function ts64(x, i, h, l) {
  x[i]   = (h >> 24) & 0xff;
  x[i+1] = (h >> 16) & 0xff;
  x[i+2] = (h >>  8) & 0xff;
  x[i+3] = h & 0xff;
  x[i+4] = (l >> 24)  & 0xff;
  x[i+5] = (l >> 16)  & 0xff;
  x[i+6] = (l >>  8)  & 0xff;
  x[i+7] = l & 0xff;
}

function vn(x, xi, y, yi, n) {
  var i,d = 0;
  for (i = 0; i < n; i++) d |= x[xi+i]^y[yi+i];
  return (1 & ((d - 1) >>> 8)) - 1;
}

function crypto_verify_16(x, xi, y, yi) {
  return vn(x,xi,y,yi,16);
}

function crypto_verify_32(x, xi, y, yi) {
  return vn(x,xi,y,yi,32);
}

function core_salsa20(o, p, k, c) {
  var j0  = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,
      j1  = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,
      j2  = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,
      j3  = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,
      j4  = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,
      j5  = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,
      j6  = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,
      j7  = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,
      j8  = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,
      j9  = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,
      j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,
      j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,
      j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,
      j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,
      j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,
      j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;

  var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
      x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
      x15 = j15, u;

  for (var i = 0; i < 20; i += 2) {
    u = x0 + x12 | 0;
    x4 ^= u<<7 | u>>>(32-7);
    u = x4 + x0 | 0;
    x8 ^= u<<9 | u>>>(32-9);
    u = x8 + x4 | 0;
    x12 ^= u<<13 | u>>>(32-13);
    u = x12 + x8 | 0;
    x0 ^= u<<18 | u>>>(32-18);

    u = x5 + x1 | 0;
    x9 ^= u<<7 | u>>>(32-7);
    u = x9 + x5 | 0;
    x13 ^= u<<9 | u>>>(32-9);
    u = x13 + x9 | 0;
    x1 ^= u<<13 | u>>>(32-13);
    u = x1 + x13 | 0;
    x5 ^= u<<18 | u>>>(32-18);

    u = x10 + x6 | 0;
    x14 ^= u<<7 | u>>>(32-7);
    u = x14 + x10 | 0;
    x2 ^= u<<9 | u>>>(32-9);
    u = x2 + x14 | 0;
    x6 ^= u<<13 | u>>>(32-13);
    u = x6 + x2 | 0;
    x10 ^= u<<18 | u>>>(32-18);

    u = x15 + x11 | 0;
    x3 ^= u<<7 | u>>>(32-7);
    u = x3 + x15 | 0;
    x7 ^= u<<9 | u>>>(32-9);
    u = x7 + x3 | 0;
    x11 ^= u<<13 | u>>>(32-13);
    u = x11 + x7 | 0;
    x15 ^= u<<18 | u>>>(32-18);

    u = x0 + x3 | 0;
    x1 ^= u<<7 | u>>>(32-7);
    u = x1 + x0 | 0;
    x2 ^= u<<9 | u>>>(32-9);
    u = x2 + x1 | 0;
    x3 ^= u<<13 | u>>>(32-13);
    u = x3 + x2 | 0;
    x0 ^= u<<18 | u>>>(32-18);

    u = x5 + x4 | 0;
    x6 ^= u<<7 | u>>>(32-7);
    u = x6 + x5 | 0;
    x7 ^= u<<9 | u>>>(32-9);
    u = x7 + x6 | 0;
    x4 ^= u<<13 | u>>>(32-13);
    u = x4 + x7 | 0;
    x5 ^= u<<18 | u>>>(32-18);

    u = x10 + x9 | 0;
    x11 ^= u<<7 | u>>>(32-7);
    u = x11 + x10 | 0;
    x8 ^= u<<9 | u>>>(32-9);
    u = x8 + x11 | 0;
    x9 ^= u<<13 | u>>>(32-13);
    u = x9 + x8 | 0;
    x10 ^= u<<18 | u>>>(32-18);

    u = x15 + x14 | 0;
    x12 ^= u<<7 | u>>>(32-7);
    u = x12 + x15 | 0;
    x13 ^= u<<9 | u>>>(32-9);
    u = x13 + x12 | 0;
    x14 ^= u<<13 | u>>>(32-13);
    u = x14 + x13 | 0;
    x15 ^= u<<18 | u>>>(32-18);
  }
   x0 =  x0 +  j0 | 0;
   x1 =  x1 +  j1 | 0;
   x2 =  x2 +  j2 | 0;
   x3 =  x3 +  j3 | 0;
   x4 =  x4 +  j4 | 0;
   x5 =  x5 +  j5 | 0;
   x6 =  x6 +  j6 | 0;
   x7 =  x7 +  j7 | 0;
   x8 =  x8 +  j8 | 0;
   x9 =  x9 +  j9 | 0;
  x10 = x10 + j10 | 0;
  x11 = x11 + j11 | 0;
  x12 = x12 + j12 | 0;
  x13 = x13 + j13 | 0;
  x14 = x14 + j14 | 0;
  x15 = x15 + j15 | 0;

  o[ 0] = x0 >>>  0 & 0xff;
  o[ 1] = x0 >>>  8 & 0xff;
  o[ 2] = x0 >>> 16 & 0xff;
  o[ 3] = x0 >>> 24 & 0xff;

  o[ 4] = x1 >>>  0 & 0xff;
  o[ 5] = x1 >>>  8 & 0xff;
  o[ 6] = x1 >>> 16 & 0xff;
  o[ 7] = x1 >>> 24 & 0xff;

  o[ 8] = x2 >>>  0 & 0xff;
  o[ 9] = x2 >>>  8 & 0xff;
  o[10] = x2 >>> 16 & 0xff;
  o[11] = x2 >>> 24 & 0xff;

  o[12] = x3 >>>  0 & 0xff;
  o[13] = x3 >>>  8 & 0xff;
  o[14] = x3 >>> 16 & 0xff;
  o[15] = x3 >>> 24 & 0xff;

  o[16] = x4 >>>  0 & 0xff;
  o[17] = x4 >>>  8 & 0xff;
  o[18] = x4 >>> 16 & 0xff;
  o[19] = x4 >>> 24 & 0xff;

  o[20] = x5 >>>  0 & 0xff;
  o[21] = x5 >>>  8 & 0xff;
  o[22] = x5 >>> 16 & 0xff;
  o[23] = x5 >>> 24 & 0xff;

  o[24] = x6 >>>  0 & 0xff;
  o[25] = x6 >>>  8 & 0xff;
  o[26] = x6 >>> 16 & 0xff;
  o[27] = x6 >>> 24 & 0xff;

  o[28] = x7 >>>  0 & 0xff;
  o[29] = x7 >>>  8 & 0xff;
  o[30] = x7 >>> 16 & 0xff;
  o[31] = x7 >>> 24 & 0xff;

  o[32] = x8 >>>  0 & 0xff;
  o[33] = x8 >>>  8 & 0xff;
  o[34] = x8 >>> 16 & 0xff;
  o[35] = x8 >>> 24 & 0xff;

  o[36] = x9 >>>  0 & 0xff;
  o[37] = x9 >>>  8 & 0xff;
  o[38] = x9 >>> 16 & 0xff;
  o[39] = x9 >>> 24 & 0xff;

  o[40] = x10 >>>  0 & 0xff;
  o[41] = x10 >>>  8 & 0xff;
  o[42] = x10 >>> 16 & 0xff;
  o[43] = x10 >>> 24 & 0xff;

  o[44] = x11 >>>  0 & 0xff;
  o[45] = x11 >>>  8 & 0xff;
  o[46] = x11 >>> 16 & 0xff;
  o[47] = x11 >>> 24 & 0xff;

  o[48] = x12 >>>  0 & 0xff;
  o[49] = x12 >>>  8 & 0xff;
  o[50] = x12 >>> 16 & 0xff;
  o[51] = x12 >>> 24 & 0xff;

  o[52] = x13 >>>  0 & 0xff;
  o[53] = x13 >>>  8 & 0xff;
  o[54] = x13 >>> 16 & 0xff;
  o[55] = x13 >>> 24 & 0xff;

  o[56] = x14 >>>  0 & 0xff;
  o[57] = x14 >>>  8 & 0xff;
  o[58] = x14 >>> 16 & 0xff;
  o[59] = x14 >>> 24 & 0xff;

  o[60] = x15 >>>  0 & 0xff;
  o[61] = x15 >>>  8 & 0xff;
  o[62] = x15 >>> 16 & 0xff;
  o[63] = x15 >>> 24 & 0xff;
}

function core_hsalsa20(o,p,k,c) {
  var j0  = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,
      j1  = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,
      j2  = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,
      j3  = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,
      j4  = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,
      j5  = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,
      j6  = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,
      j7  = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,
      j8  = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,
      j9  = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,
      j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,
      j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,
      j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,
      j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,
      j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,
      j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;

  var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
      x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
      x15 = j15, u;

  for (var i = 0; i < 20; i += 2) {
    u = x0 + x12 | 0;
    x4 ^= u<<7 | u>>>(32-7);
    u = x4 + x0 | 0;
    x8 ^= u<<9 | u>>>(32-9);
    u = x8 + x4 | 0;
    x12 ^= u<<13 | u>>>(32-13);
    u = x12 + x8 | 0;
    x0 ^= u<<18 | u>>>(32-18);

    u = x5 + x1 | 0;
    x9 ^= u<<7 | u>>>(32-7);
    u = x9 + x5 | 0;
    x13 ^= u<<9 | u>>>(32-9);
    u = x13 + x9 | 0;
    x1 ^= u<<13 | u>>>(32-13);
    u = x1 + x13 | 0;
    x5 ^= u<<18 | u>>>(32-18);

    u = x10 + x6 | 0;
    x14 ^= u<<7 | u>>>(32-7);
    u = x14 + x10 | 0;
    x2 ^= u<<9 | u>>>(32-9);
    u = x2 + x14 | 0;
    x6 ^= u<<13 | u>>>(32-13);
    u = x6 + x2 | 0;
    x10 ^= u<<18 | u>>>(32-18);

    u = x15 + x11 | 0;
    x3 ^= u<<7 | u>>>(32-7);
    u = x3 + x15 | 0;
    x7 ^= u<<9 | u>>>(32-9);
    u = x7 + x3 | 0;
    x11 ^= u<<13 | u>>>(32-13);
    u = x11 + x7 | 0;
    x15 ^= u<<18 | u>>>(32-18);

    u = x0 + x3 | 0;
    x1 ^= u<<7 | u>>>(32-7);
    u = x1 + x0 | 0;
    x2 ^= u<<9 | u>>>(32-9);
    u = x2 + x1 | 0;
    x3 ^= u<<13 | u>>>(32-13);
    u = x3 + x2 | 0;
    x0 ^= u<<18 | u>>>(32-18);

    u = x5 + x4 | 0;
    x6 ^= u<<7 | u>>>(32-7);
    u = x6 + x5 | 0;
    x7 ^= u<<9 | u>>>(32-9);
    u = x7 + x6 | 0;
    x4 ^= u<<13 | u>>>(32-13);
    u = x4 + x7 | 0;
    x5 ^= u<<18 | u>>>(32-18);

    u = x10 + x9 | 0;
    x11 ^= u<<7 | u>>>(32-7);
    u = x11 + x10 | 0;
    x8 ^= u<<9 | u>>>(32-9);
    u = x8 + x11 | 0;
    x9 ^= u<<13 | u>>>(32-13);
    u = x9 + x8 | 0;
    x10 ^= u<<18 | u>>>(32-18);

    u = x15 + x14 | 0;
    x12 ^= u<<7 | u>>>(32-7);
    u = x12 + x15 | 0;
    x13 ^= u<<9 | u>>>(32-9);
    u = x13 + x12 | 0;
    x14 ^= u<<13 | u>>>(32-13);
    u = x14 + x13 | 0;
    x15 ^= u<<18 | u>>>(32-18);
  }

  o[ 0] = x0 >>>  0 & 0xff;
  o[ 1] = x0 >>>  8 & 0xff;
  o[ 2] = x0 >>> 16 & 0xff;
  o[ 3] = x0 >>> 24 & 0xff;

  o[ 4] = x5 >>>  0 & 0xff;
  o[ 5] = x5 >>>  8 & 0xff;
  o[ 6] = x5 >>> 16 & 0xff;
  o[ 7] = x5 >>> 24 & 0xff;

  o[ 8] = x10 >>>  0 & 0xff;
  o[ 9] = x10 >>>  8 & 0xff;
  o[10] = x10 >>> 16 & 0xff;
  o[11] = x10 >>> 24 & 0xff;

  o[12] = x15 >>>  0 & 0xff;
  o[13] = x15 >>>  8 & 0xff;
  o[14] = x15 >>> 16 & 0xff;
  o[15] = x15 >>> 24 & 0xff;

  o[16] = x6 >>>  0 & 0xff;
  o[17] = x6 >>>  8 & 0xff;
  o[18] = x6 >>> 16 & 0xff;
  o[19] = x6 >>> 24 & 0xff;

  o[20] = x7 >>>  0 & 0xff;
  o[21] = x7 >>>  8 & 0xff;
  o[22] = x7 >>> 16 & 0xff;
  o[23] = x7 >>> 24 & 0xff;

  o[24] = x8 >>>  0 & 0xff;
  o[25] = x8 >>>  8 & 0xff;
  o[26] = x8 >>> 16 & 0xff;
  o[27] = x8 >>> 24 & 0xff;

  o[28] = x9 >>>  0 & 0xff;
  o[29] = x9 >>>  8 & 0xff;
  o[30] = x9 >>> 16 & 0xff;
  o[31] = x9 >>> 24 & 0xff;
}

function crypto_core_salsa20(out,inp,k,c) {
  core_salsa20(out,inp,k,c);
}

function crypto_core_hsalsa20(out,inp,k,c) {
  core_hsalsa20(out,inp,k,c);
}

var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
            // "expand 32-byte k"

function crypto_stream_salsa20_xor(c,cpos,m,mpos,b,n,k) {
  var z = new Uint8Array(16), x = new Uint8Array(64);
  var u, i;
  for (i = 0; i < 16; i++) z[i] = 0;
  for (i = 0; i < 8; i++) z[i] = n[i];
  while (b >= 64) {
    crypto_core_salsa20(x,z,k,sigma);
    for (i = 0; i < 64; i++) c[cpos+i] = m[mpos+i] ^ x[i];
    u = 1;
    for (i = 8; i < 16; i++) {
      u = u + (z[i] & 0xff) | 0;
      z[i] = u & 0xff;
      u >>>= 8;
    }
    b -= 64;
    cpos += 64;
    mpos += 64;
  }
  if (b > 0) {
    crypto_core_salsa20(x,z,k,sigma);
    for (i = 0; i < b; i++) c[cpos+i] = m[mpos+i] ^ x[i];
  }
  return 0;
}

function crypto_stream_salsa20(c,cpos,b,n,k) {
  var z = new Uint8Array(16), x = new Uint8Array(64);
  var u, i;
  for (i = 0; i < 16; i++) z[i] = 0;
  for (i = 0; i < 8; i++) z[i] = n[i];
  while (b >= 64) {
    crypto_core_salsa20(x,z,k,sigma);
    for (i = 0; i < 64; i++) c[cpos+i] = x[i];
    u = 1;
    for (i = 8; i < 16; i++) {
      u = u + (z[i] & 0xff) | 0;
      z[i] = u & 0xff;
      u >>>= 8;
    }
    b -= 64;
    cpos += 64;
  }
  if (b > 0) {
    crypto_core_salsa20(x,z,k,sigma);
    for (i = 0; i < b; i++) c[cpos+i] = x[i];
  }
  return 0;
}

function crypto_stream(c,cpos,d,n,k) {
  var s = new Uint8Array(32);
  crypto_core_hsalsa20(s,n,k,sigma);
  var sn = new Uint8Array(8);
  for (var i = 0; i < 8; i++) sn[i] = n[i+16];
  return crypto_stream_salsa20(c,cpos,d,sn,s);
}

function crypto_stream_xor(c,cpos,m,mpos,d,n,k) {
  var s = new Uint8Array(32);
  crypto_core_hsalsa20(s,n,k,sigma);
  var sn = new Uint8Array(8);
  for (var i = 0; i < 8; i++) sn[i] = n[i+16];
  return crypto_stream_salsa20_xor(c,cpos,m,mpos,d,sn,s);
}

/*
* Port of Andrew Moon's Poly1305-donna-16. Public domain.
* https://github.com/floodyberry/poly1305-donna
*/

var poly1305 = function(key) {
  this.buffer = new Uint8Array(16);
  this.r = new Uint16Array(10);
  this.h = new Uint16Array(10);
  this.pad = new Uint16Array(8);
  this.leftover = 0;
  this.fin = 0;

  var t0, t1, t2, t3, t4, t5, t6, t7;

  t0 = key[ 0] & 0xff | (key[ 1] & 0xff) << 8; this.r[0] = ( t0                     ) & 0x1fff;
  t1 = key[ 2] & 0xff | (key[ 3] & 0xff) << 8; this.r[1] = ((t0 >>> 13) | (t1 <<  3)) & 0x1fff;
  t2 = key[ 4] & 0xff | (key[ 5] & 0xff) << 8; this.r[2] = ((t1 >>> 10) | (t2 <<  6)) & 0x1f03;
  t3 = key[ 6] & 0xff | (key[ 7] & 0xff) << 8; this.r[3] = ((t2 >>>  7) | (t3 <<  9)) & 0x1fff;
  t4 = key[ 8] & 0xff | (key[ 9] & 0xff) << 8; this.r[4] = ((t3 >>>  4) | (t4 << 12)) & 0x00ff;
  this.r[5] = ((t4 >>>  1)) & 0x1ffe;
  t5 = key[10] & 0xff | (key[11] & 0xff) << 8; this.r[6] = ((t4 >>> 14) | (t5 <<  2)) & 0x1fff;
  t6 = key[12] & 0xff | (key[13] & 0xff) << 8; this.r[7] = ((t5 >>> 11) | (t6 <<  5)) & 0x1f81;
  t7 = key[14] & 0xff | (key[15] & 0xff) << 8; this.r[8] = ((t6 >>>  8) | (t7 <<  8)) & 0x1fff;
  this.r[9] = ((t7 >>>  5)) & 0x007f;

  this.pad[0] = key[16] & 0xff | (key[17] & 0xff) << 8;
  this.pad[1] = key[18] & 0xff | (key[19] & 0xff) << 8;
  this.pad[2] = key[20] & 0xff | (key[21] & 0xff) << 8;
  this.pad[3] = key[22] & 0xff | (key[23] & 0xff) << 8;
  this.pad[4] = key[24] & 0xff | (key[25] & 0xff) << 8;
  this.pad[5] = key[26] & 0xff | (key[27] & 0xff) << 8;
  this.pad[6] = key[28] & 0xff | (key[29] & 0xff) << 8;
  this.pad[7] = key[30] & 0xff | (key[31] & 0xff) << 8;
};

poly1305.prototype.blocks = function(m, mpos, bytes) {
  var hibit = this.fin ? 0 : (1 << 11);
  var t0, t1, t2, t3, t4, t5, t6, t7, c;
  var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9;

  var h0 = this.h[0],
      h1 = this.h[1],
      h2 = this.h[2],
      h3 = this.h[3],
      h4 = this.h[4],
      h5 = this.h[5],
      h6 = this.h[6],
      h7 = this.h[7],
      h8 = this.h[8],
      h9 = this.h[9];

  var r0 = this.r[0],
      r1 = this.r[1],
      r2 = this.r[2],
      r3 = this.r[3],
      r4 = this.r[4],
      r5 = this.r[5],
      r6 = this.r[6],
      r7 = this.r[7],
      r8 = this.r[8],
      r9 = this.r[9];

  while (bytes >= 16) {
    t0 = m[mpos+ 0] & 0xff | (m[mpos+ 1] & 0xff) << 8; h0 += ( t0                     ) & 0x1fff;
    t1 = m[mpos+ 2] & 0xff | (m[mpos+ 3] & 0xff) << 8; h1 += ((t0 >>> 13) | (t1 <<  3)) & 0x1fff;
    t2 = m[mpos+ 4] & 0xff | (m[mpos+ 5] & 0xff) << 8; h2 += ((t1 >>> 10) | (t2 <<  6)) & 0x1fff;
    t3 = m[mpos+ 6] & 0xff | (m[mpos+ 7] & 0xff) << 8; h3 += ((t2 >>>  7) | (t3 <<  9)) & 0x1fff;
    t4 = m[mpos+ 8] & 0xff | (m[mpos+ 9] & 0xff) << 8; h4 += ((t3 >>>  4) | (t4 << 12)) & 0x1fff;
    h5 += ((t4 >>>  1)) & 0x1fff;
    t5 = m[mpos+10] & 0xff | (m[mpos+11] & 0xff) << 8; h6 += ((t4 >>> 14) | (t5 <<  2)) & 0x1fff;
    t6 = m[mpos+12] & 0xff | (m[mpos+13] & 0xff) << 8; h7 += ((t5 >>> 11) | (t6 <<  5)) & 0x1fff;
    t7 = m[mpos+14] & 0xff | (m[mpos+15] & 0xff) << 8; h8 += ((t6 >>>  8) | (t7 <<  8)) & 0x1fff;
    h9 += ((t7 >>> 5)) | hibit;

    c = 0;

    d0 = c;
    d0 += h0 * r0;
    d0 += h1 * (5 * r9);
    d0 += h2 * (5 * r8);
    d0 += h3 * (5 * r7);
    d0 += h4 * (5 * r6);
    c = (d0 >>> 13); d0 &= 0x1fff;
    d0 += h5 * (5 * r5);
    d0 += h6 * (5 * r4);
    d0 += h7 * (5 * r3);
    d0 += h8 * (5 * r2);
    d0 += h9 * (5 * r1);
    c += (d0 >>> 13); d0 &= 0x1fff;

    d1 = c;
    d1 += h0 * r1;
    d1 += h1 * r0;
    d1 += h2 * (5 * r9);
    d1 += h3 * (5 * r8);
    d1 += h4 * (5 * r7);
    c = (d1 >>> 13); d1 &= 0x1fff;
    d1 += h5 * (5 * r6);
    d1 += h6 * (5 * r5);
    d1 += h7 * (5 * r4);
    d1 += h8 * (5 * r3);
    d1 += h9 * (5 * r2);
    c += (d1 >>> 13); d1 &= 0x1fff;

    d2 = c;
    d2 += h0 * r2;
    d2 += h1 * r1;
    d2 += h2 * r0;
    d2 += h3 * (5 * r9);
    d2 += h4 * (5 * r8);
    c = (d2 >>> 13); d2 &= 0x1fff;
    d2 += h5 * (5 * r7);
    d2 += h6 * (5 * r6);
    d2 += h7 * (5 * r5);
    d2 += h8 * (5 * r4);
    d2 += h9 * (5 * r3);
    c += (d2 >>> 13); d2 &= 0x1fff;

    d3 = c;
    d3 += h0 * r3;
    d3 += h1 * r2;
    d3 += h2 * r1;
    d3 += h3 * r0;
    d3 += h4 * (5 * r9);
    c = (d3 >>> 13); d3 &= 0x1fff;
    d3 += h5 * (5 * r8);
    d3 += h6 * (5 * r7);
    d3 += h7 * (5 * r6);
    d3 += h8 * (5 * r5);
    d3 += h9 * (5 * r4);
    c += (d3 >>> 13); d3 &= 0x1fff;

    d4 = c;
    d4 += h0 * r4;
    d4 += h1 * r3;
    d4 += h2 * r2;
    d4 += h3 * r1;
    d4 += h4 * r0;
    c = (d4 >>> 13); d4 &= 0x1fff;
    d4 += h5 * (5 * r9);
    d4 += h6 * (5 * r8);
    d4 += h7 * (5 * r7);
    d4 += h8 * (5 * r6);
    d4 += h9 * (5 * r5);
    c += (d4 >>> 13); d4 &= 0x1fff;

    d5 = c;
    d5 += h0 * r5;
    d5 += h1 * r4;
    d5 += h2 * r3;
    d5 += h3 * r2;
    d5 += h4 * r1;
    c = (d5 >>> 13); d5 &= 0x1fff;
    d5 += h5 * r0;
    d5 += h6 * (5 * r9);
    d5 += h7 * (5 * r8);
    d5 += h8 * (5 * r7);
    d5 += h9 * (5 * r6);
    c += (d5 >>> 13); d5 &= 0x1fff;

    d6 = c;
    d6 += h0 * r6;
    d6 += h1 * r5;
    d6 += h2 * r4;
    d6 += h3 * r3;
    d6 += h4 * r2;
    c = (d6 >>> 13); d6 &= 0x1fff;
    d6 += h5 * r1;
    d6 += h6 * r0;
    d6 += h7 * (5 * r9);
    d6 += h8 * (5 * r8);
    d6 += h9 * (5 * r7);
    c += (d6 >>> 13); d6 &= 0x1fff;

    d7 = c;
    d7 += h0 * r7;
    d7 += h1 * r6;
    d7 += h2 * r5;
    d7 += h3 * r4;
    d7 += h4 * r3;
    c = (d7 >>> 13); d7 &= 0x1fff;
    d7 += h5 * r2;
    d7 += h6 * r1;
    d7 += h7 * r0;
    d7 += h8 * (5 * r9);
    d7 += h9 * (5 * r8);
    c += (d7 >>> 13); d7 &= 0x1fff;

    d8 = c;
    d8 += h0 * r8;
    d8 += h1 * r7;
    d8 += h2 * r6;
    d8 += h3 * r5;
    d8 += h4 * r4;
    c = (d8 >>> 13); d8 &= 0x1fff;
    d8 += h5 * r3;
    d8 += h6 * r2;
    d8 += h7 * r1;
    d8 += h8 * r0;
    d8 += h9 * (5 * r9);
    c += (d8 >>> 13); d8 &= 0x1fff;

    d9 = c;
    d9 += h0 * r9;
    d9 += h1 * r8;
    d9 += h2 * r7;
    d9 += h3 * r6;
    d9 += h4 * r5;
    c = (d9 >>> 13); d9 &= 0x1fff;
    d9 += h5 * r4;
    d9 += h6 * r3;
    d9 += h7 * r2;
    d9 += h8 * r1;
    d9 += h9 * r0;
    c += (d9 >>> 13); d9 &= 0x1fff;

    c = (((c << 2) + c)) | 0;
    c = (c + d0) | 0;
    d0 = c & 0x1fff;
    c = (c >>> 13);
    d1 += c;

    h0 = d0;
    h1 = d1;
    h2 = d2;
    h3 = d3;
    h4 = d4;
    h5 = d5;
    h6 = d6;
    h7 = d7;
    h8 = d8;
    h9 = d9;

    mpos += 16;
    bytes -= 16;
  }
  this.h[0] = h0;
  this.h[1] = h1;
  this.h[2] = h2;
  this.h[3] = h3;
  this.h[4] = h4;
  this.h[5] = h5;
  this.h[6] = h6;
  this.h[7] = h7;
  this.h[8] = h8;
  this.h[9] = h9;
};

poly1305.prototype.finish = function(mac, macpos) {
  var g = new Uint16Array(10);
  var c, mask, f, i;

  if (this.leftover) {
    i = this.leftover;
    this.buffer[i++] = 1;
    for (; i < 16; i++) this.buffer[i] = 0;
    this.fin = 1;
    this.blocks(this.buffer, 0, 16);
  }

  c = this.h[1] >>> 13;
  this.h[1] &= 0x1fff;
  for (i = 2; i < 10; i++) {
    this.h[i] += c;
    c = this.h[i] >>> 13;
    this.h[i] &= 0x1fff;
  }
  this.h[0] += (c * 5);
  c = this.h[0] >>> 13;
  this.h[0] &= 0x1fff;
  this.h[1] += c;
  c = this.h[1] >>> 13;
  this.h[1] &= 0x1fff;
  this.h[2] += c;

  g[0] = this.h[0] + 5;
  c = g[0] >>> 13;
  g[0] &= 0x1fff;
  for (i = 1; i < 10; i++) {
    g[i] = this.h[i] + c;
    c = g[i] >>> 13;
    g[i] &= 0x1fff;
  }
  g[9] -= (1 << 13);

  mask = (g[9] >>> ((2 * 8) - 1)) - 1;
  for (i = 0; i < 10; i++) g[i] &= mask;
  mask = ~mask;
  for (i = 0; i < 10; i++) this.h[i] = (this.h[i] & mask) | g[i];

  this.h[0] = ((this.h[0]       ) | (this.h[1] << 13)                    ) & 0xffff;
  this.h[1] = ((this.h[1] >>>  3) | (this.h[2] << 10)                    ) & 0xffff;
  this.h[2] = ((this.h[2] >>>  6) | (this.h[3] <<  7)                    ) & 0xffff;
  this.h[3] = ((this.h[3] >>>  9) | (this.h[4] <<  4)                    ) & 0xffff;
  this.h[4] = ((this.h[4] >>> 12) | (this.h[5] <<  1) | (this.h[6] << 14)) & 0xffff;
  this.h[5] = ((this.h[6] >>>  2) | (this.h[7] << 11)                    ) & 0xffff;
  this.h[6] = ((this.h[7] >>>  5) | (this.h[8] <<  8)                    ) & 0xffff;
  this.h[7] = ((this.h[8] >>>  8) | (this.h[9] <<  5)                    ) & 0xffff;

  f = this.h[0] + this.pad[0];
  this.h[0] = f & 0xffff;
  for (i = 1; i < 8; i++) {
    f = (((this.h[i] + this.pad[i]) | 0) + (f >>> 16)) | 0;
    this.h[i] = f & 0xffff;
  }

  mac[macpos+ 0] = (this.h[0] >>> 0) & 0xff;
  mac[macpos+ 1] = (this.h[0] >>> 8) & 0xff;
  mac[macpos+ 2] = (this.h[1] >>> 0) & 0xff;
  mac[macpos+ 3] = (this.h[1] >>> 8) & 0xff;
  mac[macpos+ 4] = (this.h[2] >>> 0) & 0xff;
  mac[macpos+ 5] = (this.h[2] >>> 8) & 0xff;
  mac[macpos+ 6] = (this.h[3] >>> 0) & 0xff;
  mac[macpos+ 7] = (this.h[3] >>> 8) & 0xff;
  mac[macpos+ 8] = (this.h[4] >>> 0) & 0xff;
  mac[macpos+ 9] = (this.h[4] >>> 8) & 0xff;
  mac[macpos+10] = (this.h[5] >>> 0) & 0xff;
  mac[macpos+11] = (this.h[5] >>> 8) & 0xff;
  mac[macpos+12] = (this.h[6] >>> 0) & 0xff;
  mac[macpos+13] = (this.h[6] >>> 8) & 0xff;
  mac[macpos+14] = (this.h[7] >>> 0) & 0xff;
  mac[macpos+15] = (this.h[7] >>> 8) & 0xff;
};

poly1305.prototype.update = function(m, mpos, bytes) {
  var i, want;

  if (this.leftover) {
    want = (16 - this.leftover);
    if (want > bytes)
      want = bytes;
    for (i = 0; i < want; i++)
      this.buffer[this.leftover + i] = m[mpos+i];
    bytes -= want;
    mpos += want;
    this.leftover += want;
    if (this.leftover < 16)
      return;
    this.blocks(this.buffer, 0, 16);
    this.leftover = 0;
  }

  if (bytes >= 16) {
    want = bytes - (bytes % 16);
    this.blocks(m, mpos, want);
    mpos += want;
    bytes -= want;
  }

  if (bytes) {
    for (i = 0; i < bytes; i++)
      this.buffer[this.leftover + i] = m[mpos+i];
    this.leftover += bytes;
  }
};

function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
  var s = new poly1305(k);
  s.update(m, mpos, n);
  s.finish(out, outpos);
  return 0;
}

function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
  var x = new Uint8Array(16);
  crypto_onetimeauth(x,0,m,mpos,n,k);
  return crypto_verify_16(h,hpos,x,0);
}

function crypto_secretbox(c,m,d,n,k) {
  var i;
  if (d < 32) return -1;
  crypto_stream_xor(c,0,m,0,d,n,k);
  crypto_onetimeauth(c, 16, c, 32, d - 32, c);
  for (i = 0; i < 16; i++) c[i] = 0;
  return 0;
}

function crypto_secretbox_open(m,c,d,n,k) {
  var i;
  var x = new Uint8Array(32);
  if (d < 32) return -1;
  crypto_stream(x,0,32,n,k);
  if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1;
  crypto_stream_xor(m,0,c,0,d,n,k);
  for (i = 0; i < 32; i++) m[i] = 0;
  return 0;
}

function set25519(r, a) {
  var i;
  for (i = 0; i < 16; i++) r[i] = a[i]|0;
}

function car25519(o) {
  var i, v, c = 1;
  for (i = 0; i < 16; i++) {
    v = o[i] + c + 65535;
    c = Math.floor(v / 65536);
    o[i] = v - c * 65536;
  }
  o[0] += c-1 + 37 * (c-1);
}

function sel25519(p, q, b) {
  var t, c = ~(b-1);
  for (var i = 0; i < 16; i++) {
    t = c & (p[i] ^ q[i]);
    p[i] ^= t;
    q[i] ^= t;
  }
}

function pack25519(o, n) {
  var i, j, b;
  var m = gf(), t = gf();
  for (i = 0; i < 16; i++) t[i] = n[i];
  car25519(t);
  car25519(t);
  car25519(t);
  for (j = 0; j < 2; j++) {
    m[0] = t[0] - 0xffed;
    for (i = 1; i < 15; i++) {
      m[i] = t[i] - 0xffff - ((m[i-1]>>16) & 1);
      m[i-1] &= 0xffff;
    }
    m[15] = t[15] - 0x7fff - ((m[14]>>16) & 1);
    b = (m[15]>>16) & 1;
    m[14] &= 0xffff;
    sel25519(t, m, 1-b);
  }
  for (i = 0; i < 16; i++) {
    o[2*i] = t[i] & 0xff;
    o[2*i+1] = t[i]>>8;
  }
}

function neq25519(a, b) {
  var c = new Uint8Array(32), d = new Uint8Array(32);
  pack25519(c, a);
  pack25519(d, b);
  return crypto_verify_32(c, 0, d, 0);
}

function par25519(a) {
  var d = new Uint8Array(32);
  pack25519(d, a);
  return d[0] & 1;
}

function unpack25519(o, n) {
  var i;
  for (i = 0; i < 16; i++) o[i] = n[2*i] + (n[2*i+1] << 8);
  o[15] &= 0x7fff;
}

function A(o, a, b) {
  for (var i = 0; i < 16; i++) o[i] = a[i] + b[i];
}

function Z(o, a, b) {
  for (var i = 0; i < 16; i++) o[i] = a[i] - b[i];
}

function M(o, a, b) {
  var v, c,
     t0 = 0,  t1 = 0,  t2 = 0,  t3 = 0,  t4 = 0,  t5 = 0,  t6 = 0,  t7 = 0,
     t8 = 0,  t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0,
    t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0,
    t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0,
    b0 = b[0],
    b1 = b[1],
    b2 = b[2],
    b3 = b[3],
    b4 = b[4],
    b5 = b[5],
    b6 = b[6],
    b7 = b[7],
    b8 = b[8],
    b9 = b[9],
    b10 = b[10],
    b11 = b[11],
    b12 = b[12],
    b13 = b[13],
    b14 = b[14],
    b15 = b[15];

  v = a[0];
  t0 += v * b0;
  t1 += v * b1;
  t2 += v * b2;
  t3 += v * b3;
  t4 += v * b4;
  t5 += v * b5;
  t6 += v * b6;
  t7 += v * b7;
  t8 += v * b8;
  t9 += v * b9;
  t10 += v * b10;
  t11 += v * b11;
  t12 += v * b12;
  t13 += v * b13;
  t14 += v * b14;
  t15 += v * b15;
  v = a[1];
  t1 += v * b0;
  t2 += v * b1;
  t3 += v * b2;
  t4 += v * b3;
  t5 += v * b4;
  t6 += v * b5;
  t7 += v * b6;
  t8 += v * b7;
  t9 += v * b8;
  t10 += v * b9;
  t11 += v * b10;
  t12 += v * b11;
  t13 += v * b12;
  t14 += v * b13;
  t15 += v * b14;
  t16 += v * b15;
  v = a[2];
  t2 += v * b0;
  t3 += v * b1;
  t4 += v * b2;
  t5 += v * b3;
  t6 += v * b4;
  t7 += v * b5;
  t8 += v * b6;
  t9 += v * b7;
  t10 += v * b8;
  t11 += v * b9;
  t12 += v * b10;
  t13 += v * b11;
  t14 += v * b12;
  t15 += v * b13;
  t16 += v * b14;
  t17 += v * b15;
  v = a[3];
  t3 += v * b0;
  t4 += v * b1;
  t5 += v * b2;
  t6 += v * b3;
  t7 += v * b4;
  t8 += v * b5;
  t9 += v * b6;
  t10 += v * b7;
  t11 += v * b8;
  t12 += v * b9;
  t13 += v * b10;
  t14 += v * b11;
  t15 += v * b12;
  t16 += v * b13;
  t17 += v * b14;
  t18 += v * b15;
  v = a[4];
  t4 += v * b0;
  t5 += v * b1;
  t6 += v * b2;
  t7 += v * b3;
  t8 += v * b4;
  t9 += v * b5;
  t10 += v * b6;
  t11 += v * b7;
  t12 += v * b8;
  t13 += v * b9;
  t14 += v * b10;
  t15 += v * b11;
  t16 += v * b12;
  t17 += v * b13;
  t18 += v * b14;
  t19 += v * b15;
  v = a[5];
  t5 += v * b0;
  t6 += v * b1;
  t7 += v * b2;
  t8 += v * b3;
  t9 += v * b4;
  t10 += v * b5;
  t11 += v * b6;
  t12 += v * b7;
  t13 += v * b8;
  t14 += v * b9;
  t15 += v * b10;
  t16 += v * b11;
  t17 += v * b12;
  t18 += v * b13;
  t19 += v * b14;
  t20 += v * b15;
  v = a[6];
  t6 += v * b0;
  t7 += v * b1;
  t8 += v * b2;
  t9 += v * b3;
  t10 += v * b4;
  t11 += v * b5;
  t12 += v * b6;
  t13 += v * b7;
  t14 += v * b8;
  t15 += v * b9;
  t16 += v * b10;
  t17 += v * b11;
  t18 += v * b12;
  t19 += v * b13;
  t20 += v * b14;
  t21 += v * b15;
  v = a[7];
  t7 += v * b0;
  t8 += v * b1;
  t9 += v * b2;
  t10 += v * b3;
  t11 += v * b4;
  t12 += v * b5;
  t13 += v * b6;
  t14 += v * b7;
  t15 += v * b8;
  t16 += v * b9;
  t17 += v * b10;
  t18 += v * b11;
  t19 += v * b12;
  t20 += v * b13;
  t21 += v * b14;
  t22 += v * b15;
  v = a[8];
  t8 += v * b0;
  t9 += v * b1;
  t10 += v * b2;
  t11 += v * b3;
  t12 += v * b4;
  t13 += v * b5;
  t14 += v * b6;
  t15 += v * b7;
  t16 += v * b8;
  t17 += v * b9;
  t18 += v * b10;
  t19 += v * b11;
  t20 += v * b12;
  t21 += v * b13;
  t22 += v * b14;
  t23 += v * b15;
  v = a[9];
  t9 += v * b0;
  t10 += v * b1;
  t11 += v * b2;
  t12 += v * b3;
  t13 += v * b4;
  t14 += v * b5;
  t15 += v * b6;
  t16 += v * b7;
  t17 += v * b8;
  t18 += v * b9;
  t19 += v * b10;
  t20 += v * b11;
  t21 += v * b12;
  t22 += v * b13;
  t23 += v * b14;
  t24 += v * b15;
  v = a[10];
  t10 += v * b0;
  t11 += v * b1;
  t12 += v * b2;
  t13 += v * b3;
  t14 += v * b4;
  t15 += v * b5;
  t16 += v * b6;
  t17 += v * b7;
  t18 += v * b8;
  t19 += v * b9;
  t20 += v * b10;
  t21 += v * b11;
  t22 += v * b12;
  t23 += v * b13;
  t24 += v * b14;
  t25 += v * b15;
  v = a[11];
  t11 += v * b0;
  t12 += v * b1;
  t13 += v * b2;
  t14 += v * b3;
  t15 += v * b4;
  t16 += v * b5;
  t17 += v * b6;
  t18 += v * b7;
  t19 += v * b8;
  t20 += v * b9;
  t21 += v * b10;
  t22 += v * b11;
  t23 += v * b12;
  t24 += v * b13;
  t25 += v * b14;
  t26 += v * b15;
  v = a[12];
  t12 += v * b0;
  t13 += v * b1;
  t14 += v * b2;
  t15 += v * b3;
  t16 += v * b4;
  t17 += v * b5;
  t18 += v * b6;
  t19 += v * b7;
  t20 += v * b8;
  t21 += v * b9;
  t22 += v * b10;
  t23 += v * b11;
  t24 += v * b12;
  t25 += v * b13;
  t26 += v * b14;
  t27 += v * b15;
  v = a[13];
  t13 += v * b0;
  t14 += v * b1;
  t15 += v * b2;
  t16 += v * b3;
  t17 += v * b4;
  t18 += v * b5;
  t19 += v * b6;
  t20 += v * b7;
  t21 += v * b8;
  t22 += v * b9;
  t23 += v * b10;
  t24 += v * b11;
  t25 += v * b12;
  t26 += v * b13;
  t27 += v * b14;
  t28 += v * b15;
  v = a[14];
  t14 += v * b0;
  t15 += v * b1;
  t16 += v * b2;
  t17 += v * b3;
  t18 += v * b4;
  t19 += v * b5;
  t20 += v * b6;
  t21 += v * b7;
  t22 += v * b8;
  t23 += v * b9;
  t24 += v * b10;
  t25 += v * b11;
  t26 += v * b12;
  t27 += v * b13;
  t28 += v * b14;
  t29 += v * b15;
  v = a[15];
  t15 += v * b0;
  t16 += v * b1;
  t17 += v * b2;
  t18 += v * b3;
  t19 += v * b4;
  t20 += v * b5;
  t21 += v * b6;
  t22 += v * b7;
  t23 += v * b8;
  t24 += v * b9;
  t25 += v * b10;
  t26 += v * b11;
  t27 += v * b12;
  t28 += v * b13;
  t29 += v * b14;
  t30 += v * b15;

  t0  += 38 * t16;
  t1  += 38 * t17;
  t2  += 38 * t18;
  t3  += 38 * t19;
  t4  += 38 * t20;
  t5  += 38 * t21;
  t6  += 38 * t22;
  t7  += 38 * t23;
  t8  += 38 * t24;
  t9  += 38 * t25;
  t10 += 38 * t26;
  t11 += 38 * t27;
  t12 += 38 * t28;
  t13 += 38 * t29;
  t14 += 38 * t30;
  // t15 left as is

  // first car
  c = 1;
  v =  t0 + c + 65535; c = Math.floor(v / 65536);  t0 = v - c * 65536;
  v =  t1 + c + 65535; c = Math.floor(v / 65536);  t1 = v - c * 65536;
  v =  t2 + c + 65535; c = Math.floor(v / 65536);  t2 = v - c * 65536;
  v =  t3 + c + 65535; c = Math.floor(v / 65536);  t3 = v - c * 65536;
  v =  t4 + c + 65535; c = Math.floor(v / 65536);  t4 = v - c * 65536;
  v =  t5 + c + 65535; c = Math.floor(v / 65536);  t5 = v - c * 65536;
  v =  t6 + c + 65535; c = Math.floor(v / 65536);  t6 = v - c * 65536;
  v =  t7 + c + 65535; c = Math.floor(v / 65536);  t7 = v - c * 65536;
  v =  t8 + c + 65535; c = Math.floor(v / 65536);  t8 = v - c * 65536;
  v =  t9 + c + 65535; c = Math.floor(v / 65536);  t9 = v - c * 65536;
  v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;
  v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;
  v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;
  v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;
  v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;
  v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;
  t0 += c-1 + 37 * (c-1);

  // second car
  c = 1;
  v =  t0 + c + 65535; c = Math.floor(v / 65536);  t0 = v - c * 65536;
  v =  t1 + c + 65535; c = Math.floor(v / 65536);  t1 = v - c * 65536;
  v =  t2 + c + 65535; c = Math.floor(v / 65536);  t2 = v - c * 65536;
  v =  t3 + c + 65535; c = Math.floor(v / 65536);  t3 = v - c * 65536;
  v =  t4 + c + 65535; c = Math.floor(v / 65536);  t4 = v - c * 65536;
  v =  t5 + c + 65535; c = Math.floor(v / 65536);  t5 = v - c * 65536;
  v =  t6 + c + 65535; c = Math.floor(v / 65536);  t6 = v - c * 65536;
  v =  t7 + c + 65535; c = Math.floor(v / 65536);  t7 = v - c * 65536;
  v =  t8 + c + 65535; c = Math.floor(v / 65536);  t8 = v - c * 65536;
  v =  t9 + c + 65535; c = Math.floor(v / 65536);  t9 = v - c * 65536;
  v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;
  v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;
  v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;
  v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;
  v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;
  v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;
  t0 += c-1 + 37 * (c-1);

  o[ 0] = t0;
  o[ 1] = t1;
  o[ 2] = t2;
  o[ 3] = t3;
  o[ 4] = t4;
  o[ 5] = t5;
  o[ 6] = t6;
  o[ 7] = t7;
  o[ 8] = t8;
  o[ 9] = t9;
  o[10] = t10;
  o[11] = t11;
  o[12] = t12;
  o[13] = t13;
  o[14] = t14;
  o[15] = t15;
}

function S(o, a) {
  M(o, a, a);
}

function inv25519(o, i) {
  var c = gf();
  var a;
  for (a = 0; a < 16; a++) c[a] = i[a];
  for (a = 253; a >= 0; a--) {
    S(c, c);
    if(a !== 2 && a !== 4) M(c, c, i);
  }
  for (a = 0; a < 16; a++) o[a] = c[a];
}

function pow2523(o, i) {
  var c = gf();
  var a;
  for (a = 0; a < 16; a++) c[a] = i[a];
  for (a = 250; a >= 0; a--) {
      S(c, c);
      if(a !== 1) M(c, c, i);
  }
  for (a = 0; a < 16; a++) o[a] = c[a];
}

function crypto_scalarmult(q, n, p) {
  var z = new Uint8Array(32);
  var x = new Float64Array(80), r, i;
  var a = gf(), b = gf(), c = gf(),
      d = gf(), e = gf(), f = gf();
  for (i = 0; i < 31; i++) z[i] = n[i];
  z[31]=(n[31]&127)|64;
  z[0]&=248;
  unpack25519(x,p);
  for (i = 0; i < 16; i++) {
    b[i]=x[i];
    d[i]=a[i]=c[i]=0;
  }
  a[0]=d[0]=1;
  for (i=254; i>=0; --i) {
    r=(z[i>>>3]>>>(i&7))&1;
    sel25519(a,b,r);
    sel25519(c,d,r);
    A(e,a,c);
    Z(a,a,c);
    A(c,b,d);
    Z(b,b,d);
    S(d,e);
    S(f,a);
    M(a,c,a);
    M(c,b,e);
    A(e,a,c);
    Z(a,a,c);
    S(b,a);
    Z(c,d,f);
    M(a,c,_121665);
    A(a,a,d);
    M(c,c,a);
    M(a,d,f);
    M(d,b,x);
    S(b,e);
    sel25519(a,b,r);
    sel25519(c,d,r);
  }
  for (i = 0; i < 16; i++) {
    x[i+16]=a[i];
    x[i+32]=c[i];
    x[i+48]=b[i];
    x[i+64]=d[i];
  }
  var x32 = x.subarray(32);
  var x16 = x.subarray(16);
  inv25519(x32,x32);
  M(x16,x16,x32);
  pack25519(q,x16);
  return 0;
}

function crypto_scalarmult_base(q, n) {
  return crypto_scalarmult(q, n, _9);
}

function crypto_box_keypair(y, x) {
  randombytes(x, 32);
  return crypto_scalarmult_base(y, x);
}

function crypto_box_beforenm(k, y, x) {
  var s = new Uint8Array(32);
  crypto_scalarmult(s, x, y);
  return crypto_core_hsalsa20(k, _0, s, sigma);
}

var crypto_box_afternm = crypto_secretbox;
var crypto_box_open_afternm = crypto_secretbox_open;

function crypto_box(c, m, d, n, y, x) {
  var k = new Uint8Array(32);
  crypto_box_beforenm(k, y, x);
  return crypto_box_afternm(c, m, d, n, k);
}

function crypto_box_open(m, c, d, n, y, x) {
  var k = new Uint8Array(32);
  crypto_box_beforenm(k, y, x);
  return crypto_box_open_afternm(m, c, d, n, k);
}

var K = [
  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
];

function crypto_hashblocks_hl(hh, hl, m, n) {
  var wh = new Int32Array(16), wl = new Int32Array(16),
      bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7,
      bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7,
      th, tl, i, j, h, l, a, b, c, d;

  var ah0 = hh[0],
      ah1 = hh[1],
      ah2 = hh[2],
      ah3 = hh[3],
      ah4 = hh[4],
      ah5 = hh[5],
      ah6 = hh[6],
      ah7 = hh[7],

      al0 = hl[0],
      al1 = hl[1],
      al2 = hl[2],
      al3 = hl[3],
      al4 = hl[4],
      al5 = hl[5],
      al6 = hl[6],
      al7 = hl[7];

  var pos = 0;
  while (n >= 128) {
    for (i = 0; i < 16; i++) {
      j = 8 * i + pos;
      wh[i] = (m[j+0] << 24) | (m[j+1] << 16) | (m[j+2] << 8) | m[j+3];
      wl[i] = (m[j+4] << 24) | (m[j+5] << 16) | (m[j+6] << 8) | m[j+7];
    }
    for (i = 0; i < 80; i++) {
      bh0 = ah0;
      bh1 = ah1;
      bh2 = ah2;
      bh3 = ah3;
      bh4 = ah4;
      bh5 = ah5;
      bh6 = ah6;
      bh7 = ah7;

      bl0 = al0;
      bl1 = al1;
      bl2 = al2;
      bl3 = al3;
      bl4 = al4;
      bl5 = al5;
      bl6 = al6;
      bl7 = al7;

      // add
      h = ah7;
      l = al7;

      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;

      // Sigma1
      h = ((ah4 >>> 14) | (al4 << (32-14))) ^ ((ah4 >>> 18) | (al4 << (32-18))) ^ ((al4 >>> (41-32)) | (ah4 << (32-(41-32))));
      l = ((al4 >>> 14) | (ah4 << (32-14))) ^ ((al4 >>> 18) | (ah4 << (32-18))) ^ ((ah4 >>> (41-32)) | (al4 << (32-(41-32))));

      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;

      // Ch
      h = (ah4 & ah5) ^ (~ah4 & ah6);
      l = (al4 & al5) ^ (~al4 & al6);

      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;

      // K
      h = K[i*2];
      l = K[i*2+1];

      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;

      // w
      h = wh[i%16];
      l = wl[i%16];

      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;

      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;

      th = c & 0xffff | d << 16;
      tl = a & 0xffff | b << 16;

      // add
      h = th;
      l = tl;

      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;

      // Sigma0
      h = ((ah0 >>> 28) | (al0 << (32-28))) ^ ((al0 >>> (34-32)) | (ah0 << (32-(34-32)))) ^ ((al0 >>> (39-32)) | (ah0 << (32-(39-32))));
      l = ((al0 >>> 28) | (ah0 << (32-28))) ^ ((ah0 >>> (34-32)) | (al0 << (32-(34-32)))) ^ ((ah0 >>> (39-32)) | (al0 << (32-(39-32))));

      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;

      // Maj
      h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2);
      l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2);

      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;

      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;

      bh7 = (c & 0xffff) | (d << 16);
      bl7 = (a & 0xffff) | (b << 16);

      // add
      h = bh3;
      l = bl3;

      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;

      h = th;
      l = tl;

      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;

      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;

      bh3 = (c & 0xffff) | (d << 16);
      bl3 = (a & 0xffff) | (b << 16);

      ah1 = bh0;
      ah2 = bh1;
      ah3 = bh2;
      ah4 = bh3;
      ah5 = bh4;
      ah6 = bh5;
      ah7 = bh6;
      ah0 = bh7;

      al1 = bl0;
      al2 = bl1;
      al3 = bl2;
      al4 = bl3;
      al5 = bl4;
      al6 = bl5;
      al7 = bl6;
      al0 = bl7;

      if (i%16 === 15) {
        for (j = 0; j < 16; j++) {
          // add
          h = wh[j];
          l = wl[j];

          a = l & 0xffff; b = l >>> 16;
          c = h & 0xffff; d = h >>> 16;

          h = wh[(j+9)%16];
          l = wl[(j+9)%16];

          a += l & 0xffff; b += l >>> 16;
          c += h & 0xffff; d += h >>> 16;

          // sigma0
          th = wh[(j+1)%16];
          tl = wl[(j+1)%16];
          h = ((th >>> 1) | (tl << (32-1))) ^ ((th >>> 8) | (tl << (32-8))) ^ (th >>> 7);
          l = ((tl >>> 1) | (th << (32-1))) ^ ((tl >>> 8) | (th << (32-8))) ^ ((tl >>> 7) | (th << (32-7)));

          a += l & 0xffff; b += l >>> 16;
          c += h & 0xffff; d += h >>> 16;

          // sigma1
          th = wh[(j+14)%16];
          tl = wl[(j+14)%16];
          h = ((th >>> 19) | (tl << (32-19))) ^ ((tl >>> (61-32)) | (th << (32-(61-32)))) ^ (th >>> 6);
          l = ((tl >>> 19) | (th << (32-19))) ^ ((th >>> (61-32)) | (tl << (32-(61-32)))) ^ ((tl >>> 6) | (th << (32-6)));

          a += l & 0xffff; b += l >>> 16;
          c += h & 0xffff; d += h >>> 16;

          b += a >>> 16;
          c += b >>> 16;
          d += c >>> 16;

          wh[j] = (c & 0xffff) | (d << 16);
          wl[j] = (a & 0xffff) | (b << 16);
        }
      }
    }

    // add
    h = ah0;
    l = al0;

    a = l & 0xffff; b = l >>> 16;
    c = h & 0xffff; d = h >>> 16;

    h = hh[0];
    l = hl[0];

    a += l & 0xffff; b += l >>> 16;
    c += h & 0xffff; d += h >>> 16;

    b += a >>> 16;
    c += b >>> 16;
    d += c >>> 16;

    hh[0] = ah0 = (c & 0xffff) | (d << 16);
    hl[0] = al0 = (a & 0xffff) | (b << 16);

    h = ah1;
    l = al1;

    a = l & 0xffff; b = l >>> 16;
    c = h & 0xffff; d = h >>> 16;

    h = hh[1];
    l = hl[1];

    a += l & 0xffff; b += l >>> 16;
    c += h & 0xffff; d += h >>> 16;

    b += a >>> 16;
    c += b >>> 16;
    d += c >>> 16;

    hh[1] = ah1 = (c & 0xffff) | (d << 16);
    hl[1] = al1 = (a & 0xffff) | (b << 16);

    h = ah2;
    l = al2;

    a = l & 0xffff; b = l >>> 16;
    c = h & 0xffff; d = h >>> 16;

    h = hh[2];
    l = hl[2];

    a += l & 0xffff; b += l >>> 16;
    c += h & 0xffff; d += h >>> 16;

    b += a >>> 16;
    c += b >>> 16;
    d += c >>> 16;

    hh[2] = ah2 = (c & 0xffff) | (d << 16);
    hl[2] = al2 = (a & 0xffff) | (b << 16);

    h = ah3;
    l = al3;

    a = l & 0xffff; b = l >>> 16;
    c = h & 0xffff; d = h >>> 16;

    h = hh[3];
    l = hl[3];

    a += l & 0xffff; b += l >>> 16;
    c += h & 0xffff; d += h >>> 16;

    b += a >>> 16;
    c += b >>> 16;
    d += c >>> 16;

    hh[3] = ah3 = (c & 0xffff) | (d << 16);
    hl[3] = al3 = (a & 0xffff) | (b << 16);

    h = ah4;
    l = al4;

    a = l & 0xffff; b = l >>> 16;
    c = h & 0xffff; d = h >>> 16;

    h = hh[4];
    l = hl[4];

    a += l & 0xffff; b += l >>> 16;
    c += h & 0xffff; d += h >>> 16;

    b += a >>> 16;
    c += b >>> 16;
    d += c >>> 16;

    hh[4] = ah4 = (c & 0xffff) | (d << 16);
    hl[4] = al4 = (a & 0xffff) | (b << 16);

    h = ah5;
    l = al5;

    a = l & 0xffff; b = l >>> 16;
    c = h & 0xffff; d = h >>> 16;

    h = hh[5];
    l = hl[5];

    a += l & 0xffff; b += l >>> 16;
    c += h & 0xffff; d += h >>> 16;

    b += a >>> 16;
    c += b >>> 16;
    d += c >>> 16;

    hh[5] = ah5 = (c & 0xffff) | (d << 16);
    hl[5] = al5 = (a & 0xffff) | (b << 16);

    h = ah6;
    l = al6;

    a = l & 0xffff; b = l >>> 16;
    c = h & 0xffff; d = h >>> 16;

    h = hh[6];
    l = hl[6];

    a += l & 0xffff; b += l >>> 16;
    c += h & 0xffff; d += h >>> 16;

    b += a >>> 16;
    c += b >>> 16;
    d += c >>> 16;

    hh[6] = ah6 = (c & 0xffff) | (d << 16);
    hl[6] = al6 = (a & 0xffff) | (b << 16);

    h = ah7;
    l = al7;

    a = l & 0xffff; b = l >>> 16;
    c = h & 0xffff; d = h >>> 16;

    h = hh[7];
    l = hl[7];

    a += l & 0xffff; b += l >>> 16;
    c += h & 0xffff; d += h >>> 16;

    b += a >>> 16;
    c += b >>> 16;
    d += c >>> 16;

    hh[7] = ah7 = (c & 0xffff) | (d << 16);
    hl[7] = al7 = (a & 0xffff) | (b << 16);

    pos += 128;
    n -= 128;
  }

  return n;
}

function crypto_hash(out, m, n) {
  var hh = new Int32Array(8),
      hl = new Int32Array(8),
      x = new Uint8Array(256),
      i, b = n;

  hh[0] = 0x6a09e667;
  hh[1] = 0xbb67ae85;
  hh[2] = 0x3c6ef372;
  hh[3] = 0xa54ff53a;
  hh[4] = 0x510e527f;
  hh[5] = 0x9b05688c;
  hh[6] = 0x1f83d9ab;
  hh[7] = 0x5be0cd19;

  hl[0] = 0xf3bcc908;
  hl[1] = 0x84caa73b;
  hl[2] = 0xfe94f82b;
  hl[3] = 0x5f1d36f1;
  hl[4] = 0xade682d1;
  hl[5] = 0x2b3e6c1f;
  hl[6] = 0xfb41bd6b;
  hl[7] = 0x137e2179;

  crypto_hashblocks_hl(hh, hl, m, n);
  n %= 128;

  for (i = 0; i < n; i++) x[i] = m[b-n+i];
  x[n] = 128;

  n = 256-128*(n<112?1:0);
  x[n-9] = 0;
  ts64(x, n-8,  (b / 0x20000000) | 0, b << 3);
  crypto_hashblocks_hl(hh, hl, x, n);

  for (i = 0; i < 8; i++) ts64(out, 8*i, hh[i], hl[i]);

  return 0;
}

function add(p, q) {
  var a = gf(), b = gf(), c = gf(),
      d = gf(), e = gf(), f = gf(),
      g = gf(), h = gf(), t = gf();

  Z(a, p[1], p[0]);
  Z(t, q[1], q[0]);
  M(a, a, t);
  A(b, p[0], p[1]);
  A(t, q[0], q[1]);
  M(b, b, t);
  M(c, p[3], q[3]);
  M(c, c, D2);
  M(d, p[2], q[2]);
  A(d, d, d);
  Z(e, b, a);
  Z(f, d, c);
  A(g, d, c);
  A(h, b, a);

  M(p[0], e, f);
  M(p[1], h, g);
  M(p[2], g, f);
  M(p[3], e, h);
}

function cswap(p, q, b) {
  var i;
  for (i = 0; i < 4; i++) {
    sel25519(p[i], q[i], b);
  }
}

function pack(r, p) {
  var tx = gf(), ty = gf(), zi = gf();
  inv25519(zi, p[2]);
  M(tx, p[0], zi);
  M(ty, p[1], zi);
  pack25519(r, ty);
  r[31] ^= par25519(tx) << 7;
}

function scalarmult(p, q, s) {
  var b, i;
  set25519(p[0], gf0);
  set25519(p[1], gf1);
  set25519(p[2], gf1);
  set25519(p[3], gf0);
  for (i = 255; i >= 0; --i) {
    b = (s[(i/8)|0] >> (i&7)) & 1;
    cswap(p, q, b);
    add(q, p);
    add(p, p);
    cswap(p, q, b);
  }
}

function scalarbase(p, s) {
  var q = [gf(), gf(), gf(), gf()];
  set25519(q[0], X);
  set25519(q[1], Y);
  set25519(q[2], gf1);
  M(q[3], X, Y);
  scalarmult(p, q, s);
}

function crypto_sign_keypair(pk, sk, seeded) {
  var d = new Uint8Array(64);
  var p = [gf(), gf(), gf(), gf()];
  var i;

  if (!seeded) randombytes(sk, 32);
  crypto_hash(d, sk, 32);
  d[0] &= 248;
  d[31] &= 127;
  d[31] |= 64;

  scalarbase(p, d);
  pack(pk, p);

  for (i = 0; i < 32; i++) sk[i+32] = pk[i];
  return 0;
}

var L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10]);

function modL(r, x) {
  var carry, i, j, k;
  for (i = 63; i >= 32; --i) {
    carry = 0;
    for (j = i - 32, k = i - 12; j < k; ++j) {
      x[j] += carry - 16 * x[i] * L[j - (i - 32)];
      carry = (x[j] + 128) >> 8;
      x[j] -= carry * 256;
    }
    x[j] += carry;
    x[i] = 0;
  }
  carry = 0;
  for (j = 0; j < 32; j++) {
    x[j] += carry - (x[31] >> 4) * L[j];
    carry = x[j] >> 8;
    x[j] &= 255;
  }
  for (j = 0; j < 32; j++) x[j] -= carry * L[j];
  for (i = 0; i < 32; i++) {
    x[i+1] += x[i] >> 8;
    r[i] = x[i] & 255;
  }
}

function reduce(r) {
  var x = new Float64Array(64), i;
  for (i = 0; i < 64; i++) x[i] = r[i];
  for (i = 0; i < 64; i++) r[i] = 0;
  modL(r, x);
}

// Note: difference from C - smlen returned, not passed as argument.
function crypto_sign(sm, m, n, sk) {
  var d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64);
  var i, j, x = new Float64Array(64);
  var p = [gf(), gf(), gf(), gf()];

  crypto_hash(d, sk, 32);
  d[0] &= 248;
  d[31] &= 127;
  d[31] |= 64;

  var smlen = n + 64;
  for (i = 0; i < n; i++) sm[64 + i] = m[i];
  for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i];

  crypto_hash(r, sm.subarray(32), n+32);
  reduce(r);
  scalarbase(p, r);
  pack(sm, p);

  for (i = 32; i < 64; i++) sm[i] = sk[i];
  crypto_hash(h, sm, n + 64);
  reduce(h);

  for (i = 0; i < 64; i++) x[i] = 0;
  for (i = 0; i < 32; i++) x[i] = r[i];
  for (i = 0; i < 32; i++) {
    for (j = 0; j < 32; j++) {
      x[i+j] += h[i] * d[j];
    }
  }

  modL(sm.subarray(32), x);
  return smlen;
}

function unpackneg(r, p) {
  var t = gf(), chk = gf(), num = gf(),
      den = gf(), den2 = gf(), den4 = gf(),
      den6 = gf();

  set25519(r[2], gf1);
  unpack25519(r[1], p);
  S(num, r[1]);
  M(den, num, D);
  Z(num, num, r[2]);
  A(den, r[2], den);

  S(den2, den);
  S(den4, den2);
  M(den6, den4, den2);
  M(t, den6, num);
  M(t, t, den);

  pow2523(t, t);
  M(t, t, num);
  M(t, t, den);
  M(t, t, den);
  M(r[0], t, den);

  S(chk, r[0]);
  M(chk, chk, den);
  if (neq25519(chk, num)) M(r[0], r[0], I);

  S(chk, r[0]);
  M(chk, chk, den);
  if (neq25519(chk, num)) return -1;

  if (par25519(r[0]) === (p[31]>>7)) Z(r[0], gf0, r[0]);

  M(r[3], r[0], r[1]);
  return 0;
}

function crypto_sign_open(m, sm, n, pk) {
  var i, mlen;
  var t = new Uint8Array(32), h = new Uint8Array(64);
  var p = [gf(), gf(), gf(), gf()],
      q = [gf(), gf(), gf(), gf()];

  mlen = -1;
  if (n < 64) return -1;

  if (unpackneg(q, pk)) return -1;

  for (i = 0; i < n; i++) m[i] = sm[i];
  for (i = 0; i < 32; i++) m[i+32] = pk[i];
  crypto_hash(h, m, n);
  reduce(h);
  scalarmult(p, q, h);

  scalarbase(q, sm.subarray(32));
  add(p, q);
  pack(t, p);

  n -= 64;
  if (crypto_verify_32(sm, 0, t, 0)) {
    for (i = 0; i < n; i++) m[i] = 0;
    return -1;
  }

  for (i = 0; i < n; i++) m[i] = sm[i + 64];
  mlen = n;
  return mlen;
}

var crypto_secretbox_KEYBYTES = 32,
    crypto_secretbox_NONCEBYTES = 24,
    crypto_secretbox_ZEROBYTES = 32,
    crypto_secretbox_BOXZEROBYTES = 16,
    crypto_scalarmult_BYTES = 32,
    crypto_scalarmult_SCALARBYTES = 32,
    crypto_box_PUBLICKEYBYTES = 32,
    crypto_box_SECRETKEYBYTES = 32,
    crypto_box_BEFORENMBYTES = 32,
    crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES,
    crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES,
    crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES,
    crypto_sign_BYTES = 64,
    crypto_sign_PUBLICKEYBYTES = 32,
    crypto_sign_SECRETKEYBYTES = 64,
    crypto_sign_SEEDBYTES = 32,
    crypto_hash_BYTES = 64;

nacl.lowlevel = {
  crypto_core_hsalsa20: crypto_core_hsalsa20,
  crypto_stream_xor: crypto_stream_xor,
  crypto_stream: crypto_stream,
  crypto_stream_salsa20_xor: crypto_stream_salsa20_xor,
  crypto_stream_salsa20: crypto_stream_salsa20,
  crypto_onetimeauth: crypto_onetimeauth,
  crypto_onetimeauth_verify: crypto_onetimeauth_verify,
  crypto_verify_16: crypto_verify_16,
  crypto_verify_32: crypto_verify_32,
  crypto_secretbox: crypto_secretbox,
  crypto_secretbox_open: crypto_secretbox_open,
  crypto_scalarmult: crypto_scalarmult,
  crypto_scalarmult_base: crypto_scalarmult_base,
  crypto_box_beforenm: crypto_box_beforenm,
  crypto_box_afternm: crypto_box_afternm,
  crypto_box: crypto_box,
  crypto_box_open: crypto_box_open,
  crypto_box_keypair: crypto_box_keypair,
  crypto_hash: crypto_hash,
  crypto_sign: crypto_sign,
  crypto_sign_keypair: crypto_sign_keypair,
  crypto_sign_open: crypto_sign_open,

  crypto_secretbox_KEYBYTES: crypto_secretbox_KEYBYTES,
  crypto_secretbox_NONCEBYTES: crypto_secretbox_NONCEBYTES,
  crypto_secretbox_ZEROBYTES: crypto_secretbox_ZEROBYTES,
  crypto_secretbox_BOXZEROBYTES: crypto_secretbox_BOXZEROBYTES,
  crypto_scalarmult_BYTES: crypto_scalarmult_BYTES,
  crypto_scalarmult_SCALARBYTES: crypto_scalarmult_SCALARBYTES,
  crypto_box_PUBLICKEYBYTES: crypto_box_PUBLICKEYBYTES,
  crypto_box_SECRETKEYBYTES: crypto_box_SECRETKEYBYTES,
  crypto_box_BEFORENMBYTES: crypto_box_BEFORENMBYTES,
  crypto_box_NONCEBYTES: crypto_box_NONCEBYTES,
  crypto_box_ZEROBYTES: crypto_box_ZEROBYTES,
  crypto_box_BOXZEROBYTES: crypto_box_BOXZEROBYTES,
  crypto_sign_BYTES: crypto_sign_BYTES,
  crypto_sign_PUBLICKEYBYTES: crypto_sign_PUBLICKEYBYTES,
  crypto_sign_SECRETKEYBYTES: crypto_sign_SECRETKEYBYTES,
  crypto_sign_SEEDBYTES: crypto_sign_SEEDBYTES,
  crypto_hash_BYTES: crypto_hash_BYTES
};

/* High-level API */

function checkLengths(k, n) {
  if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size');
  if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size');
}

function checkBoxLengths(pk, sk) {
  if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error('bad public key size');
  if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error('bad secret key size');
}

function checkArrayTypes() {
  var t, i;
  for (i = 0; i < arguments.length; i++) {
     if ((t = Object.prototype.toString.call(arguments[i])) !== '[object Uint8Array]')
       throw new TypeError('unexpected type ' + t + ', use Uint8Array');
  }
}

function cleanup(arr) {
  for (var i = 0; i < arr.length; i++) arr[i] = 0;
}

nacl.util = {};

nacl.util.decodeUTF8 = function(s) {
  var i, d = unescape(encodeURIComponent(s)), b = new Uint8Array(d.length);
  for (i = 0; i < d.length; i++) b[i] = d.charCodeAt(i);
  return b;
};

nacl.util.encodeUTF8 = function(arr) {
  var i, s = [];
  for (i = 0; i < arr.length; i++) s.push(String.fromCharCode(arr[i]));
  return decodeURIComponent(escape(s.join('')));
};

nacl.util.encodeBase64 = function(arr) {
  if (typeof btoa === 'undefined') {
    return (new Buffer(arr)).toString('base64');
  } else {
    var i, s = [], len = arr.length;
    for (i = 0; i < len; i++) s.push(String.fromCharCode(arr[i]));
    return btoa(s.join(''));
  }
};

nacl.util.decodeBase64 = function(s) {
  if (typeof atob === 'undefined') {
    return new Uint8Array(Array.prototype.slice.call(new Buffer(s, 'base64'), 0));
  } else {
    var i, d = atob(s), b = new Uint8Array(d.length);
    for (i = 0; i < d.length; i++) b[i] = d.charCodeAt(i);
    return b;
  }
};

nacl.randomBytes = function(n) {
  var b = new Uint8Array(n);
  randombytes(b, n);
  return b;
};

nacl.secretbox = function(msg, nonce, key) {
  checkArrayTypes(msg, nonce, key);
  checkLengths(key, nonce);
  var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
  var c = new Uint8Array(m.length);
  for (var i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i];
  crypto_secretbox(c, m, m.length, nonce, key);
  return c.subarray(crypto_secretbox_BOXZEROBYTES);
};

nacl.secretbox.open = function(box, nonce, key) {
  checkArrayTypes(box, nonce, key);
  checkLengths(key, nonce);
  var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
  var m = new Uint8Array(c.length);
  for (var i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i];
  if (c.length < 32) return false;
  if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return false;
  return m.subarray(crypto_secretbox_ZEROBYTES);
};

nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES;
nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES;
nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES;

nacl.scalarMult = function(n, p) {
  checkArrayTypes(n, p);
  if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
  if (p.length !== crypto_scalarmult_BYTES) throw new Error('bad p size');
  var q = new Uint8Array(crypto_scalarmult_BYTES);
  crypto_scalarmult(q, n, p);
  return q;
};

nacl.scalarMult.base = function(n) {
  checkArrayTypes(n);
  if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
  var q = new Uint8Array(crypto_scalarmult_BYTES);
  crypto_scalarmult_base(q, n);
  return q;
};

nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES;
nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES;

nacl.box = function(msg, nonce, publicKey, secretKey) {
  var k = nacl.box.before(publicKey, secretKey);
  return nacl.secretbox(msg, nonce, k);
};

nacl.box.before = function(publicKey, secretKey) {
  checkArrayTypes(publicKey, secretKey);
  checkBoxLengths(publicKey, secretKey);
  var k = new Uint8Array(crypto_box_BEFORENMBYTES);
  crypto_box_beforenm(k, publicKey, secretKey);
  return k;
};

nacl.box.after = nacl.secretbox;

nacl.box.open = function(msg, nonce, publicKey, secretKey) {
  var k = nacl.box.before(publicKey, secretKey);
  return nacl.secretbox.open(msg, nonce, k);
};

nacl.box.open.after = nacl.secretbox.open;

nacl.box.keyPair = function() {
  var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
  var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);
  crypto_box_keypair(pk, sk);
  return {publicKey: pk, secretKey: sk};
};

nacl.box.keyPair.fromSecretKey = function(secretKey) {
  checkArrayTypes(secretKey);
  if (secretKey.length !== crypto_box_SECRETKEYBYTES)
    throw new Error('bad secret key size');
  var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
  crypto_scalarmult_base(pk, secretKey);
  return {publicKey: pk, secretKey: new Uint8Array(secretKey)};
};

nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES;
nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES;
nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES;
nacl.box.nonceLength = crypto_box_NONCEBYTES;
nacl.box.overheadLength = nacl.secretbox.overheadLength;

nacl.sign = function(msg, secretKey) {
  checkArrayTypes(msg, secretKey);
  if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
    throw new Error('bad secret key size');
  var signedMsg = new Uint8Array(crypto_sign_BYTES+msg.length);
  crypto_sign(signedMsg, msg, msg.length, secretKey);
  return signedMsg;
};

nacl.sign.open = function(signedMsg, publicKey) {
  if (arguments.length !== 2)
    throw new Error('nacl.sign.open accepts 2 arguments; did you mean to use nacl.sign.detached.verify?');
  checkArrayTypes(signedMsg, publicKey);
  if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
    throw new Error('bad public key size');
  var tmp = new Uint8Array(signedMsg.length);
  var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);
  if (mlen < 0) return null;
  var m = new Uint8Array(mlen);
  for (var i = 0; i < m.length; i++) m[i] = tmp[i];
  return m;
};

nacl.sign.detached = function(msg, secretKey) {
  var signedMsg = nacl.sign(msg, secretKey);
  var sig = new Uint8Array(crypto_sign_BYTES);
  for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];
  return sig;
};

nacl.sign.detached.verify = function(msg, sig, publicKey) {
  checkArrayTypes(msg, sig, publicKey);
  if (sig.length !== crypto_sign_BYTES)
    throw new Error('bad signature size');
  if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
    throw new Error('bad public key size');
  var sm = new Uint8Array(crypto_sign_BYTES + msg.length);
  var m = new Uint8Array(crypto_sign_BYTES + msg.length);
  var i;
  for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i];
  for (i = 0; i < msg.length; i++) sm[i+crypto_sign_BYTES] = msg[i];
  return (crypto_sign_open(m, sm, sm.length, publicKey) >= 0);
};

nacl.sign.keyPair = function() {
  var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
  var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
  crypto_sign_keypair(pk, sk);
  return {publicKey: pk, secretKey: sk};
};

nacl.sign.keyPair.fromSecretKey = function(secretKey) {
  checkArrayTypes(secretKey);
  if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
    throw new Error('bad secret key size');
  var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
  for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32+i];
  return {publicKey: pk, secretKey: new Uint8Array(secretKey)};
};

nacl.sign.keyPair.fromSeed = function(seed) {
  checkArrayTypes(seed);
  if (seed.length !== crypto_sign_SEEDBYTES)
    throw new Error('bad seed size');
  var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
  var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
  for (var i = 0; i < 32; i++) sk[i] = seed[i];
  crypto_sign_keypair(pk, sk, true);
  return {publicKey: pk, secretKey: sk};
};

nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES;
nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES;
nacl.sign.seedLength = crypto_sign_SEEDBYTES;
nacl.sign.signatureLength = crypto_sign_BYTES;

nacl.hash = function(msg) {
  checkArrayTypes(msg);
  var h = new Uint8Array(crypto_hash_BYTES);
  crypto_hash(h, msg, msg.length);
  return h;
};

nacl.hash.hashLength = crypto_hash_BYTES;

nacl.verify = function(x, y) {
  checkArrayTypes(x, y);
  // Zero length arguments are considered not equal.
  if (x.length === 0 || y.length === 0) return false;
  if (x.length !== y.length) return false;
  return (vn(x, 0, y, 0, x.length) === 0) ? true : false;
};

nacl.setPRNG = function(fn) {
  randombytes = fn;
};

(function() {
  // Initialize PRNG if environment provides CSPRNG.
  // If not, methods calling randombytes will throw.
  var crypto;
  if (typeof window !== 'undefined') {
    // Browser.
    if (window.crypto && window.crypto.getRandomValues) {
      crypto = window.crypto; // Standard
    } else if (window.msCrypto && window.msCrypto.getRandomValues) {
      crypto = window.msCrypto; // Internet Explorer 11+
    }
    if (crypto) {
      nacl.setPRNG(function(x, n) {
        var i, v = new Uint8Array(n);
        crypto.getRandomValues(v);
        for (i = 0; i < n; i++) x[i] = v[i];
        cleanup(v);
      });
    }
  } else if (typeof require !== 'undefined') {
    // Node.js.
    crypto = require('crypto');
    if (crypto) {
      nacl.setPRNG(function(x, n) {
        var i, v = crypto.randomBytes(n);
        for (i = 0; i < n; i++) x[i] = v[i];
        cleanup(v);
      });
    }
  }
})();

})(typeof module !== 'undefined' && module.exports ? module.exports : (window.nacl = window.nacl || {}));

}).call(this,require("buffer").Buffer)
},{"buffer":14,"crypto":14}]},{},[9])(9)
});