From 4fde72b8b6579d114800eac8713e165e89914b99 Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Mon, 4 Feb 2019 14:00:05 +0530
Subject: [PATCH 01/12] fixed prototype mistakes

---
 supernode/index.html | 888 +++++++++++++++++++++++++++++++++++--------
 1 file changed, 740 insertions(+), 148 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index d759061..567e5b2 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -8653,7 +8653,512 @@
         
         })("secp256k1"); // End of EllipticCurveEncryption Object
         
-        </script>
+    </script>
+
+    <!-- Kademelia -->
+    <script>
+        /*Kademlia DHT K-bucket implementation as a binary tree.*/
+
+        if (typeof reactor == "undefined" || !reactor) {
+            (function () {
+
+                function Event(name) {
+                    this.name = name;
+                    this.callbacks = [];
+                }
+                Event.prototype.registerCallback = function (callback) {
+                    this.callbacks.push(callback);
+                };
+
+                function Reactor() {
+                    this.events = {};
+                }
+
+                Reactor.prototype.registerEvent = function (eventName) {
+                    var event = new Event(eventName);
+                    this.events[eventName] = event;
+                };
+
+                Reactor.prototype.dispatchEvent = function (eventName, eventArgs) {
+                    this.events[eventName].callbacks.forEach(function (callback) {
+                        callback(eventArgs);
+                    });
+                };
+
+                Reactor.prototype.addEventListener = function (eventName, callback) {
+                    this.events[eventName].registerCallback(callback);
+                };
+
+                window.reactor = new Reactor();
+
+            })();
+        }
+
+
+
+        reactor.registerEvent('added');
+        reactor.addEventListener('added', function (someObject) {
+            console.log('Added fired with data ' + someObject);
+        });
+
+        reactor.registerEvent('removed');
+        reactor.addEventListener('removed', function (someObject) {
+            console.log('Removed fired with data ' + someObject);
+        });
+
+        reactor.registerEvent('updated');
+        reactor.addEventListener('updated', function (someObject) {
+            console.log('Updated fired with data ' + someObject);
+        });
+
+
+        /*
+        //Sample Usage
+        //Creating and defining the event
+        reactor.registerEvent('big bang');
+        reactor.addEventListener('big bang', function(someObject){
+        console.log('This is big bang listener yo!'+ someObject.a);
+        });
+        
+        //Firing the event
+        reactor.dispatchEvent('big bang');
+        reactor.dispatchEvent('big bang',{a:1});
+        reactor.dispatchEvent('big bang',{a:55});
+        
+        */
+
+
+        //Checking if existing NodeID can be used
+        //This first block of if will initialize the configuration of KBucket
+        //Add Events, Messaging between different K-Buckets, and attach relevant distributed data
+        if (typeof KBucketOptions == "undefined" || !KBucketOptions) {
+
+            var KBucketOptions = {};
+            var sanitizedFLOAddress = new Uint8Array(20);
+            KBucketOptions.localNodeId = window.crypto.getRandomValues(sanitizedFLOAddress);
+
+        }
+
+        if (typeof KBucket == "undefined" || !KBucket) {
+            (function (options) {
+
+
+
+                var buf = new Uint8Array(20);
+                var randomBytes = window.crypto.getRandomValues(buf);
+
+
+                /**
+                 * @param  {Uint8Array} array1
+                 * @param  {Uint8Array} array2
+                 * @return {Boolean}
+                 */
+                function arrayEquals(array1, array2) {
+                    if (array1 === array2) {
+                        return true
+                    }
+                    if (array1.length !== array2.length) {
+                        return false
+                    }
+                    for (let i = 0, length = array1.length; i < length; ++i) {
+                        if (array1[i] !== array2[i]) {
+                            return false
+                        }
+                    }
+                    return true
+                }
+
+                function createNode() {
+                    return {
+                        contacts: [],
+                        dontSplit: false,
+                        left: null,
+                        right: null
+                    }
+                }
+
+                function ensureInt8(name, val) {
+                    if (!(val instanceof Uint8Array)) {
+                        throw new TypeError(name + ' is not a Uint8Array')
+                    }
+                }
+
+                /**
+                 * Implementation of a Kademlia DHT k-bucket used for storing
+                 * contact (peer node) information.
+                 *
+                 * @extends EventEmitter
+                 */
+                function KBucket(options = {}) {
+                    /**
+                     * `options`:
+                     *   `distance`: Function
+                     *     `function (firstId, secondId) { return distance }` An optional
+                     *     `distance` function that gets two `id` Uint8Arrays
+                     *     and return distance (as number) between them.
+                     *   `arbiter`: Function (Default: vectorClock arbiter)
+                     *     `function (incumbent, candidate) { return contact; }` An optional
+                     *     `arbiter` function that givent two `contact` objects with the same `id`
+                     *     returns the desired object to be used for updating the k-bucket. For
+                     *     more details, see [arbiter function](#arbiter-function).
+                     *   `localNodeId`: Uint8Array An optional Uint8Array representing the local node id.
+                     *     If not provided, a local node id will be created via `randomBytes(20)`.
+                     *     `metadata`: Object (Default: {}) Optional satellite data to include
+                     *     with the k-bucket. `metadata` property is guaranteed not be altered by,
+                     *     it is provided as an explicit container for users of k-bucket to store
+                     *     implementation-specific data.
+                     *   `numberOfNodesPerKBucket`: Integer (Default: 20) The number of nodes
+                     *     that a k-bucket can contain before being full or split.
+                     *     `numberOfNodesToPing`: Integer (Default: 3) The number of nodes to
+                     *     ping when a bucket that should not be split becomes full. KBucket will
+                     *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
+                     *     not been contacted the longest.
+                     *
+                     * @param {Object=} options optional
+                     */
+
+                    this.localNodeId = options.localNodeId || randomBytes
+                    this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
+                    this.numberOfNodesToPing = options.numberOfNodesToPing || 3
+                    this.distance = options.distance || KBucket.distance
+                    // use an arbiter from options or vectorClock arbiter by default
+                    this.arbiter = options.arbiter || KBucket.arbiter
+                    this.metadata = Object.assign({}, options.metadata)
+
+                    ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
+
+                    this.root = createNode()
+
+
+                    /**
+                     * Default arbiter function for contacts with the same id. Uses
+                     * contact.vectorClock to select which contact to update the k-bucket with.
+                     * Contact with larger vectorClock field will be selected. If vectorClock is
+                     * the same, candidat will be selected.
+                     *
+                     * @param  {Object} incumbent Contact currently stored in the k-bucket.
+                     * @param  {Object} candidate Contact being added to the k-bucket.
+                     * @return {Object}           Contact to updated the k-bucket with.
+                     */
+                    this.arbiter = function (incumbent, candidate) {
+                        return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
+                    }
+
+                    /**
+                     * Default distance function. Finds the XOR
+                     * distance between firstId and secondId.
+                     *
+                     * @param  {Uint8Array} firstId  Uint8Array containing first id.
+                     * @param  {Uint8Array} secondId Uint8Array containing second id.
+                     * @return {Number}              Integer The XOR distance between firstId
+                     *                               and secondId.
+                     */
+                    this.distance = function (firstId, secondId) {
+                        let distance = 0
+                        let i = 0
+                        const min = Math.min(firstId.length, secondId.length)
+                        const max = Math.max(firstId.length, secondId.length)
+                        for (; i < min; ++i) {
+                            distance = distance * 256 + (firstId[i] ^ secondId[i])
+                        }
+                        for (; i < max; ++i) distance = distance * 256 + 255
+                        return distance
+                    }
+
+                    /**
+                     * Adds a contact to the k-bucket.
+                     *
+                     * @param {Object} contact the contact object to add
+                     */
+                    this.add = function (contact) {
+                        ensureInt8('contact.id', (contact || {}).id)
+
+                        let bitIndex = 0
+                        let node = this.root
+
+                        while (node.contacts === null) {
+                            // this is not a leaf node but an inner node with 'low' and 'high'
+                            // branches; we will check the appropriate bit of the identifier and
+                            // delegate to the appropriate node for further processing
+                            node = this._determineNode(node, contact.id, bitIndex++)
+                        }
+
+                        // check if the contact already exists
+                        const index = this._indexOf(node, contact.id)
+                        if (index >= 0) {
+                            this._update(node, index, contact)
+                            return this
+                        }
+
+                        if (node.contacts.length < this.numberOfNodesPerKBucket) {
+                            node.contacts.push(contact)
+                            reactor.dispatchEvent('added', contact)
+                            return this
+                        }
+
+                        // the bucket is full
+                        if (node.dontSplit) {
+                            // we are not allowed to split the bucket
+                            // we need to ping the first this.numberOfNodesToPing
+                            // in order to determine if they are alive
+                            // only if one of the pinged nodes does not respond, can the new contact
+                            // be added (this prevents DoS flodding with new invalid contacts)
+                            this.emit('ping', node.contacts.slice(0, this.numberOfNodesToPing), contact)
+                            return this
+                        }
+
+                        this._split(node, bitIndex)
+                        return this.add(contact)
+                    }
+
+                    /**
+                     * Get the n closest contacts to the provided node id. "Closest" here means:
+                     * closest according to the XOR metric of the contact node id.
+                     *
+                     * @param  {Uint8Array} id  Contact node id
+                     * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
+                     *                          closest contacts to return
+                     * @return {Array}          Array Maximum of n closest contacts to the node id
+                     */
+                    this.closest = function (id, n = Infinity) {
+                        ensureInt8('id', id)
+
+                        if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
+                            throw new TypeError('n is not positive number')
+                        }
+
+                        let contacts = []
+
+                        for (let nodes = [this.root], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) {
+                                const detNode = this._determineNode(node, id, bitIndex++)
+                                nodes.push(node.left === detNode ? node.right : node.left)
+                                nodes.push(detNode)
+                            } else {
+                                contacts = contacts.concat(node.contacts)
+                            }
+                        }
+
+                        return contacts
+                            .map(a => [this.distance(a.id, id), a])
+                            .sort((a, b) => a[0] - b[0])
+                            .slice(0, n)
+                            .map(a => a[1])
+                    }
+
+                    /**
+                     * Counts the total number of contacts in the tree.
+                     *
+                     * @return {Number} The number of contacts held in the tree
+                     */
+                    this.count = function () {
+                        // return this.toArray().length
+                        let count = 0
+                        for (const nodes = [this.root]; nodes.length > 0;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) nodes.push(node.right, node.left)
+                            else count += node.contacts.length
+                        }
+                        return count
+                    }
+
+                    /**
+                     * Determines whether the id at the bitIndex is 0 or 1.
+                     * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
+                     *
+                     * @param  {Object} node     internal object that has 2 leafs: left and right
+                     * @param  {Uint8Array} id   Id to compare localNodeId with.
+                     * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
+                     *                           to check in the id Uint8Array.
+                     * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
+                     */
+                    this._determineNode = function (node, id, bitIndex) {
+                        // *NOTE* remember that id is a Uint8Array and has granularity of
+                        // bytes (8 bits), whereas the bitIndex is the bit index (not byte)
+
+                        // id's that are too short are put in low bucket (1 byte = 8 bits)
+                        // (bitIndex >> 3) finds how many bytes the bitIndex describes
+                        // bitIndex % 8 checks if we have extra bits beyond byte multiples
+                        // if number of bytes is <= no. of bytes described by bitIndex and there
+                        // are extra bits to consider, this means id has less bits than what
+                        // bitIndex describes, id therefore is too short, and will be put in low
+                        // bucket
+                        const bytesDescribedByBitIndex = bitIndex >> 3
+                        const bitIndexWithinByte = bitIndex % 8
+                        if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
+                            return node.left
+                        }
+
+                        const byteUnderConsideration = id[bytesDescribedByBitIndex]
+
+                        // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
+                        // where 255 is 11111111 and 0 is 00000000
+                        // in order to find out whether the bit at bitIndexWithinByte is set
+                        // we construct (1 << (7 - bitIndexWithinByte)) which will consist
+                        // of all bits being 0, with only one bit set to 1
+                        // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
+                        // (1 << (7 - 3)) -> (1 << 4) -> 16
+                        if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
+                            return node.right
+                        }
+
+                        return node.left
+                    }
+
+                    /**
+                     * Get a contact by its exact ID.
+                     * If this is a leaf, loop through the bucket contents and return the correct
+                     * contact if we have it or null if not. If this is an inner node, determine
+                     * which branch of the tree to traverse and repeat.
+                     *
+                     * @param  {Uint8Array} id The ID of the contact to fetch.
+                     * @return {Object|Null}   The contact if available, otherwise null
+                     */
+                    this.get = function (id) {
+                        ensureInt8('id', id)
+
+                        let bitIndex = 0
+
+                        let node = this.root
+                        while (node.contacts === null) {
+                            node = this._determineNode(node, id, bitIndex++)
+                        }
+
+                        // index of uses contact id for matching
+                        const index = this._indexOf(node, id)
+                        return index >= 0 ? node.contacts[index] : null
+                    }
+
+                    /**
+                     * Returns the index of the contact with provided
+                     * id if it exists, returns -1 otherwise.
+                     *
+                     * @param  {Object} node    internal object that has 2 leafs: left and right
+                     * @param  {Uint8Array} id  Contact node id.
+                     * @return {Number}         Integer Index of contact with provided id if it
+                     *                          exists, -1 otherwise.
+                     */
+                    this._indexOf = function (node, id) {
+                        for (let i = 0; i < node.contacts.length; ++i) {
+                            if (arrayEquals(node.contacts[i].id, id)) return i
+                        }
+
+                        return -1
+                    }
+
+                    /**
+                     * Removes contact with the provided id.
+                     *
+                     * @param  {Uint8Array} id The ID of the contact to remove.
+                     * @return {Object}        The k-bucket itself.
+                     */
+                    this.remove = function (id) {
+                        ensureInt8('the id as parameter 1', id)
+
+                        let bitIndex = 0
+                        let node = this.root
+
+                        while (node.contacts === null) {
+                            node = this._determineNode(node, id, bitIndex++)
+                        }
+
+                        const index = this._indexOf(node, id)
+                        if (index >= 0) {
+                            const contact = node.contacts.splice(index, 1)[0]
+                            reactor.dispatchEvent('removed', contact)
+                        }
+
+                        return this
+                    }
+
+                    /**
+                     * Splits the node, redistributes contacts to the new nodes, and marks the
+                     * node that was split as an inner node of the binary tree of nodes by
+                     * setting this.root.contacts = null
+                     *
+                     * @param  {Object} node     node for splitting
+                     * @param  {Number} bitIndex the bitIndex to which byte to check in the
+                     *                           Uint8Array for navigating the binary tree
+                     */
+                    this._split = function (node, bitIndex) {
+                        node.left = createNode()
+                        node.right = createNode()
+
+                        // redistribute existing contacts amongst the two newly created nodes
+                        for (const contact of node.contacts) {
+                            this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
+                        }
+
+                        node.contacts = null // mark as inner tree node
+
+                        // don't split the "far away" node
+                        // we check where the local node would end up and mark the other one as
+                        // "dontSplit" (i.e. "far away")
+                        const detNode = this._determineNode(node, this.localNodeId, bitIndex)
+                        const otherNode = node.left === detNode ? node.right : node.left
+                        otherNode.dontSplit = true
+                    }
+
+                    /**
+                     * Returns all the contacts contained in the tree as an array.
+                     * If this is a leaf, return a copy of the bucket. `slice` is used so that we
+                     * don't accidentally leak an internal reference out that might be
+                     * accidentally misused. If this is not a leaf, return the union of the low
+                     * and high branches (themselves also as arrays).
+                     *
+                     * @return {Array} All of the contacts in the tree, as an array
+                     */
+                    this.toArray = function () {
+                        let result = []
+                        for (const nodes = [this.root]; nodes.length > 0;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) nodes.push(node.right, node.left)
+                            else result = result.concat(node.contacts)
+                        }
+                        return result
+                    }
+
+                    /**
+                     * Updates the contact selected by the arbiter.
+                     * If the selection is our old contact and the candidate is some new contact
+                     * then the new contact is abandoned (not added).
+                     * If the selection is our old contact and the candidate is our old contact
+                     * then we are refreshing the contact and it is marked as most recently
+                     * contacted (by being moved to the right/end of the bucket array).
+                     * If the selection is our new contact, the old contact is removed and the new
+                     * contact is marked as most recently contacted.
+                     *
+                     * @param  {Object} node    internal object that has 2 leafs: left and right
+                     * @param  {Number} index   the index in the bucket where contact exists
+                     *                          (index has already been computed in a previous
+                     *                          calculation)
+                     * @param  {Object} contact The contact object to update.
+                     */
+                    this._update = function (node, index, contact) {
+                        // sanity check
+                        if (!arrayEquals(node.contacts[index].id, contact.id)) {
+                            throw new Error('wrong index for _update')
+                        }
+
+                        const incumbent = node.contacts[index]
+                        const selection = this.arbiter(incumbent, contact)
+                        // if the selection is our old contact and the candidate is some new
+                        // contact, then there is nothing to do
+                        if (selection === incumbent && incumbent !== contact) return
+
+                        node.contacts.splice(index, 1) // remove old contact
+                        node.contacts.push(selection) // add more recent contact version
+                        reactor.dispatchEvent('updated', incumbent.concat(selection))
+                    }
+                }
+
+                window.KBucket = new KBucket(options)
+
+            })(KBucketOptions);
+
+        }
+    </script>
 
     <!---------------------------------------------------------------------------------- 
                                 localbitcoinplusplus Code starts 
@@ -9144,7 +9649,8 @@
             },
 
             sync_with_supernode: function(trader_flo_address) {
-                let sync_request = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                let sync_request = RM_RPC.send_rpc.call(this,
                     "sync_with_supernode", {
                         "trader_flo_address": trader_flo_address,
                         "job": "SYNC_MY_LOCAL_DB_WITH_SUPERNODE_DB"
@@ -9167,18 +9673,20 @@
                             claim_id:claim_id
                         }
 
+                        const RM_WALLET = new localbitcoinplusplus.wallets;
+                        const RM_RPC = new localbitcoinplusplus.rpc;
+
                         let deposit_withdraw_user_claim_str = JSON.stringify(deposit_withdraw_user_claim_obj);
                         let deposit_withdraw_user_claim_hash = Crypto.SHA256(deposit_withdraw_user_claim_str);
-                        let deposit_withdraw_user_claim_sign = localbitcoinplusplus.wallets.prototype.sign(deposit_withdraw_user_claim_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                        let deposit_withdraw_user_claim_sign = RM_WALLET.sign(deposit_withdraw_user_claim_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
 
                         deposit_withdraw_user_claim_obj.userPubKey = localbitcoinplusplus.wallets.my_local_flo_public_key;
                         deposit_withdraw_user_claim_obj.hash = deposit_withdraw_user_claim_hash;
                         deposit_withdraw_user_claim_obj.sign = deposit_withdraw_user_claim_sign;
 
+                        
                         let deposit_withdraw_claim =
-                            localbitcoinplusplus
-                            .rpc
-                            .prototype
+                            RM_RPC
                             .send_rpc
                             .call(
                                 this,
@@ -9348,7 +9856,8 @@
                 let myPrivateKey = localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY;
                 if (typeof myPrivateKey!=="string") throw new Error("No private key found.");
                 
-                let privateKey = localbitcoinplusplus.wallets.prototype.wifToDecimal(myPrivateKey, true);
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                let privateKey = RM_WALLET.wifToDecimal(myPrivateKey, true);
                 if(typeof privateKey.privateKeyDecimal !== "string") throw new Error("Failed to detremine your private key.");
                 receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
 
@@ -9366,16 +9875,17 @@
                 readDB('userPublicData', flo_id).then((res)=>{
                     pubKey = res.trader_flo_pubKey;
                     let foo = localbitcoinplusplus.encrypt.encryptMessage(message, pubKey);
-                    let bar = localbitcoinplusplus.rpc.prototype
-                        .send_rpc
-                        .call(this, "testMessageBroadcasting", foo);
-                    
+                    const RM_RPC = new localbitcoinplusplus.rpc;
+                    let bar = RM_RPC
+                            .send_rpc
+                            .call(this, "testMessageBroadcasting", foo);
                     doSend(bar);
                 });
             },
 
             transmitMessageToMiddleMan: function(dataToBeSentToReceiver, receiverFloAddress) {
-                let bar = localbitcoinplusplus.rpc.prototype
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                let bar = RM_RPC
                     .send_rpc
                     .call(this, "MessageForMiddleman", dataToBeSentToReceiver);
                 doSend(bar);
@@ -9511,7 +10021,8 @@
                 return false;
             },
             rebuild_my_private_key: function(transactionKey) {
-                let my_pvt_key = localbitcoinplusplus.wallets.prototype.rebuild_private_key(MY_PRIVATE_KEY_SHAMIRS_SHARES, transactionKey);
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                let my_pvt_key = RM_WALLET.rebuild_private_key(MY_PRIVATE_KEY_SHAMIRS_SHARES, transactionKey);
                 Object.defineProperty(localbitcoinplusplus.wallets, 'MY_SUPERNODE_PRIVATE_KEY', {
                     value: my_pvt_key,
                     writable: false,
@@ -9563,14 +10074,15 @@
 
                 if (users_entered_private_key.length<0) throw new Error("Private key is empty.");
                 
+                const RM_WALLET = new localbitcoinplusplus.wallets;
                 let publicKey_for_users_entered_private_key;
                 try {
-                    publicKey_for_users_entered_private_key = localbitcoinplusplus.wallets.prototype.generateFloKeys(users_entered_private_key).pubKeyHex;
+                    publicKey_for_users_entered_private_key = RM_WALLET.generateFloKeys(users_entered_private_key).pubKeyHex;
                 } catch (error) {
                     throw new Error(error);
                 } 
 
-                let pvt_key_shamirs_secret_shares = localbitcoinplusplus.wallets.prototype.createShamirsSecretShares(users_entered_private_key, 10, 5);
+                let pvt_key_shamirs_secret_shares = RM_WALLET.createShamirsSecretShares(users_entered_private_key, 10, 5);
                 if (typeof pvt_key_shamirs_secret_shares=="object" && pvt_key_shamirs_secret_shares.length>0) {
                     
                     // Add suprnode's own private keys to DB
@@ -9591,7 +10103,8 @@
 
                     // Send chunks of private keys to other supernodes 
                     pvt_key_shamirs_secret_shares_array.map(shares=>{
-                        let store_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                        const RM_RPC = new localbitcoinplusplus.rpc;
+                        let store_pvtkey_req = RM_RPC
                             .send_rpc
                             .call(this, "store_shamirs_secret_pvtkey_shares",
                             shares);
@@ -9625,7 +10138,8 @@
                 if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY === "string"
                     && localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY.length > 0
                 ) {
-                    let user_keys = localbitcoinplusplus.wallets.prototype.generateFloKeys(localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                    const RM_WALLET = new localbitcoinplusplus.wallets;
+                    let user_keys = RM_WALLET.generateFloKeys(localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                     if (typeof user_keys == "object" && typeof user_keys.pubKeyHex == "string") {
                         if (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                                 user_keys.pubKeyHex)) {
@@ -9640,8 +10154,13 @@
                 var request = JSON.parse(request);
                 var params = request.params[0];
                 var method = request.method;
-                
+
                 if (typeof params == "object" && typeof method == "string") {
+                    
+                    const RM_WALLET = new localbitcoinplusplus.wallets;
+                    const RM_TRADE = new localbitcoinplusplus.trade;
+                    const RM_RPC = new localbitcoinplusplus.rpc;
+                    
                     let respective_trader_id = '';
                     if (typeof params.trader_flo_address == "string") respective_trader_id = params.trader_flo_address;
                     request.response = {};
@@ -9672,7 +10191,8 @@
                                             let server_msg = `Trader id ${respective_trader_id} is not clear for trade currently.
                                                 You must finish your previous pending deposit/withdraw action to qualify again to trade.`;
 
-                                            let server_response = localbitcoinplusplus.rpc.prototype
+                                            const RM_RPC = new localbitcoinplusplus.rpc;
+                                            let server_response = RM_RPC
                                                 .send_rpc
                                                 .call(this, "supernode_message",
                                                     {"trader_flo_id":respective_trader_id, "server_msg":server_msg});
@@ -9689,23 +10209,24 @@
                     
                     switch (method) {
                         case "trade_buy":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(async function (is_valid_request) {
+                            
+                            RM_RPC.filter_legit_requests(async function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
-                                await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                let trade_margin = await localbitcoinplusplus.trade.prototype.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
+                                await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
                                 if (typeof trade_margin.remaining_crypto_credit=="number" && typeof trade_margin.remaining_fiat_credit=="number") {
                                     if (trade_margin.remaining_fiat_credit>0 && trade_margin.remaining_fiat_credit>=params.buy_price) {
-                                        request.response = localbitcoinplusplus.trade.prototype.trade_buy.call(this,
+                                        request.response = RM_TRADE.trade_buy.call(this,
                                         ...request.params,
                                         function (supernode_signed_res) {
                                             if (typeof supernode_signed_res == "object") {
-                                                let buy_request_response = localbitcoinplusplus.rpc.prototype
+                                                let buy_request_response = RM_RPC
                                                     .send_rpc
                                                     .call(this, "trade_buy_request_response",
                                                         supernode_signed_res);
                                                 doSend(buy_request_response);
                                                 // Init trading
-                                                localbitcoinplusplus.trade.prototype.createTradePipes(params.currency);
+                                                RM_TRADE.createTradePipes(params.currency);
                                                 return true;
                                             }
                                         });       
@@ -9719,24 +10240,24 @@
                             });
                             break;
                         case "trade_sell":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(async function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(async function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
-                                await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                let trade_margin = await localbitcoinplusplus.trade.prototype.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
+                                await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
                                 if (typeof trade_margin.remaining_crypto_credit=="number" && typeof trade_margin.remaining_fiat_credit=="number") {
-                                    let eqCrypto = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(params.buy_price);
+                                    let eqCrypto = RM_TRADE.calculateCryptoEquivalentOfCash(params.buy_price);
                                     if (trade_margin.remaining_crypto_credit>0 && trade_margin.remaining_crypto_credit>=eqCrypto) {
-                                        request.response = localbitcoinplusplus.trade.prototype.trade_sell.call(
+                                        request.response = RM_TRADE.trade_sell.call(
                                             this, ...request.params,
                                             function (supernode_signed_res) {
                                                 if (typeof supernode_signed_res == "object") {
-                                                    let sell_request_response = localbitcoinplusplus.rpc.prototype
+                                                    let sell_request_response = RM_RPC
                                                         .send_rpc
                                                         .call(this, "trade_sell_request_response",
                                                             supernode_signed_res);
                                                     doSend(sell_request_response);
                                                     // Init trading
-                                                    localbitcoinplusplus.trade.prototype.createTradePipes(params.currency);
+                                                    RM_TRADE.createTradePipes(params.currency);
                                                     return true;
                                                 }
                                             }
@@ -9750,13 +10271,13 @@
                             });
                             break;
                         case "sync_with_supernode":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(function (is_valid_request) {
                                 if (is_valid_request === true && params.job=="SYNC_MY_LOCAL_DB_WITH_SUPERNODE_DB" && params.trader_flo_address.length>0) {
                                     const tableArray = ["deposit", "withdraw_cash", "withdraw_btc", "crypto_balances", "cash_balances", "userPublicData"];
                                     localbitcoinplusplus.actions.get_sharable_db_data(tableArray).then(function(su_db_data) {
                                         if (typeof su_db_data == "object") {
                                             su_db_data.trader_flo_address = params.trader_flo_address;
-                                            let server_sync_response = localbitcoinplusplus.rpc.prototype
+                                            let server_sync_response = RM_RPC
                                                 .send_rpc
                                                 .call(this, "server_sync_response",
                                                     su_db_data);
@@ -9768,7 +10289,7 @@
                             });
                             break;
                         case "deposit_asset_request":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(function (is_valid_request) {
 
                                 if (is_valid_request !== true) return false;
                                 
@@ -9783,25 +10304,25 @@
                                     && typeof params.trader_flo_address == "string" 
                                     && params.trader_flo_address.length > 0
                                 ) {
-                                    localbitcoinplusplus.wallets.prototype.getUserPublicKey(params.trader_flo_address, 
+                                    RM_WALLET.getUserPublicKey(params.trader_flo_address, 
                                     async function(requester_public_key) {
                                         if (requester_public_key==undefined||requester_public_key==null) {
                                             throw new Error('Failed to get public key of the user.');
                                         }
                                         params.depositor_public_key = requester_public_key;
 
-                                        await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                        await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
 
                                         if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
                                         
-                                        let generate_btc_keys_for_requester = localbitcoinplusplus.wallets.prototype
+                                        let generate_btc_keys_for_requester = RM_WALLET
                                             .generateFloKeys(null, params.product);
 
                                         params.id = helper_functions.unique_id();
                                         params.status = 1;
                                         params.btc_address = generate_btc_keys_for_requester.address;
 
-                                        params.bitcoinToBePaid = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(
+                                        params.bitcoinToBePaid = RM_TRADE.calculateCryptoEquivalentOfCash(
                                             params.depositing_amount, params.currency, params.product);
 
                                         let receivedTradeInfo = {...params};
@@ -9823,7 +10344,7 @@
                                                 receivedTradeInfo["depositDataHash"] =
                                                     receivedTradeInfoHash;
                                                 receivedTradeInfo["order_validator_sign"] =
-                                                    localbitcoinplusplus.wallets.prototype.sign(
+                                                    RM_WALLET.sign(
                                                         receivedTradeInfoHash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
                                                     );
                                                 receivedTradeInfo["order_validator_public_key"] =
@@ -9832,7 +10353,7 @@
                                                 try {
                                                     const this_btc_pvt_key = generate_btc_keys_for_requester.privateKeyWIF;
                                                     const this_btc_tx_key = Crypto.util.randomBytes(64);
-                                                    const this_btc_pvt_key_shamirs_secret = localbitcoinplusplus.wallets.prototype.createShamirsSecretShares(this_btc_pvt_key, 10, 5); 
+                                                    const this_btc_pvt_key_shamirs_secret = RM_WALLET.createShamirsSecretShares(this_btc_pvt_key, 10, 5); 
                                                     if (typeof this_btc_pvt_key_shamirs_secret=="object" && this_btc_pvt_key_shamirs_secret.length>0) {
                                                         addDB("deposit", receivedTradeInfo);
 
@@ -9840,11 +10361,11 @@
                                                         let deposit_response_object = {
                                                             error: false,
                                                             method: "deposit_asset_request_response",
-                                                            msg: `Please send the Bitcoin to ${generate_btc_keys_for_requester.address}.`,
+                                                            msg: `Please send ${params.product} ${params.bitcoinToBePaid} to the following addres: ${generate_btc_keys_for_requester.address}.`,
                                                             data: receivedTradeInfo
                                                         };
-                                                        let deposit_request_response = localbitcoinplusplus
-                                                            .rpc.prototype.send_rpc
+                                                        let deposit_request_response = RM_RPC
+                                                            .send_rpc
                                                             .call(this,
                                                                 "deposit_asset_request_response",
                                                                 deposit_response_object);
@@ -9861,7 +10382,7 @@
 
                                                         // Send chunks of private keys to other supernodes 
                                                         this_btc_pvt_key_shamirs_secret_array.map(shares=>{
-                                                            let store_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                                            let store_pvtkey_req = RM_RPC
                                                                 .send_rpc
                                                                 .call(this, "store_shamirs_secret_pvtkey_shares", shares);
                                                             doSend(store_pvtkey_req);
@@ -9904,8 +10425,7 @@
                                                     data: receivedTradeInfo
                                                 };
 
-                                                let deposit_request_response = localbitcoinplusplus
-                                                    .rpc.prototype.send_rpc
+                                                let deposit_request_response = RM_RPC.send_rpc
                                                     .call(this,
                                                         "deposit_asset_request_response",
                                                         deposit_response_object);
@@ -9932,7 +10452,7 @@
                                                 let receivedTradeInfoHash = Crypto.SHA256(JSON.stringify(receivedTradeInfo));
 
                                                 receivedTradeInfo["depositDataHash"] = receivedTradeInfoHash;
-                                                receivedTradeInfo["order_validator_sign"] = localbitcoinplusplus.wallets.prototype.sign(
+                                                receivedTradeInfo["order_validator_sign"] = RM_WALLET.sign(
                                                     receivedTradeInfoHash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
                                                 );
                                                 receivedTradeInfo["order_validator_public_key"] = su_data.myLocalFLOPublicKey;
@@ -9967,9 +10487,7 @@
                                                                                     withdrawer_data: withdrawer
                                                                                 };
                                                                                 let deposit_request_response =
-                                                                                    localbitcoinplusplus
-                                                                                    .rpc
-                                                                                    .prototype
+                                                                                    RM_RPC
                                                                                     .send_rpc
                                                                                     .call(
                                                                                         this,
@@ -9992,8 +10510,7 @@
                                                                         data: receivedTradeInfo
                                                                     };
                                                                     let deposit_request_response =
-                                                                        localbitcoinplusplus.rpc
-                                                                        .prototype.send_rpc
+                                                                        RM_RPC.send_rpc
                                                                         .call(this,
                                                                             "deposit_asset_request_response",
                                                                             deposit_response_object
@@ -10024,7 +10541,7 @@
                             });
                             break;
                         case "withdraw_request_method":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(async function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(async function (is_valid_request) {
 
                                 if (is_valid_request !== true) return false;
 
@@ -10040,11 +10557,11 @@
                                     typeof params.receivinAddress == "string" && params.receivinAddress.length >
                                     0 && typeof params.currency == "string"
                                 ) {
-                                    await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                    let trade_margin = await localbitcoinplusplus.trade.prototype.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
+                                    await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                    let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
 
                                     if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
-                                        let eqCrypto = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(params.withdrawing_amount);
+                                        let eqCrypto = RM_TRADE.calculateCryptoEquivalentOfCash(params.withdrawing_amount);
                                         if (trade_margin.remaining_crypto_credit<0 && trade_margin.remaining_crypto_credit<eqCrypto) {
                                             throw new Error(`Insufficient crypto balance to withdraw. You can withdraw upto: ${params.product} ${trade_margin.remaining_crypto_credit}`);
                                         }
@@ -10068,7 +10585,7 @@
                                                 if(!localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency)) {
                                                     throw new Error("Invalid or unsupported currency.");
                                                 }
-                                                let eqBTC = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(
+                                                let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(
                                                     withdrawing_btc_amount_in_cash, params.currency, params.product);
                                                 eqBTC = parseFloat(eqBTC).toFixed(8);
                                                 let withdrawer_new_btc_balance = withdrawer_btc_balance - eqBTC;
@@ -10134,7 +10651,7 @@
                                                                 readDBbyIndex('system_btc_reserves_private_keys', 'btc_address', vbl.deposited_btc_address).then(function(res) {
                                                                     let retrieve_pvtkey_req_id = res[0].id;
                                                                     res[0].btc_private_key_shamirs_id.map(bpks=>{
-                                                                        let retrieve_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                                                        let retrieve_pvtkey_req = RM_RPC
                                                                             .send_rpc
                                                                             .call(this, "send_back_shamirs_secret_btc_pvtkey",
                                                                             {   retrieve_pvtkey_req_id:retrieve_pvtkey_req_id,
@@ -10219,13 +10736,11 @@
                                                                 Crypto.SHA256(JSON.stringify(
                                                                     withdraw_request_db_object
                                                                 ));
-                                                            withdraw_request_db_object[
-                                                                    "withdrawDataHash"] =
+                                                            withdraw_request_db_object["withdrawDataHash"] =
                                                                 withdraw_request_db_object_hash;
                                                             withdraw_request_db_object[
                                                                     "order_validator_sign"] =
-                                                                localbitcoinplusplus.wallets
-                                                                .prototype
+                                                                RM_WALLET
                                                                 .sign(
                                                                     withdraw_request_db_object_hash,
                                                                     localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
@@ -10242,8 +10757,7 @@
                                                                 // return back the response to client 
                                                                 let
                                                                     withdrawal_request_response =
-                                                                    localbitcoinplusplus.rpc
-                                                                    .prototype.send_rpc
+                                                                    RM_RPC.send_rpc
                                                                     .call(this,
                                                                         "withdrawal_request_response",
                                                                         withdraw_request_db_object
@@ -10270,7 +10784,7 @@
                             break;
 
                         case "retrieve_shamirs_secret_btc_pvtkey":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(function (is_valid_request) {
                             if (is_valid_request !== true)  return false;
 
                             if (typeof params.btc_private_key_array !== "string" || typeof params.retrieve_pvtkey_req_id !== "string") return false;
@@ -10296,10 +10810,10 @@
                                                
                                                 let transaction_key = btc_reserves.supernode_transaction_key;
                                                 if (transaction_key.length>0) {
-                                                    let btc_private_key = localbitcoinplusplus.wallets.prototype.rebuild_private_key(btc_pk_shares_array, transaction_key);
+                                                    let btc_private_key = RM_WALLET.rebuild_private_key(btc_pk_shares_array, transaction_key);
                                                     console.log(btc_private_key);
                                                     
-                                                    localbitcoinplusplus.trade.prototype.sendTransaction(withdraw_res.product, withdraw_res.utxo_addr, btc_private_key, withdraw_res.receiverBTCAddress, 
+                                                    RM_TRADE.sendTransaction(withdraw_res.product, withdraw_res.utxo_addr, btc_private_key, withdraw_res.receiverBTCAddress, 
                                                         withdraw_res.receiverBTCEquivalentInCash, withdraw_res.currency, withdraw_res.change_adress, async function(res) {
                                                         console.log(res);
                                                         if (typeof res == "string" && res.length>0) {
@@ -10321,12 +10835,12 @@
                                                         *******************CHECK ACTUAL BTC BALANCE HERE THROUGH AN API AND UPDATE DEPOSIT TABLE****************************************************
                                                         ************************************************************************************************************************************/
 
-                                                        await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(withdraw_res.product, withdraw_res.currency);
+                                                        await RM_TRADE.resolve_current_crypto_price_in_fiat(withdraw_res.product, withdraw_res.currency);
 
                                                         readDBbyIndex('deposit', 'btc_address', withdraw_res.utxo_addr).then(function(deposit_arr_resp) {
                                                             if (typeof deposit_arr_resp=="object") {
                                                                 deposit_arr_resp.map(deposit_arr=>{
-                                                                    let eqBTC = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(withdraw_res.receiverBTCEquivalentInCash, withdraw_res.currency, withdraw_res.product);
+                                                                    let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(withdraw_res.receiverBTCEquivalentInCash, withdraw_res.currency, withdraw_res.product);
                                                                     eqBTC = parseFloat(eqBTC);
                                                                     deposit_arr.bitcoinToBePaid -= eqBTC;
 
@@ -10379,7 +10893,7 @@
                                         timestamp: params.data.timestamp
                                     };
                                     let res_data_hash = Crypto.SHA256(JSON.stringify(res_data_obj));
-                                    let res_data_verification = localbitcoinplusplus.wallets.prototype
+                                    let res_data_verification = RM_WALLET
                                         .verify(res_data_hash, params.sign, params.su_pubKey);
                                     if ((res_data_verification==true) && res_data_hash==params.data_hash) {
                                         addDB('userPublicData', params.data);
@@ -10393,7 +10907,7 @@
                             if (typeof params=="object") {
                                 if (params.filename=="UPDATE_ALL_FILES") {
                                     let file_details_str = JSON.stringify(params.file_updated);
-                                    if(localbitcoinplusplus.wallets.prototype.verify(file_details_str, 
+                                    if(RM_WALLET.verify(file_details_str, 
                                         params.server_sign, params.server_pubkey)) {
                                             params.file_updated.map(new_file=>{
                                                 updateinDB("external_files", new_file);
@@ -10403,7 +10917,7 @@
                                     }
                                 } else {
                                     let file_details_string = JSON.stringify(params.file_updated);
-                                    if(localbitcoinplusplus.wallets.prototype.verify(file_details_string, 
+                                    if(RM_WALLET.verify(file_details_string, 
                                         params.server_sign, params.server_pubkey)) {
                                             updateinDB("external_files", params.file_updated);
                                             createScript(params.file_updated.filename, params.file_updated.content);
@@ -10514,8 +11028,8 @@
                         "currency": this.currency,
                         "buy_price": this.buy_price
                     }
-
-                    let placeNewOrder = localbitcoinplusplus.rpc.prototype.send_rpc.call(this, this
+                    const RM_RPC = new localbitcoinplusplus.rpc;
+                    let placeNewOrder = RM_RPC.send_rpc.call(this, this
                         .rpc_job, newOrderDataObj);
                     return placeNewOrder;
 
@@ -10542,6 +11056,10 @@
                     throw new Error("Invalid buy request.");
                 }
 
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                const RM_TRADE = new localbitcoinplusplus.trade;
+                const RM_RPC = new localbitcoinplusplus.rpc;
+
                 //Check buyer's fiat balance
                 const trader_cash_id = `${params.trader_flo_address}_${params.currency}`;
                 readDB("cash_balances", trader_cash_id).then(function (res) {
@@ -10552,7 +11070,7 @@
                             throw new Error("Insufficient balance.");
                         }
                         // calculate equivalent BTC for x amount of Cash
-                        let eqBTC = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(buy_price_btc, params.currency, params.product);
+                        let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc, params.currency, params.product);
                         eqBTC = parseFloat(eqBTC);
                         if (typeof eqBTC == "number" && eqBTC > 0) {
 
@@ -10569,7 +11087,7 @@
 
                                         let hashed_data = Crypto.SHA256(JSON.stringify(params));
                                         // Signing of the data by Supernode
-                                        let signed_data = localbitcoinplusplus.wallets.prototype
+                                        let signed_data = RM_WALLET
                                             .sign(hashed_data, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
 
                                         params["data_hash"] = hashed_data;
@@ -10611,6 +11129,10 @@
                     throw new Error("Invalid sell request.");
                 }
 
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                const RM_TRADE = new localbitcoinplusplus.trade;
+                const RM_RPC = new localbitcoinplusplus.rpc;
+
                 // Check crypto balance of the seller
                 let seller_btc_id = `${params.trader_flo_address}_${params.product}`;
                 readDB("crypto_balances", seller_btc_id).then(function (res) {
@@ -10618,7 +11140,7 @@
                         .length > 0 && res.crypto_balance > 0) {
                         let seller_btc_balance = parseFloat(res.crypto_balance);
                         let sell_price_in_inr = parseFloat(params.buy_price);
-                        let eqBTC = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(sell_price_in_inr, params.currency, params.product);
+                        let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(sell_price_in_inr, params.currency, params.product);
                         eqBTC = parseFloat(eqBTC);
                         if (typeof eqBTC == "number" && eqBTC > 0) {
 
@@ -10636,7 +11158,7 @@
 
                                     let hashed_data = Crypto.SHA256(JSON.stringify(params));
                                     // Signing of the data by Supernode
-                                    let signed_data = localbitcoinplusplus.wallets.prototype
+                                    let signed_data = RM_WALLET
                                         .sign(hashed_data, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
 
                                     params["data_hash"] = hashed_data;
@@ -10651,7 +11173,7 @@
                             });
                             callback(false);
                         } else {
-                            throw new Error("Failed to fetch cuurent BTC price.");
+                            throw new Error("Failed to fetch current BTC price.");
                         }
                     } else {
                         throw new Error("Failed to read BTC balance from DB.");
@@ -10679,8 +11201,8 @@
                     order_validator_public_key: null,
                     product: assetType
                 }
-
-                let deposit_request = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                let deposit_request = RM_RPC.send_rpc.call(this,
                     "deposit_asset_request", deposit_request_object);
                 doSend(deposit_request);
             },
@@ -10710,8 +11232,8 @@
                     product: assetType,
                     currency: currency
                 }
-
-                let withdraw_request = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                let withdraw_request = RM_RPC.send_rpc.call(this,
                     "withdraw_request_method", withdraw_request_object);
                 doSend(withdraw_request);
             },
@@ -10719,7 +11241,8 @@
                 if (localbitcoinplusplus.master_configurations.validTradingAmount.includes(price)) {
                     if(!localbitcoinplusplus.master_configurations.tradableAsset1.includes(crypto_code)) return false;
                     if(!localbitcoinplusplus.master_configurations.tradableAsset2.includes(currency)) return false;
-                    let current_crypto_price = localbitcoinplusplus.trade.prototype.get_current_crypto_price_in_fiat(crypto_code, currency);
+                    const RM_TRADE = new localbitcoinplusplus.trade;
+                    let current_crypto_price = RM_TRADE.get_current_crypto_price_in_fiat(crypto_code, currency);
                     if (typeof current_crypto_price=="object" && current_crypto_price.rate > 0) {
                         return parseFloat(price / current_crypto_price.rate).toFixed(8);
                     }
@@ -10731,10 +11254,11 @@
             },
             async resolve_current_crypto_price_in_fiat(crypto_code, currency_code) {
                 let today = + new Date();
-                let last_update_of_fiat_price_obj = localbitcoinplusplus.trade.prototype.get_current_crypto_price_in_fiat(crypto_code, currency_code); 
+                const RM_TRADE = new localbitcoinplusplus.trade;
+                let last_update_of_fiat_price_obj = RM_TRADE.get_current_crypto_price_in_fiat(crypto_code, currency_code); 
                 if(typeof last_update_of_fiat_price_obj!=="object"
                   || (today-last_update_of_fiat_price_obj.timestamp>3600000)) {
-                    last_update_of_fiat_price_obj = await localbitcoinplusplus.trade.prototype.set_current_crypto_price_in_fiat(crypto_code, currency_code);
+                    last_update_of_fiat_price_obj = await RM_TRADE.set_current_crypto_price_in_fiat(crypto_code, currency_code);
                     return last_update_of_fiat_price_obj; 
                 } else {
                     return last_update_of_fiat_price_obj; 
@@ -10743,7 +11267,7 @@
             async set_current_crypto_price_in_fiat(crypto_code, currency_code) {
                 if(!localbitcoinplusplus.master_configurations.tradableAsset1.includes(crypto_code) 
                     || !localbitcoinplusplus.master_configurations.tradableAsset2.includes(currency_code)) return false;
-                let new_price = 1;
+                let new_price = 1000000;
                 
                                 /**************************
                                     Fetch latest rates here
@@ -10789,7 +11313,8 @@
                                 if (!localbitcoinplusplus.master_configurations.validTradingAmount.includes(receiving_amount)) {
                                     throw new Error('Invalid amount');
                                 }
-                                btc_eq_receiving_amount = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(receiving_amount, receiving_amount_currency, crypto_type);
+                                const RM_TRADE = new localbitcoinplusplus.trade;
+                                btc_eq_receiving_amount = RM_TRADE.calculateCryptoEquivalentOfCash(receiving_amount, receiving_amount_currency, crypto_type);
                                 btc_eq_receiving_amount = parseFloat(btc_eq_receiving_amount).toFixed(8);    
                             }
                             
@@ -10877,14 +11402,15 @@
                                             let n = buyPipe.value.length < sellPipe.value.length ? buyPipe.value.length : sellPipe.value.length;
 
                                             if (buyPipe.value.length > 0 && sellPipe.value.length > 0) {
+                                                const RM_TRADE = new localbitcoinplusplus.trade;
+                                                const RM_RPC = new localbitcoinplusplus.rpc;
                                                 for (let i = 0; i < n; i++) {
-                                                    localbitcoinplusplus.trade.prototype.launchTrade(
+                                                    RM_TRADE.launchTrade(
                                                         buyPipe.value[i], sellPipe.value[i],
                                                         function (supernode_res) {
                                                             if (typeof supernode_res == "object") {
                                                                 let server_res =
-                                                                    localbitcoinplusplus.rpc
-                                                                    .prototype.send_rpc.call(
+                                                                    RM_RPC.send_rpc.call(
                                                                         this,
                                                                         "trade_balance_updates",
                                                                         supernode_res);
@@ -10908,6 +11434,8 @@
                     && buyPipeObj.currency == sellPipeObj.currency
                     && buyPipeObj.product == sellPipeObj.product
                 ) {
+                    const RM_TRADE = new localbitcoinplusplus.trade;
+                    const RM_WALLET = new localbitcoinplusplus.wallets;
                     // Check buyer's cash balance
                     const buyer_cash_id = `${buyPipeObj.trader_flo_address}_${buyPipeObj.currency}`;
                     readDB("cash_balances", buyer_cash_id).then(function (buyPipeCashRes) {
@@ -10919,7 +11447,7 @@
                                 throw new Error("Insufficient cash balance of buyer.");
                             }
                             // calculate equivalent BTC for x amount of Cash
-                            let eqBTCBuyer = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(buy_price_btc, buyPipeObj.currency, buyPipeObj.product);
+                            let eqBTCBuyer = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc, buyPipeObj.currency, buyPipeObj.product);
 
                             if (!isNaN(eqBTCBuyer) && eqBTCBuyer != "" && eqBTCBuyer != undefined) {
                                 eqBTCBuyer = parseFloat(eqBTCBuyer);
@@ -10933,7 +11461,7 @@
                                     let seller_btc_balance = parseFloat(sellPipeBTCRes.crypto_balance)
                                         .toFixed(8);
                                     let sell_price_in_inr = parseFloat(sellPipeObj.buy_price);
-                                    let eqBTCSeller = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(
+                                    let eqBTCSeller = RM_TRADE.calculateCryptoEquivalentOfCash(
                                         sell_price_in_inr, buyPipeObj.currency, buyPipeObj.product);
                                     if (!isNaN(eqBTCSeller) && eqBTCSeller != "" && eqBTCSeller !=
                                         undefined) {
@@ -11110,8 +11638,7 @@
 
                                                                     // Signing of the data by Supernode
                                                                     let signed_data =
-                                                                        localbitcoinplusplus
-                                                                        .wallets.prototype
+                                                                        RM_WALLET
                                                                         .sign(
                                                                             hashed_data,
                                                                             localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
@@ -11150,6 +11677,9 @@
                     alert("Failed to cancel the trade.");
                     return false;
                 }
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                
                 const signed_trade_id = RM_WALLET.sign(trade_id, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                 const cancel_trade_request_object = {
                     job: `cancel_trade_request`,
@@ -11159,7 +11689,7 @@
                     trade_type: trade_type
                 }
 
-                let cancel_trade_request = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                let cancel_trade_request = RM_RPC.send_rpc.call(this,
                     "cancel_trade", cancel_trade_request_object);
                 doSend(cancel_trade_request);
             },
@@ -11493,6 +12023,10 @@
                     if (typeof res_obj.method !== undefined) {
                         let response_from_sever;
                         
+                        const RM_WALLET = new localbitcoinplusplus.wallets;
+                        const RM_TRADE = new localbitcoinplusplus.trade;
+                        const RM_RPC = new localbitcoinplusplus.rpc;
+
                         switch (res_obj.method) {
                             case "supernode_message":
                             if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
@@ -11515,7 +12049,7 @@
                             }
                             break;
                             case "trade_buy":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                                 break;
                             case "trade_buy_request_response":
@@ -11525,7 +12059,7 @@
                                     if (typeof localbitcoinplusplus.master_configurations.supernodesPubKeys == "object" &&
                                         localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                                             buyOrders_data.supernodePubKey)) {
-                                        let isDataSignedBySuperNode = localbitcoinplusplus.wallets.prototype
+                                        let isDataSignedBySuperNode = RM_WALLET
                                             .verify(buyOrders_data.data_hash, buyOrders_data.supernode_sign,
                                                 buyOrders_data.supernodePubKey);
                                         if (isDataSignedBySuperNode === true) {
@@ -11536,7 +12070,7 @@
                                 }
                                 break;
                             case "trade_sell":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                                 break;
                             case "trade_sell_request_response":
@@ -11546,7 +12080,7 @@
                                         localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                                             sellOrders_data
                                             .supernodePubKey)) {
-                                        let isDataSignedBySuperNode = localbitcoinplusplus.wallets.prototype
+                                        let isDataSignedBySuperNode = RM_WALLET
                                             .verify(sellOrders_data.data_hash, sellOrders_data.supernode_sign,
                                                 sellOrders_data.supernodePubKey);
                                         if (isDataSignedBySuperNode === true) {
@@ -11557,7 +12091,7 @@
                                 }
                                 break;
                             case "sync_with_supernode":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                                 break;
                             case "server_sync_response":
@@ -11608,13 +12142,13 @@
                                 }
                                 break;
                             case "deposit_asset_request":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                             case "deposit_asset_request_response":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object" && typeof res_obj
                                     .params[0].data == "object") {
                                     let resp = res_obj.params[0];
-                                    if (localbitcoinplusplus.wallets.prototype
+                                    if (RM_WALLET
                                         .verify(resp.data.depositDataHash, resp.data.order_validator_sign, resp.data.order_validator_public_key)
                                     ) {
                                         addDB('deposit', resp.data);
@@ -11634,13 +12168,13 @@
                                 }
                                 break;
                             case "withdraw_request_method":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                                 doSend(JSON.stringify(response_from_sever)); // send response to client
                                 break;
                             case "withdrawal_request_response":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                    if (localbitcoinplusplus.wallets.prototype
+                                    if (RM_WALLET
                                         .verify(res_obj.params[0].withdrawDataHash, res_obj.params[0].order_validator_sign,
                                             res_obj.params[0].order_validator_public_key)) {
                                         addDB('withdraw_cash', res_obj.params[0]);
@@ -11656,7 +12190,7 @@
                                                 throw new Error("Unverified user");
                                             }
                                             tradeDB = cancel_request.trade_type == "buy" ? "buyOrders":"sellOrders";
-                                            if(localbitcoinplusplus.wallets.prototype
+                                            if(RM_WALLET
                                             .verify(cancel_request.trade_id, cancel_request.signed_trade_id, trader_data.trader_flo_pubKey)) {
                                                 removeinDB(tradeDB, cancel_request.trade_id)
                                                 .then((id)=>console.info(`Trade Id ${id} deleted.`));
@@ -11685,7 +12219,7 @@
 
                                     if (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                                             trade_balance_res.supernodePubKey)) {
-                                        if (localbitcoinplusplus.wallets.prototype.verify(hashed_data,
+                                        if (RM_WALLET.verify(hashed_data,
                                                 trade_balance_res.supernode_sign, trade_balance_res.supernodePubKey)) {
                                             // Delete orders in clients DB
                                             try {
@@ -11722,7 +12256,7 @@
                             case "send_back_shamirs_secret_supernode_pvtkey":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
                                     readDB("supernode_private_key_chunks", res_obj.params[0].chunk_val).then(function(res) {
-                                        let send_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                        let send_pvtkey_req = RM_RPC
                                             .send_rpc
                                             .call(this, "retrieve_shamirs_secret_supernode_pvtkey",
                                             {private_key_chunk:res});
@@ -11740,7 +12274,7 @@
                                             MY_PRIVATE_KEY_SHAMIRS_SHARES.push(share);
                                         }
                                         if (MY_PRIVATE_KEY_SHAMIRS_SHARES.length==5) {
-                                            localbitcoinplusplus.wallets.prototype.rebuild_my_private_key(localbitcoinplusplus.wallets.supernode_transaction_key);
+                                            RM_WALLET.rebuild_my_private_key(localbitcoinplusplus.wallets.supernode_transaction_key);
                                             return;
                                         }
                                 }
@@ -11748,7 +12282,7 @@
                             case "send_back_shamirs_secret_btc_pvtkey":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
                                     readDB("supernode_private_key_chunks", res_obj.params[0].chunk_val).then(function(res) {
-                                        let send_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                        let send_pvtkey_req = RM_RPC
                                             .send_rpc
                                             .call(this, "retrieve_shamirs_secret_btc_pvtkey",
                                             {
@@ -11774,13 +12308,13 @@
                                     if (btc_pvt_arr[retrieve_pvtkey_req_id].length===localbitcoinplusplus.master_configurations.ShamirsMaxShares) {
                                         delete res_obj.params[0].private_key_chunk;
                                         res_obj.params[0].btc_private_key_array = JSON.stringify(btc_pvt_arr[retrieve_pvtkey_req_id]);
-                                        localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this, JSON.stringify(res_obj)); 
+                                        RM_RPC.receive_rpc_response.call(this, JSON.stringify(res_obj)); 
                                         btc_pvt_arr[retrieve_pvtkey_req_id] = [];  // Unset the object
                                     } 
                                 }
                                 break;
                             case "deposit_withdraw_user_claim":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                                RM_RPC.filter_legit_requests(function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
                                 if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY=="undefined") throw new Error("Supernode Private Keys is undefind.");
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
@@ -11797,7 +12331,7 @@
                                     let deposit_withdraw_user_claim_hash = Crypto.SHA256(deposit_withdraw_user_claim_str);
 
                                     if (deposit_withdraw_user_claim_hash==user_claim_request.hash &&
-                                        localbitcoinplusplus.wallets.prototype.verify(deposit_withdraw_user_claim_hash,
+                                        RM_WALLET.verify(deposit_withdraw_user_claim_hash,
                                         user_claim_request.sign, user_claim_request.userPubKey)) {
                                         //If the request is valid, find out if the requester is depositor or withdrawer
                                         
@@ -11812,12 +12346,12 @@
                                                     };
                                                     let update_withdraw_cash_obj_data_str = JSON.stringify(update_withdraw_cash_obj_data);
                                                     let update_withdraw_cash_obj_data_hash = Crypto.SHA256(update_withdraw_cash_obj_data_str);
-                                                    let update_withdraw_cash_obj_data_sign = localbitcoinplusplus.wallets.prototype
+                                                    let update_withdraw_cash_obj_data_sign = RM_WALLET
                                                         .sign(update_withdraw_cash_obj_data_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                                                     update_withdraw_cash_obj_data.hash = update_withdraw_cash_obj_data_hash;
                                                     update_withdraw_cash_obj_data.sign = update_withdraw_cash_obj_data_sign;
                                                     update_withdraw_cash_obj_data.publicKey = localbitcoinplusplus.wallets.my_local_flo_public_key;
-                                                    let update_withdraw_cash_obj = localbitcoinplusplus.rpc.prototype
+                                                    let update_withdraw_cash_obj = RM_RPC
                                                         .send_rpc
                                                         .call(this, "update_all_withdraw_cash_depositor_claim",
                                                         update_withdraw_cash_obj_data);
@@ -11849,7 +12383,7 @@
                                                         }
                                                         let update_cash_balance_str = JSON.stringify(update_cash_balance_obj);
                                                         let update_cash_balance_hash = Crypto.SHA256(update_cash_balance_str);
-                                                        let update_cash_balance_sign = localbitcoinplusplus.wallets.prototype
+                                                        let update_cash_balance_sign = RM_WALLET
                                                             .sign(update_cash_balance_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY); 
                                                         
                                                         update_cash_balance_obj.publicKey = localbitcoinplusplus.wallets.my_local_flo_public_key;
@@ -11857,7 +12391,7 @@
                                                         update_cash_balance_obj.hash = update_cash_balance_hash;
                                                         update_cash_balance_obj.withdraw_id = withdraw_data.id;
 
-                                                        let update_cash_balance_req = localbitcoinplusplus.rpc.prototype
+                                                        let update_cash_balance_req = RM_RPC
                                                             .send_rpc
                                                             .call(this, "update_all_deposit_withdraw_success",
                                                             update_cash_balance_obj);
@@ -11879,7 +12413,7 @@
                                 };
                                 let update_withdraw_cash_obj_data_res_str = JSON.stringify(update_withdraw_cash_obj_data_res);
                                 let depositor_claim_response_data_hash = Crypto.SHA256(update_withdraw_cash_obj_data_res_str);
-                                let depositor_claim_response_object_verification = localbitcoinplusplus.wallets.prototype
+                                let depositor_claim_response_object_verification = RM_WALLET
                                     .verify(depositor_claim_response_data_hash, depositor_claim_response_object.sign, depositor_claim_response_object.publicKey);
                                 
                                 if ((depositor_claim_response_data_hash==depositor_claim_response_object.hash) && (depositor_claim_response_object_verification==true)) {
@@ -11897,7 +12431,7 @@
                                 }
                                 let update_cash_balance_obj_res_str = JSON.stringify(update_cash_balance_obj_res);
                                 let update_cash_balance_obj_res_hash = Crypto.SHA256(update_cash_balance_obj_res_str);
-                                let update_cash_balance_obj_res_verification = localbitcoinplusplus.wallets.prototype
+                                let update_cash_balance_obj_res_verification = RM_WALLET
                                     .verify(update_cash_balance_obj_res_hash, withdraw_success_response.sign, withdraw_success_response.publicKey);
 
                                 if ((update_cash_balance_obj_res_hash==withdraw_success_response.hash) && update_cash_balance_obj_res_verification==true) {
@@ -11912,7 +12446,7 @@
                                 break;
 
                             case "add_user_public_data":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                                RM_RPC.filter_legit_requests(function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
 
                                 let supernode_flo_public_key = localbitcoinplusplus.wallets.my_local_flo_public_key;
@@ -11939,7 +12473,7 @@
 
                                         let public_req_object_str = JSON.stringify(public_req_object);
                                         let public_req_object_hash = Crypto.SHA256(public_req_object_str);
-                                        let public_req_object_sign = localbitcoinplusplus.wallets.prototype.sign(public_req_object_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                                        let public_req_object_sign = RM_WALLET.sign(public_req_object_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                                         
                                         let userPublicDataResponseObject = {
                                             data: public_req_object,
@@ -11948,7 +12482,7 @@
                                             su_pubKey: localbitcoinplusplus.wallets.my_local_flo_public_key
                                         }
                                         
-                                        let send_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                        let send_pvtkey_req = RM_RPC
                                             .send_rpc
                                             .call(this, "superNodeSignedAddUserPublicData",
                                             userPublicDataResponseObject);
@@ -11964,13 +12498,13 @@
                             break;
 
                             case "superNodeSignedAddUserPublicData":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                         JSON.stringify(res_obj));
                                 doSend(JSON.stringify(response_from_sever)); // send response to client
                             break;
 
                             case "refresh_deposit_status_request":
-                                localbitcoinplusplus.rpc.prototype.filter_legit_requests((is_valid_request)=>{
+                                RM_RPC.filter_legit_requests((is_valid_request)=>{
                                     if (is_valid_request !== true) return false;
                                     readDBbyIndex("deposit", 'status', 1).then(function (res) {
                                         res.map(function (deposit_trade) {
@@ -11980,10 +12514,10 @@
                                         });
                                     });
                                 });
-                            break;
+                                break;
 
                             case "update_external_file_request":
-                                localbitcoinplusplus.rpc.prototype.filter_legit_requests(is_valid_request=>{
+                                RM_RPC.filter_legit_requests(is_valid_request=>{
                                     if (is_valid_request !== true) return false;
                                     let update_script_request = res_obj.params[0];
 
@@ -11998,9 +12532,9 @@
                                         readDB("external_files", update_script_request.file_to_update).then(file_details=>{
                                             if (typeof file_details.content=="string" && file_details.content.length>0) {
                                                 let file_details_string = JSON.stringify(file_details);
-                                                let server_sign = localbitcoinplusplus.wallets.prototype
+                                                let server_sign = RM_WALLET
                                                 .sign(file_details_string, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
-                                                response_from_sever = localbitcoinplusplus.rpc.prototype.send_rpc
+                                                response_from_sever = RM_RPC.send_rpc
                                                     .call(this, "update_external_file_server_response", {
                                                         user_flo_address: update_script_request.user_flo_address,
                                                         file_updated: file_details,
@@ -12015,9 +12549,9 @@
                                         readAllDB("external_files").then(file_details=>{
                                             if (file_details.length>0) {
                                                 let file_details_str = JSON.stringify(file_details);
-                                                let server_sign = localbitcoinplusplus.wallets.prototype
+                                                let server_sign = RM_WALLET
                                                 .sign(file_details_str, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
-                                                response_from_sever = localbitcoinplusplus.rpc.prototype.send_rpc
+                                                response_from_sever = RM_RPC.send_rpc
                                                     .call(this, "update_external_file_server_response", {
                                                             user_flo_address: update_script_request.user_flo_address,
                                                             file_updated: file_details,
@@ -12030,14 +12564,36 @@
                                         });
                                     } 
                                 });
-                            break;
+                                break;
 
                             case "update_external_file_server_response":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                         JSON.stringify(res_obj));
                                 doSend(JSON.stringify(response_from_sever)); // send response to client
                                 break;
 
+                            case "updateUserCryptoBalanceRequest":
+                                let updateUserCryptoBalanceResponseObject = res_obj.params[0];
+                                let SuPubKey = readDB(userPublicData, updateUserCryptoBalanceObject.trader_flo_address)
+                                    .then(user_data=>{
+                                        if(typeof user_data !=="object" || user_data.supernode_flo_public_key.length<1) 
+                                            throw new Error(`No such user exists.`);
+                                        let updateUserCryptoBalanceResponseString = JSON.stringify
+                                            (updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject);
+                                        let isBalanceLegit = RM_WALLET.verify(updateUserCryptoBalanceResponseString, 
+                                            updateUserCryptoBalanceResponseObject.updatedBTCBalanceObjectSign,
+                                            user_data.supernode_flo_public_key 
+                                        );
+                                        if (isBalanceLegit) {
+                                            updateinDB("crypto_balances", updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject,
+                                            user_data.trader_flo_address);
+                                            if(localbitcoinplusplus.wallets.my_local_flo_address==updateUserCryptoBalanceObject.trader_flo_address)
+                                            displayBalances(updateUserCryptoBalanceObject.trader_flo_address);
+                                            return true;
+                                        } else { console.warn(`Failed to update balance in your DB. Please refresh.`); }
+                                    });
+                                break;
+
                             case "testMessageBroadcasting":
                                 console.log(res_obj);
                                 try {
@@ -12047,11 +12603,11 @@
                                 } catch (error) {
                                     console.error(error);
                                 }
-                            break;
+                                break;
 
                             case "MessageForMiddleman":
                                 console.log(res_obj);
-                            break;
+                                break;
                             
                             default:
                                 break;
@@ -12485,7 +13041,6 @@
         }
     </script>
 
-    <!-- Database operations -->
     <script>
         const createScript = (id, content)=>{
             let getScriptId = document.getElementById(id);
@@ -12523,7 +13078,8 @@
         }
 
         const updateFileRequest = (user_flo_address, filename)=>{
-            let update_external_file = localbitcoinplusplus.rpc.prototype
+            const RM_RPC = new localbitcoinplusplus.rpc;
+            let update_external_file = RM_RPC
                 .send_rpc
                 .call(this, "update_external_file_request",
                     {
@@ -12542,8 +13098,9 @@
                 let supernode_transaction_key_arr = [];
                 const chunks = await readAllDB("my_supernode_private_key_chunks");
                 if (typeof chunks == "object" && chunks.length>0) {
+                    const RM_RPC = new localbitcoinplusplus.rpc;
                     let txKey = chunks.map(chunk=>{
-                        let retrieve_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                        let retrieve_pvtkey_req = RM_RPC
                             .send_rpc
                             .call(this, "send_back_shamirs_secret_supernode_pvtkey",
                             {chunk_val:chunk.id});
@@ -12564,9 +13121,9 @@
         // localbitcoinUser Databse
         const dataBaseUIOperations = async function () {
 
-            var RM_WALLET = new localbitcoinplusplus.wallets;
-            var RM_TRADE = new localbitcoinplusplus.trade;
-            var RM_RPC = new localbitcoinplusplus.rpc;
+            const RM_WALLET = new localbitcoinplusplus.wallets;
+            const RM_TRADE = new localbitcoinplusplus.trade;
+            const RM_RPC = new localbitcoinplusplus.rpc;
 
             // rebuild private key
             privateKeyBuilder();
@@ -12594,7 +13151,7 @@
                     // Declare the user flo address
                     const MY_LOCAL_FLO_ADDRESS = localbitcoinplusplus.wallets.my_local_flo_address = idbData.myLocalFLOAddress;
                     const MY_LOCAL_FLO_PUBLIC_KEY = localbitcoinplusplus.wallets.my_local_flo_public_key = idbData.myLocalFLOPublicKey;
-
+                    
                     readDB('userPublicData', MY_LOCAL_FLO_ADDRESS).then(function(pubic_data_response) {
                         if (typeof pubic_data_response !== "object") {
                             let user_public_data_object = {
@@ -12603,7 +13160,7 @@
                                 trader_status: 0,
                                 timestamp: + new Date()
                             }
-                            let add_user_public_data_req = localbitcoinplusplus.rpc.prototype
+                            let add_user_public_data_req = RM_RPC
                                 .send_rpc
                                 .call(this, "add_user_public_data",
                                 {public_data:user_public_data_object});
@@ -12655,6 +13212,7 @@
             let myBuyOrders =  (typeof buyOrders=="object") ? Promise.resolve(buyOrders) : readDBbyIndex('buyOrders', 'trader_flo_address', myFloId);
             let mySellOrders = (typeof sellOrders=="object") ? Promise.resolve(sellOrders) : readDBbyIndex('sellOrders', 'trader_flo_address', myFloId);
             let my_trades_div = document.getElementById('my_trades_div');
+            const RM_TRADE = new localbitcoinplusplus.trade;
             let t = `<h4>Your Trade Orders: </h4>`;
                 t += `<ul>`;
             Promise.all([myBuyOrders, mySellOrders]).then((myOrders)=>{
@@ -12706,6 +13264,8 @@
 
             if(typeof idbData !== "object") return;
 
+            const RM_RPC = new localbitcoinplusplus.rpc;
+
             // NOTIFY DEPOSITED CRYPTO CONFIRMATION
             const checkCryptoStatusDiv = document.getElementById("checkCryptoStatusDiv");
             const refresh_crypto_status_btn = document.createElement('button');
@@ -12713,7 +13273,7 @@
             refresh_crypto_status_btn.appendChild(refresh_crypto_status_btn_text);
             checkCryptoStatusDiv.appendChild(refresh_crypto_status_btn);
             refresh_crypto_status_btn.addEventListener('click', function() {
-                let refresh_deposit_status = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                let refresh_deposit_status = RM_RPC.send_rpc.call(this,
                     "refresh_deposit_status_request", null);
                 doSend(refresh_deposit_status);
             });
@@ -12819,6 +13379,9 @@
     <!-- Deposit/Withdraw asset -->
     <script>
         const depositWithdrawAsset = function (userFLOaddress) {
+
+            const RM_TRADE = new localbitcoinplusplus.trade;
+
             let asset_box = document.getElementById("asset_box");
 
             // Create a select input for asset type
@@ -13008,6 +13571,7 @@
                 if (receiving_crypto_amount_input.value <0) throw new Error("Empty Sending Amount."); 
                 if (change_adress_input.value.length<1) throw new Error("Empty Change Address."); 
 
+                const RM_TRADE = new localbitcoinplusplus.trade;
                 RM_TRADE.sendTransaction(send_crypto_type.value, utxo_addr_input.value, utxo_addr_wif_input.value, receiver_address_input.value,
                 receiving_crypto_amount_input.value, null, change_adress_input.value,
                 async function(res) { 
@@ -13036,8 +13600,10 @@
             let new_flo_keys_ul = document.getElementById('new_flo_keys_ul');
             let new_flo_keys_button = document.getElementById('new_flo_keys');
             new_flo_keys_button.onclick = function () {
-                if (typeof RM_WALLET == "object") {
+                if (typeof localbitcoinplusplus.wallets !== "undefined") {
+                    const RM_WALLET = new localbitcoinplusplus.wallets;
                     let new_flo_keys = RM_WALLET.generateFloKeys();
+                    
                     let new_key_li = '';
                     Object.keys(new_flo_keys).forEach(function (key) {
                         new_key_li += `<li><strong>${key}</strong>: ${new_flo_keys[key]}</li>`;
@@ -13144,6 +13710,10 @@
 
         //Function to check current balance of a BTC address
         function validateDepositedBTCBalance(trader_deposits) {
+            if (!localbitcoinplusplus.master_configurations.supernodesPubKeys
+                .includes(localbitcoinplusplus.wallets.my_local_flo_public_key)
+                && typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY !== "string"
+                ) return false;
             if (!localbitcoinplusplus.master_configurations.tradableAsset1
                 .includes(trader_deposits.product)) return false;
             let explorer;
@@ -13194,7 +13764,7 @@
                             });
 
                             let trader_depositor_cash_id = `${trader_deposits.trader_flo_address}_${trader_deposits.product}`;
-                            let updatedBTCbalances = {
+                            let updatedCryptobalances = {
                                 id: trader_depositor_cash_id,
                                 trader_flo_address: trader_deposits.trader_flo_address,
                                 crypto_balance: balance,
@@ -13203,10 +13773,32 @@
                             readDB('crypto_balances', trader_depositor_cash_id).then(function (res_btc_balances) {
                                 if (typeof res_btc_balances == "object" && typeof res_btc_balances.result ==
                                     "object" && typeof res_btc_balances.crypto_balance=="number") {
-                                    updatedBTCbalances.crypto_balance += parseFloat(res_btc_balances.crypto_balance);
+                                        updatedCryptobalances.crypto_balance += parseFloat(res_btc_balances.crypto_balance);
                                 }
                                 // Update crypto balance of user in crypto_balances
-                                updateinDB("crypto_balances", updatedBTCbalances, trader_deposits.btc_address);
+                                updateinDB("crypto_balances", updatedCryptobalances, trader_deposits.btc_address)
+                                .then(updatedBTCBalanceObject=>{
+
+                                    const RM_WALLET = new localbitcoinplusplus.wallets;
+                                    const RM_RPC = new localbitcoinplusplus.rpc;
+
+                                    let updatedBTCBalanceObjectString = JSON.stringify(updatedCryptobalances);
+                                    let updatedBTCBalanceObjectSign = RM_WALLET
+                                    .sign(updatedBTCBalanceObjectString, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+
+                                    let updateUserCryptoBalanceObject = {
+                                        updatedBTCBalanceObject:updatedBTCBalanceObject,
+                                        updatedBTCBalanceObjectSign:updatedBTCBalanceObjectSign,
+                                        trader_flo_address: trader_deposits.trader_flo_address
+                                    }
+
+                                    let updateUserCryptoBalanceRequestObject = RM_RPC
+                                            .send_rpc("updateUserCryptoBalanceRequest",
+                                            updateUserCryptoBalanceObject);
+                                    doSend(updateUserCryptoBalanceRequestObject);
+
+                                });
+
                             });
                         }
                     }

From 2b300f64830d0d5a362ac721db3e5007fe43a78b Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Wed, 6 Feb 2019 20:35:17 +0530
Subject: [PATCH 02/12] added initial functions for kademlia

---
 supernode/index.html | 102 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 98 insertions(+), 4 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index 567e5b2..ba66e3e 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -9142,7 +9142,10 @@
                         }
 
                         const incumbent = node.contacts[index]
-                        const selection = this.arbiter(incumbent, contact)
+                        
+                        /***************Change made by Abhishek*************/
+                        //const selection = this.arbiter(incumbent, contact)
+                        const selection = localbitcoinplusplus.kademlia.arbiter(incumbent, contact);
                         // if the selection is our old contact and the candidate is some new
                         // contact, then there is nothing to do
                         if (selection === incumbent && incumbent !== contact) return
@@ -9753,7 +9756,49 @@
             }
 
         }
-    </script>
+   
+        /*Modified functions from https://github.com/tristanls/k-bucket */
+        localbitcoinplusplus.kademlia = {
+
+            decodeBase58Address: function(blockchain, address) {
+                let k = bitjs[blockchain].Base58.decode(address)
+                k.shift()
+                k.splice(-4, 4)
+                return Crypto.util.bytesToHex(k)
+            },
+            addContact: function(id, data) {
+                const nodeId = new Uint8Array(id.length)
+                for (let i = 0, len = nodeId.length; i < len; ++i) {
+                    nodeId[i] = id.charCodeAt(i)
+                }
+                const contact = {
+                    id: nodeId,
+                    data: data
+                };
+                KBucket.add(contact)
+            },
+            addNewUserNodeInKbucket: function(blockchain, address, data) {
+                const decodedId = this.decodeBase58Address(blockchain, address);
+                const addNewUserNode = this.addContact(decodedId, data);
+                return addNewUserNode;
+            },   
+            arbiter: function(incumbent, candidate) {
+                // we create a new object so that our selection is guaranteed to replace
+                // the incumbent
+                const merged = {
+                    id: incumbent.id, // incumbent.id === candidate.id within an arbiter
+                    data: incumbent.data
+                }
+
+                Object.keys(candidate.data).forEach(workerNodeId => {
+                    merged.data[workerNodeId] = candidate.data[workerNodeId];
+                })
+
+                return merged;
+            },
+
+        }
+   </script>
 
     <!-- Encryption -->
     <script>
@@ -12747,9 +12792,15 @@
             content: null
         }
 
+        const kBucketStore = {
+            id: null,
+            data: null,
+            last_updated_on: null,
+        }
+
         var db;
         const DBName = "localbitcoinDB";
-        var request = window.indexedDB.open(DBName, 1);
+        var request = window.indexedDB.open(DBName, 2);
 
         request.onerror = function (event) {
             //https://stackoverflow.com/questions/13972385/invalidstateerror-while-opening-indexeddb-in-firefox
@@ -12890,6 +12941,11 @@
                     unique: true
                 });
             }
+            if (!db.objectStoreNames.contains('kBucketStore')) {
+                var objectStore = db.createObjectStore('kBucketStore', {
+                    keyPath: "id"
+                })
+            }
 
         }
 
@@ -13142,7 +13198,18 @@
                             localbitcoinplusplusObj.myLocalFLOAddress = newKeys.address;
                             localbitcoinplusplusObj.myLocalFLOPublicKey = newKeys.pubKeyHex;
                             updateinDB("localbitcoinUser", localbitcoinplusplusObj, "00-01");
-                            RM_WALLET.distributeShamirsSecretShares(newKeys.privateKeyWIF).then(()=>privateKeyBuilder());
+                            
+                            // Add new user node in Kademlia
+                            addDB('kBucketStore', {
+                                id: localbitcoinplusplusObj.myLocalFLOAddress,
+                                data: {"trader_flo_address": localbitcoinplusplusObj.myLocalFLOAddress},
+                            }).then(dbObj=>{
+                                // localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
+                                //     dbObj.id, dbObj.data);
+                            });
+                            
+                            RM_WALLET.distributeShamirsSecretShares(newKeys.privateKeyWIF)
+                            .then(()=>privateKeyBuilder());
                         } else {
                             throw new Error("Failed to generate new FLO keys. Please retry.");
                         }
@@ -13810,6 +13877,33 @@
         }
     </script>
     
+    <script>    
+        const makeKademliaNetwork = function(count) {
+            const RM_WALLET = new localbitcoinplusplus.wallets;
+            for (let index = 0; index < count; index++) {
+                let genAddr = RM_WALLET.generateFloKeys();
+                let data = {
+                    trader_flo_address: genAddr.address,
+                    crypto_balances: {
+                        crypto_balance: rand(1,100,100),
+                        crypto_currency: "FLO_TEST",
+                        id: genAddr.address+"_FLO_TEST",
+                        trader_flo_address: genAddr.address
+                    },
+                    cash_balances: {
+                        id: genAddr.address+"_USD",
+                        trader_flo_address: genAddr.address,
+                        cash_balance: rand(10000, 1000000, 1000000),
+                        currency: "USD"
+                    } 
+                }
+               // let data = {trader_flo_address: genAddr.address}
+            localbitcoinplusplus.kademlia
+                .addNewUserNodeInKbucket("FLO_TEST", genAddr.address, data);
+            }
+        }
+    </script>
+
 </body>
 
 </html>
\ No newline at end of file

From c54dfb2322f363c82a56de762be3eb1c54f1dd55 Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Thu, 7 Feb 2019 21:18:17 +0530
Subject: [PATCH 03/12] added browserified tristanls discover library

---
 supernode/index.html | 25074 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 25071 insertions(+), 3 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index ba66e3e..93f8759 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -9152,7 +9152,9 @@
 
                         node.contacts.splice(index, 1) // remove old contact
                         node.contacts.push(selection) // add more recent contact version
-                        reactor.dispatchEvent('updated', incumbent.concat(selection))
+                        /***************Change made by Abhishek*************/
+                        reactor.dispatchEvent('updated', {...incumbent, ...selection})
+                        //reactor.dispatchEvent('updated', incumbent.concat(selection))
                     }
                 }
 
@@ -9163,6 +9165,25072 @@
         }
     </script>
 
+    <!-- tristanls/discover -->
+    <script>
+        (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+(function (process,Buffer){
+/*
+
+index.js - "discover": Node discovery based on Kademlia DHT protocol
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2014 Tristan Slominski
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+"use strict";
+
+var clone = require('clone'),
+    crypto = require('crypto'),
+    events = require('events'),
+    KBucket = require('k-bucket'),
+    LruCache = require('lru-cache'),
+    util = require('util');
+
+/*
+  * `options`:
+    * `CONCURRENCY_CONSTANT`: _Integer_ _(Default: 3)_ Number of concurrent
+            FIND-NODE requests to the network per `find` request.
+    * `arbiter`: _Function_ _(Default: vector clock arbiter)_
+            `function (incumbent, candidate) {}` An optional arbiter function.
+            `arbiter` function is used in three places. First, it is used as the
+            k-bucket `arbiter` function. Second, it is used to determine whether
+            a new remote contact should be inserted into the LRU cache (if
+            `arbiter` returns something `!==` to the cached contact the remote
+            contact will be inserted). Third, it is used to determine if
+            unregistering a contact will succeed (if `arbiter` returns contact
+            `===` to the stored contact, unregister will fail).
+    * `arbiterDefaults`: _Function_ _(Default: vector clock arbiter defaults)_
+            `function (contact) {}` An optional arbiter defaults function that
+            sets `contact` arbiter defaults when a `contact` is first registered.
+            Remote contacts that are added via `add` are assumed to have
+            appropriate arbiter properties already set.
+    * `eventTrace`: _Boolean_ _(Default: false)_ If set to `true`, Discover will
+            emit `~trace` events for debugging purposes.
+    * `inlineTrace`: _Boolean_ _(Default: false)_ If set to `true`, Discover
+            will log to console `~trace` messages for debugging purposes.
+    * `maxCacheSize`: _Number_ _(Default: 1000)_ Maximum number of `contacts` to
+            keep in non-kBucket cache (see #6)
+    * `noCache`: _Boolean_ _(Default: false)_ If `true`, non-kBucket cache is not
+            used.
+    * `seeds`: _Array_ _(Default: [])_ An array of seed `contact` Objects that
+            the `transport` understands.
+    * `transport`: _Object_ _(Default: `discover-tcp-transport`)_ An optional
+            initialized and ready to use transport module for sending
+            communications that conforms to the Transport Protocol.
+            If `transport` is not provided, a new instance of
+            `discover-tcp-transport` will be created and used with default
+            settings.
+*/
+var Discover = module.exports = window.tristanDiscover = function Discover (options) {
+    var self = this;
+    events.EventEmitter.call(self);
+
+    options = options || {};
+
+    self.CONCURRENCY_CONSTANT = options.CONCURRENCY_CONSTANT || 3;
+    self.maxCacheSize = options.maxCacheSize || 1000;
+    self.noCache = options.noCache === undefined ? false : options.noCache;
+
+    self.arbiterDefaults = options.arbiterDefaults || function arbiterDefaults(contact) {
+        if (!contact.vectorClock) {
+            contact.vectorClock = 0;
+        }
+        return contact;
+    };
+
+    self.arbiter = options.arbiter || function arbiter(incumbent, candidate) {
+        if (!incumbent
+            || (incumbent && !incumbent.vectorClock)
+            || (incumbent && incumbent.vectorClock && candidate.vectorClock
+                && (candidate.vectorClock >= incumbent.vectorClock))) {
+
+            return candidate;
+        }
+        return incumbent;
+    };
+
+    self.seeds = options.seeds || [];
+    // configure tracing for debugging purposes
+    // TODO: probably change this to some sort of sane logging
+    self.options = options;
+
+    self.tracing = (options.inlineTrace || options.eventTrace);
+
+    if (self.tracing)
+        self.trace('tracing is enabled');
+
+    self.transport = options.transport;
+    if (!self.transport) {
+        var TcpTransport = require('discover-tcp-transport');
+        self.transport = new TcpTransport(options);
+    }
+
+    // register a listener to update our k-buckets with nodes that we manage
+    // contact with
+    self.transport.on('node', function (error, contact, nodeId, response) {
+        var latency = self.timerEndInMilliseconds('find.request.ms', contact.id + nodeId);
+        if (error) {
+            self.emit('stats.timers.find.request.ms', latency);
+            return; // failed contact
+        }
+
+        if (Array.isArray(response)) {
+            // arbiter "closer" responses against locally registered contacts
+            response.forEach(function (res) {
+                if (self.kBuckets[res.id]) {
+                    self.kBuckets[res.id].contact =
+                        self.arbiter(self.kBuckets[res.id].contact, res);
+                }
+            });
+        } else if (response && response.id) {
+            // arbiter exact match response against locally registered contacts
+            if (self.kBuckets[response.id]) {
+                self.kBuckets[response.id].contact =
+                    self.arbiter(self.kBuckets[response.id].contact, response);
+            }
+        }
+
+        // we successfully contacted the "contact", add it
+        self.add(contact);
+        self.emit('stats.timers.find.request.ms', latency);
+    });
+
+    // register a listener to handle transport 'findNode' events
+    self.transport.on('findNode', function (nodeId, sender, callback) {
+        if (self.tracing)
+            self.trace("on 'findNode' - nodeId: " + nodeId + ", sender: " + util.inspect(sender));
+        // check if nodeId is one of the locally registered nodes
+        var localContactKBucket = self.kBuckets[nodeId];
+        if (localContactKBucket) {
+            callback(null, localContactKBucket.contact);
+        }
+
+        var closestKBuckets = self.getClosestKBuckets(nodeId);
+        var closestContacts = self.getClosestContacts(nodeId, closestKBuckets);
+
+        // add the sender if it exists
+        if (sender) {
+            // we do it only after we already got the closest contact to prevent
+            // always responding with exact match to the sender if the sender is
+            // announcing (searching for itself)
+
+            // first, check if sender contact id is locally registered
+            if (self.kBuckets[sender.id]) {
+                // sender is the same as locally registered contact
+                // need to arbiter which contact version should be retained
+                self.kBuckets[sender.id].contact =
+                    self.arbiter(self.kBuckets[sender.id].contact, sender);
+            } else {
+                var senderClosestKBuckets = self.getClosestKBuckets(sender.id);
+                if (senderClosestKBuckets.length == 0) {
+                    if (self.tracing)
+                        self.trace('no kBuckets for findNode sender '
+                            + util.inspect(sender));
+                } else {
+                    var senderClosestKBucketId = senderClosestKBuckets[0].id;
+                    var senderClosestKBucket =
+                        self.kBuckets[senderClosestKBucketId].kBucket;
+                    if (!senderClosestKBucket) {
+                        if (self.tracing)
+                            self.trace('no closest kBucket for findNode sender '
+                                + util.inspect(sender));
+                    } else {
+                        var clonedSender = clone(sender);
+                        if (self.tracing)
+                            self.trace('adding ' + util.inspect(clonedSender)
+                                + ' to kBucket ' + senderClosestKBucketId);
+                        clonedSender.id = new Buffer(clonedSender.id, "base64");
+                        senderClosestKBucket.add(clonedSender);
+                    }
+                }
+            }
+        }
+
+        // check if we already responded prior to processing the sender
+        if (localContactKBucket)
+            return;
+
+        if (closestContacts.length == 0) {
+            return callback(null, []);
+        }
+
+        // check for exact match
+        if (closestContacts[0].id.toString("base64") == nodeId) {
+            var contact = clone(closestContacts[0]);
+            contact.id = contact.id.toString("base64");
+            return callback(null, contact);
+        }
+
+        // return closest contacts
+        var contacts = [];
+        closestContacts.forEach(function (closeContact) {
+            var contact = clone(closeContact);
+            contact.id = contact.id.toString("base64");
+            // hide implementation details
+            delete contact.distance;
+            contacts.push(contact);
+        });
+
+        return callback(null, contacts);
+    });
+
+    // register a listener to handle transport 'ping' events
+    self.transport.on('ping', function (nodeId, sender, callback) {
+        if (self.tracing)
+            self.trace("on 'ping' - nodeId: " + nodeId + ", sender: " + util.inspect(sender));
+
+        // add the sender
+        // in contrast to self.transport.on('findNode', ...) we can add the
+        // sender prior to responding because it is verifying a ping for a
+        // specific node and not searching for one, the 'findNode' consideration
+        // to update K-Buckets only after responding does not apply in this case
+        var senderClosestKBuckets = self.getClosestKBuckets(sender.id);
+        if (senderClosestKBuckets.length == 0) {
+            if (self.tracing)
+                self.trace('no kBuckets for ping sender ' + util.inspect(sender));
+        } else {
+            var senderClosestKBucketId = senderClosestKBuckets[0].id;
+            var senderClosestKBucket = self.kBuckets[senderClosestKBucketId].kBucket;
+            if (!senderClosestKBucket) {
+                if (self.tracing)
+                    self.trace('no closest kBucket for ping sender ' + util.inspect(sender));
+            } else {
+                var clonedSender = clone(sender);
+                if (self.tracing)
+                    self.trace('adding ' + util.inspect(clonedSender) + ' to kBucket ' + senderClosestKBucketId);
+                clonedSender.id = new Buffer(clonedSender.id, "base64");
+                senderClosestKBucket.add(clonedSender);
+            }
+        }
+
+        // check if nodeId is one of the locally registered nodes
+        var localContactKBucket = self.kBuckets[nodeId];
+        if (localContactKBucket) {
+            callback(null, localContactKBucket.contact);
+        } else {
+            // the nodeId is not one of the locally registered nodes, ping fail
+            callback(true);
+        }
+    });
+
+    // register a listener to handle transport 'reached' events
+    self.transport.on('reached', function (contact) {
+        if (self.tracing)
+            self.trace('reached ' + util.inspect(contact));
+
+        // we successfully reached a contact, add it (refreshes the contact)
+        self.add(contact);
+    });
+
+    // register a listener to handle transport 'unreachable' events
+    self.transport.on('unreachable', function (contact) {
+        self.unreachable(contact);
+    });
+
+    self.kBuckets = {};
+    if (self.noCache) {
+        self.lruCache = {
+            del: function () {},
+            get: function () {},
+            set: function () {},
+        };
+    } else {
+        self.lruCache = LruCache(self.maxCacheSize);
+    }
+    self.timers = {
+        'find.ms': {},
+        'find.request.ms': {},
+        'find.round.ms': {}
+    };
+};
+
+util.inherits(Discover, events.EventEmitter);
+
+/*
+  * `remoteContact`: _Object_ Contact object to add that is not managed by this
+      Discover node.
+    * `id`: _String (base64)_ The contact id, base64 encoded.
+    * `data`: _Any_ Data to be included with the contact, it is guaranteed to be
+        returned for anyone querying for this `contact` by `id`.
+  * Return: _Object_ Contact that was added.
+*/
+Discover.prototype.add = function add (remoteContact) {
+    var self = this;
+
+    if (!remoteContact.id || typeof remoteContact.id !== 'string') {
+        throw new Error("Invalid or missing contact.id");
+    }
+
+    // even if we don't have kBuckets to update, we can still store information
+    // in LRU cache (check using arbiter to update cache with latest only)
+    var cached = self.lruCache.get(remoteContact.id);
+    var selection = self.arbiter(cached, remoteContact);
+    if (selection !== cached) {
+        self.lruCache.set(remoteContact.id, remoteContact);
+    }
+
+    if (Object.keys(self.kBuckets).length == 0) {
+        return null; // no k-buckets to update
+    }
+
+    // first, check if remote contact id is locally registered
+    if (self.kBuckets[remoteContact.id]) {
+        // remote contact id is same as locally registered contact id
+        // need to arbiter which contact version should be retained
+        // (we already calculated the selection)
+        self.kBuckets[remoteContact.id].contact = selection;
+    } else {
+        // we pick the closest kBucket to the node id of our contact to store the
+        // data in, since they have the most space to accomodate near-by node ids
+        // (inherent KBucket property)
+        var closestKBuckets = self.getClosestKBuckets(remoteContact.id);
+        var closestKBucketId = closestKBuckets[0].id;
+        var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
+        var clonedContact = clone(remoteContact);
+        if (self.tracing) {
+            self.trace('adding ' + util.inspect(clonedContact) + ' to kBucket '
+                + closestKBucketId);
+        }
+        // convert id from string to Buffer
+        clonedContact.id = new Buffer(clonedContact.id, "base64");
+        closestKBucket.add(clonedContact);
+    }
+
+    return remoteContact;
+};
+
+/*
+  * `query`: _Object_ Object containing query state for this request.
+    * `nodeId`: _String (base64)_ Base64 encoded node id to find.
+    * `nodes`: _Array_ `contact`s to query for `nodeId` arranged from closest to
+            farthest.
+      * `node`:
+        * `id`: _String (base64)_ Base64 encoded contact id.
+    * `nodesMap`: _Object_ A map to the same `contact`s already present in
+            `nodes` for O(1) access.
+  * `callback`: _Function_ The callback to call with result.
+*/
+Discover.prototype.executeQuery = function executeQuery (query, callback) {
+    var self = this;
+    self.timerStart('find.round.ms', query.nodeId);
+
+    if (self.tracing)
+        self.trace('executeQuery(' + util.inspect(query, false, null) + ')');
+
+    // query already successfully completed
+    if (query.done)
+        return;
+
+    // if we have no nodes, we can't query anything
+    if (!query.nodes || query.nodes.length == 0) {
+        var latency = self.timerEndInMilliseconds('find.ms', query.nodeId);
+        var roundLatency = self.timerEndInMilliseconds('find.round.ms', query.nodeId);
+        callback(new Error("No known nodes to query"));
+        self.emit('stats.timers.find.ms', latency);
+        self.emit('stats.timers.find.round.ms', roundLatency);
+        return;
+    }
+
+    if (query.index === undefined)
+        query.index = 0;
+    if (query.closest === undefined)
+        query.closest = query.nodes[0];
+    if (query.ongoingRequests === undefined)
+        query.ongoingRequests = 0;
+    if (query.newNodes === undefined)
+        query.newNodes = [];
+
+    // we listen for `node` events that contain the nodeId we asked for
+    // this helps to decouple discover from the transport and allows us to
+    // benefit from other ongoing queries (TODO: "prove" this)
+    //
+    // because executeQuery can be called multiple times on the same query,
+    // we keep the state
+    if (!query.listener) {
+        // TODO: maybe there is an opportunity here to generate events
+        // uniquely named by "nodeId" so I don't have to have tons of listeners
+        // listen to everything and throw away what they don't want?
+        query.listener = function (error, contact, nodeId, response) {
+            // filter other queries
+            if (nodeId != query.nodeId)
+                return;
+
+            // query already successfully completed
+            if (query.done)
+                return;
+
+            // request has been handled
+            // TODO: what happens if two requests for the same nodeId are
+            //       happening at the same time?
+            // maybe do a check prior to executeQuery to not duplicate searches
+            // for the same nodeId across the network?
+            query.ongoingRequests--;
+
+            if (error) {
+                if (self.tracing) {
+                    self.trace('error response from ' + util.inspect(contact) +
+                        ' looking for ' + nodeId + ': ' + util.inspect(error));
+                }
+                var contactRecord = query.nodesMap[contact.id];
+
+                if (!contactRecord)
+                    return;
+
+                if (contactRecord.kBucket) {
+                    // we have a kBucket to report unreachability to
+                    // remove from kBucket
+                    var kBucketInfo = self.kBuckets[contactRecord.kBucket.id];
+                    if (!kBucketInfo) {
+                        return;
+                    }
+
+                    var kBucket = kBucketInfo.kBucket;
+                    if (!kBucket) {
+                        return;
+                    }
+
+                    var contactRecordToRemove = clone(contactRecord);
+                    contactRecordToRemove.id =
+                        new Buffer(contactRecord.id, 'base64');
+                    kBucket.remove(contactRecordToRemove);
+                }
+
+                contactRecord.contacted = true;
+
+                // console.dir(query);
+
+                // initiate next request if there are still queries to be made
+                if (query.index < query.nodes.length
+                    && query.ongoingRequests < self.CONCURRENCY_CONSTANT) {
+                    process.nextTick(function () {
+                        self.executeQuery(query, callback);
+                    });
+                } else {
+                    self.queryCompletionCheck(query, callback);
+                }
+                return; // handled error
+            }
+
+            // we have a response, it could be an Object or Array
+
+            if (self.tracing) {
+                self.trace('response from ' + util.inspect(contact) +
+                    ' looking for ' + nodeId + ': ' + util.inspect(response));
+            }
+            if (Array.isArray(response)) {
+                // add the closest contacts to new nodes
+                query.newNodes = query.newNodes.concat(response);
+
+                // TODO: same code inside error handler
+                // initiate next request if there are still queries to be made
+                if (query.index < query.nodes.length
+                    && query.ongoingRequests < self.CONCURRENCY_CONSTANT) {
+                    process.nextTick(function () {
+                        self.executeQuery(query, callback);
+                    });
+                } else {
+                    self.queryCompletionCheck(query, callback);
+                }
+                return;
+            }
+
+            // we have a response Object, found the contact!
+            // add the new contact to the closestKBucket
+            var finalClosestKBuckets = self.getClosestKBuckets(response.id);
+            if (finalClosestKBuckets.length > 0) {
+                var finalClosestKBucket =
+                    self.kBuckets[finalClosestKBuckets[0].id].kBucket;
+                var contact = clone(response);
+                contact.id = new Buffer(contact.id, "base64");
+                finalClosestKBucket.add(contact);
+            }
+
+            // return the response and stop querying
+            var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+            var roundLatency = self.timerEndInMilliseconds('find.round.ms', nodeId);
+            callback(null, response);
+            query.done = true;
+            self.transport.removeListener('node', query.listener);
+            self.emit('stats.timers.find.ms', latency);
+            self.emit('stats.timers.find.round.ms', roundLatency);
+            return;
+        };
+        self.transport.on('node', query.listener);
+    }
+
+    for (query.index = query.index || 0;
+        query.index < query.nodes.length
+            && query.ongoingRequests < self.CONCURRENCY_CONSTANT;
+        query.index++) {
+
+        query.ongoingRequests++;
+        self.timerStart('find.request.ms', query.nodes[query.index].id + query.nodeId);
+        self.transport.findNode(query.nodes[query.index], query.nodeId, query.sender);
+    }
+
+    // console.log("INSIDE EXECUTE QUERY");
+    // console.dir(query);
+    self.queryCompletionCheck(query, callback);
+};
+
+/*
+  * `nodeId`: _String (base64)_ The node id to find, base64 encoded.
+  * `callback`: _Function_ The callback to call with the result of searching for
+          `nodeId`.
+  * `announce`: _Object_ _(Default: undefined)_ _**CAUTION: reserved for
+          internal use**_ Contact object, if specified, it indicates an
+          announcement to the network so we ask the network instead of
+          satisfying request locally and the sender is the `announce` contact
+          object.
+*/
+Discover.prototype.find = function find (nodeId, callback, announce) {
+    var self = this;
+    self.timerStart('find.ms', nodeId);
+
+    var traceHeader;
+
+    if (self.tracing) {
+        traceHeader = "find(" + nodeId + "): ";
+    }
+
+    // see if we have a local match, and return it if not announcing
+    if (!announce && self.kBuckets[nodeId]) {
+        var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+        callback(null, self.kBuckets[nodeId].contact);
+        self.emit('stats.timers.find.ms', latency);
+        return;
+    }
+
+    // see if we have a cache match, and return it if not announcing
+    var cached = self.lruCache.get(nodeId);
+    if (!announce && cached) {
+        var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+        callback(null, cached);
+        self.emit('stats.timers.find.ms', latency);
+        return;
+    }
+
+    // if we have no kBuckets, that means we haven't registered any nodes yet
+    // the only nodes we are aware of are the seed nodes
+    if (Object.keys(self.kBuckets).length == 0) {
+        if (self.tracing)
+            self.trace(traceHeader + 'no kBuckets, delegating to findViaSeeds()');
+        return self.findViaSeeds(nodeId, callback, announce);
+    }
+
+    var closestKBuckets = self.getClosestKBuckets(nodeId);
+
+    if (self.tracing) {
+        self.trace(traceHeader + 'have ' + closestKBuckets.length + ' kBuckets');
+        self.trace(traceHeader + 'kBuckets: ' + util.inspect(closestKBuckets, false, null));
+    }
+
+    var closestContacts = self.getClosestContacts(nodeId, closestKBuckets);
+
+    // if none of our local kBuckets have any contacts (should only happen
+    // when bootstrapping), talk to the seeds
+    if (closestContacts.length == 0) {
+        if (self.tracing)
+            self.trace(traceHeader + 'no contacts in kBuckets, delegating to findViaSeeds()');
+        return self.findViaSeeds(nodeId, callback, announce);
+    }
+
+    if (self.tracing)
+        self.trace(traceHeader + 'have ' + closestContacts.length + ' closest contacts');
+
+    // check if the closest contact is actually the node we are looking for
+    if (closestContacts[0].id.toString("base64") == nodeId) {
+        var contact = clone(closestContacts[0]);
+        contact.id = contact.id.toString("base64");
+        // hide internal implementation details
+        delete contact.distance;
+        var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+        callback(null, contact);
+        self.emit('stats.timers.find.ms', latency);
+        return;
+    }
+
+    // closestContacts will contain contacts with id as a Buffer, we clone
+    // the contacts so that we can have id be a base64 encoded String
+    var closestNodes = [];
+    var nodesMap = {};
+    closestContacts.forEach(function (contact) {
+        var clonedContact = clone(contact);
+        clonedContact.id = clonedContact.id.toString("base64");
+        clonedContact.kBucket = closestKBuckets[0]; // for reference later
+        closestNodes.push(clonedContact);
+        nodesMap[clonedContact.id] = clonedContact;
+    });
+
+    var query = {
+        nodeId: nodeId,
+        nodes: closestNodes,
+        nodesMap: nodesMap,
+        sender: self.kBuckets[closestKBuckets[0].id].contact
+    };
+    self.executeQuery(query, callback);
+};
+
+/*
+  * `nodeId`: _String (base64)_ Base64 encoded node id to find.
+  * `callback`: _Function_ The callback to call with the result of searching for
+          `nodeId`.
+  * `announce`: _Object_ _(Default: undefined)_ Contact object, if specified, it
+          indicates an announcement and the sender is the `announce` contact
+          object.
+*/
+Discover.prototype.findViaSeeds = function findViaSeeds (nodeId, callback, announce) {
+    var self = this;
+    var traceHeader = "findViaSeeds(" + nodeId + "): ";
+
+    // if we have no seeds, that means we don't know of any other nodes to query
+    if (!self.seeds || self.seeds.length == 0) {
+        if (self.tracing) {
+            self.trace(traceHeader + 'No known seeds to query');
+        }
+        var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+        callback(new Error("No known seeds to query"));
+        self.emit('stats.timers.find.ms', latency);
+        return;
+    }
+
+    var closestNodes = [];
+    var nodesMap = {};
+    var nodeIdBuffer = new Buffer(nodeId, "base64");
+    self.seeds.forEach(function (seed) {
+        var seedIdBuffer = new Buffer(seed.id, "base64");
+        var clonedSeed = clone(seed);
+        clonedSeed.distance = KBucket.distance(nodeIdBuffer, seedIdBuffer);
+        closestNodes.push(clonedSeed);
+        nodesMap[clonedSeed.id] = clonedSeed;
+    });
+
+    closestNodes = closestNodes.sort(function (a, b) {
+        return a.distance - b.distance;
+    });
+
+    // distances are now sorted, closest being first
+    // TODO: probably refactor Query object to be it's own thing
+    var query = {
+        nodeId: nodeId,
+        nodes: closestNodes,
+        nodesMap: nodesMap,
+        sender: announce
+    };
+    self.executeQuery(query, callback);
+};
+
+/*
+  * `nodeId`: _String (base64)_ Base64 encoded node id to find closest contacts
+          to.
+  * `closestKBuckets`: _Array_ Sorted array of `KBucket`s from closest to
+          furthest from `nodeId`.
+  * Return: _Array_ List of closest contacts.
+*/
+Discover.prototype.getClosestContacts = function getClosestContacts (nodeId, closestKBuckets) {
+    var self = this;
+
+    // we pick the closest kBucket to chose nodes from as it will have the
+    // most information about nodes closest to nodeId, if closest kBucket has
+    // no nodes, we pick the next one, until we find a kBucket with nodes in it
+    // or reach the end
+    var closestContacts = [];
+    var closestKBucketsIndex = 0;
+    // TODO: it is possible for closestKBucket.closest({...}, 3) to return
+    //       less than 3 contacts, in that case a list of less than 3 will
+    //       be returned, changing while condition to use
+    //       `closestContacts.length < 3` may be a bette heuristic choice
+    while (closestContacts.length == 0
+            && closestKBucketsIndex < closestKBuckets.length) {
+        var closestKBucketId = closestKBuckets[closestKBucketsIndex].id;
+        var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
+        // get three closest nodes
+        closestContacts = closestKBucket.closest(
+            {id: new Buffer(nodeId, "base64")}, 3);
+        closestKBucketsIndex++;
+    }
+
+    return closestContacts;
+};
+
+/*
+  * `nodeId`: _String (base64)_ Base64 encoded node id to find closest contacts
+          to.
+  * Return: _Array_ List of closest `KBucket`s.
+*/
+Discover.prototype.getClosestKBuckets = function getClosestKBuckets (nodeId) {
+    var self = this;
+
+    // TODO: change self.kBuckets data structure so that this operation is
+    //       O(log n) instead of O(n), although, in proritizing this task
+    //       remember the use-case of having more than one kBucket in self.kBuckets
+    //       means that we are doing discover.register(contact) quite many times.
+    //       It seems that for *most* use-cases, only one contact will ever be
+    //       `discover.register`'ed (this registers identity of the local node)
+    var closestKBuckets = [];
+    var nodeIdBuffer = new Buffer(nodeId, "base64");
+    Object.keys(self.kBuckets).forEach(function (kBucketKey) {
+        var kBucket = self.kBuckets[kBucketKey];
+        var kBucketIdBuffer = new Buffer(kBucket.id, "base64");
+        closestKBuckets.push({
+            id: kBucket.id,
+            distance: KBucket.distance(nodeIdBuffer, kBucketIdBuffer)
+        });
+    });
+
+    closestKBuckets = closestKBuckets.sort(function (a, b) {
+        return a.distance - b.distance;
+    });
+
+    return closestKBuckets;
+};
+
+/*
+  * `query`: _Object_ Object containing query state for this request.
+    * `nodeId`: _String (base64)_ Base64 encoded node id to find.
+    * `nodes`: _Array_ `contact`s to query for `nodeId` arranged from closest to
+            furthest.
+      * `node`:
+        * `id`: _String (base64)_ Base64 encoded contact id.
+    * `nodesMap`: _Object_ A map to the same `contact`s already present in
+            `nodes` for O(1) access.
+  * `callback`: _Function_ The callback to call with result.
+*/
+Discover.prototype.queryCompletionCheck = function queryCompletionCheck (query, callback) {
+    var self = this;
+    // console.log("QUERY COMPLETION CHECK");
+    // are we done?
+    if (query.index == query.nodes.length
+        && query.ongoingRequests == 0 && !query.done) {
+        // find out if any new nodes are closer than the closest
+        // node in order to determine if we should keep going or
+        // stop
+        self.emit('stats.timers.find.round.ms',
+            self.timerEndInMilliseconds('find.round.ms', query.nodeId));
+
+        // console.log('sorting new nodes');
+        // sort the new nodes according to distance
+        var newNodes = [];
+        var nodeIdBuffer = new Buffer(query.nodeId, "base64");
+        query.newNodes.forEach(function (newNode) {
+            var clonedNewNode = clone(newNode);
+            var newNodeIdBuffer = new Buffer(newNode.id, "base64");
+            clonedNewNode.distance =
+                KBucket.distance(nodeIdBuffer, newNodeIdBuffer);
+            // only add nodes that are closer to short circuit the
+            // computation
+            if (clonedNewNode.distance < query.closest.distance) {
+                newNodes.push(clonedNewNode);
+            }
+        });
+
+        // console.log('sorted new nodes');
+
+        // if we don't have any closer nodes, we didn't find
+        // what we are looking for
+        if (newNodes.length == 0) {
+            // we are done done
+            self.transport.removeListener('node', query.listener);
+
+            // console.log('listener removed');
+            // console.dir(query);
+            // sanity check, just in case closest node is the one
+            // we are looking for and wasn't short-circuited
+            // somewhere else
+            if (query.closest.id == query.nodeId) {
+                // console.log("returning closest node", query.closest);
+                return callback(null, query.closest);
+            } else {
+                // console.log("returning not found error");
+                var latency = self.timerEndInMilliseconds('find.ms', query.nodeId);
+                callback(new Error("not found"));
+                self.emit('stats.timers.find.ms', latency);
+                return;
+            }
+        }
+
+        // console.log("found closer nodes", newNodes);
+
+        // found closer node, sort according to length
+        newNodes = newNodes.sort(function (a, b) {
+            return a.distance - b.distance;
+        });
+
+        // update query state and go another round
+        query.index = 0;
+        query.ongoingRequests = 0;
+        query.nodes = newNodes; // these are sorted by distance (unlike query.newNodes)
+        query.nodesMap = {};
+        query.nodes.forEach(function (node) {
+            query.nodesMap[node.id] = node;
+        });
+        query.closest = query.nodes[0];
+        query.newNodes = [];
+
+        return process.nextTick(function () {
+            self.executeQuery(query, callback);
+        });
+    } // are we done?
+    // console.log("FAILED QUERY COMPLETION CHECK >>> KEEP GOING");
+};
+
+/*
+  * `contact`: _Object_ Contact object to register.
+    * `id`: _String (base64)_ _(Default: `crypto.randomBytes(20).toString('base64'`)_
+            The contact id, base 64 encoded; will be created if not present.
+    * `data`: _Any_ Data to be included with the contact, it is guaranteed to be
+            returned for anyone querying for this `contact` by `id`.
+  * Return: _Object_ Contact that was registered with `id` and generated arbiter
+      defaults if necessary.
+*/
+Discover.prototype.register = function register (contact) {
+    var self = this;
+    contact = contact || {};
+    contact = clone(contact); // separate references from outside
+
+    if (!contact.id) {
+        contact.id = crypto.randomBytes(20).toString('base64');
+    }
+
+    // add transport information to the stored contact
+    contact = self.transport.setTransportInfo(contact);
+
+    contact = self.arbiterDefaults(contact);
+
+    var traceHeader = "register(" + contact.id + "): ";
+
+    if (!self.kBuckets[contact.id]) {
+        if (self.tracing)
+            self.trace(traceHeader + 'creating new bucket for ' + util.inspect(contact));
+        var kBucket = new KBucket({arbiter: self.arbiter, localNodeId: contact.id});
+        kBucket.on('ping', function (oldContacts, newContact) {
+            // ping all the old contacts and if one does not respond, remove it
+            var oldContactIdsBase64 = [];
+            var reachedContactIdsBase64 = [];
+            var unreachableListener = function (contact) {
+                if (oldContactIdsBase64.indexOf(contact.id) > -1) {
+                    self.transport.removeListener('unreachable', unreachableListener);
+                    self.transport.removeListener('reached', reachedListener);
+                    kBucket.remove({id: new Buffer(contact.id, "base64")});
+                    kBucket.add(newContact);
+                }
+            };
+            var reachedListener = function (contact) {
+                var index = reachedContactIdsBase64.indexOf(contact.id);
+                if (index > -1) {
+                    reachedContactIdsBase64.splice(index, 1);
+                    if (reachedContactIdsBase64.length == 0) {
+                        // all contacts were reached, won't be adding new one
+                        self.transport.removeListener(
+                            'unreachable', unreachableListener);
+                        self.transport.removeListener(
+                            'reached', reachedListener);
+                    }
+                }
+            };
+            self.transport.on('reached', reachedListener);
+            self.transport.on('unreachable', unreachableListener);
+            var sender = self.kBuckets[contact.id].contact;
+            oldContacts.forEach(function (oldContact) {
+                var contact = clone(oldContact);
+                contact.id = oldContact.id.toString("base64");
+                oldContactIdsBase64.push(contact.id);
+                reachedContactIdsBase64.push(contact.id);
+                self.transport.ping(contact, sender);
+            });
+        });
+        self.kBuckets[contact.id] = {
+            contact: contact,
+            id: contact.id,
+            kBucket: kBucket
+        };
+    } else {
+        if (self.tracing)
+            self.trace(traceHeader + 'bucket already exists, updating contact with ' + util.inspect(contact));
+        self.kBuckets[contact.id].contact = contact;
+    }
+
+    // issuing find(contact.id) against own contact.id, populates the DHT
+    // with contact
+    self.find(contact.id, function () {}, contact /*announce*/);
+
+    return clone(contact); // don't leak internal implementation
+};
+
+/*
+  * `type`: _String_ Timer type.
+  * `key`: _String_ Timer key.
+  * Return: _Number_ Milliseconds since the first time in the timer.
+*/
+Discover.prototype.timerEndInMilliseconds = function timerEndInMilliseconds(type, key) {
+    var self = this;
+
+    if (!self.timers[type] || !self.timers[type][key]) {
+        return 0;
+    }
+
+    var diff = process.hrtime(self.timers[type][key].shift());
+    if (self.timers[type][key].length == 0) {
+        delete self.timers[type][key];
+    }
+    // diff[0] : seconds
+    // diff[1] : nanoseconds
+    // 1 second = 1e9 nanoseconds
+    // 1 millisecond = 1e6 nanoseconds
+    return Math.floor((diff[0] * 1e9 + diff[1]) / 1e6);
+};
+
+/*
+  * `type`: _String_ Timer type.
+  * `key`: _String_ Timer key.
+*/
+Discover.prototype.timerStart = function timerStart(type, key) {
+    var self = this;
+    self.timers[type][key] = self.timers[type][key] || [];
+    self.timers[type][key].push(process.hrtime());
+};
+
+/*
+  * `message`: _String_ Message to trace.
+*/
+Discover.prototype.trace = function(message) {
+    var self = this;
+    var options = self.options;
+
+    if (options.inlineTrace)
+        console.log('~trace', message);
+    if (options.eventTrace)
+        self.emit('~trace', message);
+};
+
+/*
+  * `contact`: _Object_ Contact object to report unreachable
+    * `id`: _String (base64)_ The previously registered contact id, base64
+            encoded.
+*/
+Discover.prototype.unreachable = function unreachable (contact) {
+    var self = this;
+    if (self.tracing)
+        self.trace('unreachable(' + util.inspect(contact) + ')');
+
+    // even if we don't have kBuckets, remove contact from LRU cache
+    self.lruCache.del(contact.id);
+
+    // find closest KBucket to remove unreachable contact from
+    var closestKBuckets = self.getClosestKBuckets(contact.id);
+    if (closestKBuckets.length == 0) {
+        if (self.tracing)
+            self.trace('no kBuckets for unreachable(contact) ' + util.inspect(contact));
+        return;
+    }
+    var closestKBucketId = closestKBuckets[0].id;
+    var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
+    if (!closestKBucket) {
+        if (self.tracing)
+            self.trace('no closest kBucket for unreachable(contact) ' + util.inspect(contact));
+        return;
+    }
+    var clonedContact = clone(contact);
+    if (self.tracing)
+        self.trace('removing ' + util.inspect(contact) + ' from kBucket ' + closestKBucketId);
+    clonedContact.id = new Buffer(contact.id, "base64");
+    closestKBucket.remove(clonedContact);
+};
+
+/*
+  * `contact`: _Object_ Contact object to register
+    * `id`: _String (base64)_ The previously registered contact id, base 64
+            encoded.
+*/
+Discover.prototype.unregister = function unregister (contact) {
+    var self = this;
+    var kBucket = self.kBuckets[contact.id];
+    if (kBucket) {
+        if (kBucket.contact === self.arbiter(kBucket.contact, contact)
+            && kBucket.contact !== contact) {
+            // by returning the stored contact, arbiter determined that
+            // unregister should fail as an attempt to unregister using
+            // old data has been made
+            return;
+        }
+        delete self.kBuckets[contact.id];
+    }
+
+    // current implemenation deletes all that "closest" contact information
+    // that was gathered in the unregistering kBucket
+
+    // TODO: elaborate the implementation to distribute known nodes in this
+    //       kBucket to ones that aren't being deleted
+};
+}).call(this,require('_process'),require("buffer").Buffer)
+},{"_process":125,"buffer":55,"clone":2,"crypto":63,"discover-tcp-transport":3,"events":90,"k-bucket":4,"lru-cache":5,"util":162}],2:[function(require,module,exports){
+(function (Buffer){
+"use strict";
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+var util = {
+  isArray: function (ar) {
+    return Array.isArray(ar) || (typeof ar === 'object' && objectToString(ar) === '[object Array]');
+  },
+  isDate: function (d) {
+    return typeof d === 'object' && objectToString(d) === '[object Date]';
+  },
+  isRegExp: function (re) {
+    return typeof re === 'object' && objectToString(re) === '[object RegExp]';
+  },
+  getRegExpFlags: function (re) {
+    var flags = '';
+    re.global && (flags += 'g');
+    re.ignoreCase && (flags += 'i');
+    re.multiline && (flags += 'm');
+    return flags;
+  }
+};
+
+if (typeof module === 'object')
+  module.exports = clone;
+
+/**
+ * Clones (copies) an Object using deep copying.
+ *
+ * This function supports circular references by default, but if you are certain
+ * there are no circular references in your object, you can save some CPU time
+ * by calling clone(obj, false).
+ *
+ * Caution: if `circular` is false and `parent` contains circular references,
+ * your program may enter an infinite loop and crash.
+ *
+ * @param `parent` - the object to be cloned
+ * @param `circular` - set to true if the object to be cloned may contain
+ *    circular references. (optional - true by default)
+*/
+function clone(parent, circular) {
+  if (typeof circular == 'undefined')
+    circular = true;
+
+  var useBuffer = typeof Buffer != 'undefined';
+
+  var circularParent = {};
+  var circularResolved = {};
+  var circularReplace = [];
+
+  function _clone(parent, context, child, cIndex) {
+    var i; // Use local context within this function
+    // Deep clone all properties of parent into child
+    if (typeof parent == 'object') {
+      if (parent == null)
+        return parent;
+      // Check for circular references
+      for(i in circularParent)
+        if (circularParent[i] === parent) {
+          // We found a circular reference
+          circularReplace.push({'resolveTo': i, 'child': child, 'i': cIndex});
+          return null; //Just return null for now...
+          // we will resolve circular references later
+        }
+
+      // Add to list of all parent objects
+      circularParent[context] = parent;
+      // Now continue cloning...
+      if (util.isArray(parent)) {
+        child = [];
+        for(i in parent)
+          child[i] = _clone(parent[i], context + '[' + i + ']', child, i);
+      }
+      else if (util.isDate(parent))
+        child = new Date(parent.getTime());
+      else if (util.isRegExp(parent)) {
+        child = new RegExp(parent.source, util.getRegExpFlags(parent));
+        if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+      } else if (useBuffer && Buffer.isBuffer(parent))
+      {
+        child = new Buffer(parent.length);
+        parent.copy(child);
+      }
+      else {
+        child = {};
+
+        // Also copy prototype over to new cloned object
+        child.__proto__ = parent.__proto__;
+        for(i in parent)
+          child[i] = _clone(parent[i], context + '[' + i + ']', child, i);
+      }
+
+      // Add to list of all cloned objects
+      circularResolved[context] = child;
+    }
+    else
+      child = parent; //Just a simple shallow copy will do
+    return child;
+  }
+
+  var i;
+  if (circular) {
+    var cloned = _clone(parent, '*');
+
+    // Now this object has been cloned. Let's check to see if there are any
+    // circular references for it
+    for(i in circularReplace) {
+      var c = circularReplace[i];
+      if (c && c.child && c.i in c.child) {
+        c.child[c.i] = circularResolved[c.resolveTo];
+      }
+    }
+    return cloned;
+  } else {
+    // Deep clone all properties of parent into child
+    var child;
+    if (typeof parent == 'object') {
+      if (parent == null)
+        return parent;
+      if (parent.constructor.name === 'Array') {
+        child = [];
+        for(i in parent)
+          child[i] = clone(parent[i], circular);
+      }
+      else if (util.isDate(parent))
+        child = new Date(parent.getTime() );
+      else if (util.isRegExp(parent)) {
+        child = new RegExp(parent.source, util.getRegExpFlags(parent));
+        if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+      } else {
+        child = {};
+        child.__proto__ = parent.__proto__;
+        for(i in parent)
+          child[i] = clone(parent[i], circular);
+      }
+    }
+    else
+      child = parent; // Just a simple shallow clone will do
+    return child;
+  }
+}
+
+/**
+ * Simple flat clone using prototype, accepts only objects, usefull for property
+ * override on FLAT configuration object (no nested props).
+ *
+ * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+ * works.
+ */
+clone.clonePrototype = function(parent) {
+  if (parent === null)
+    return null;
+
+  var c = function () {};
+  c.prototype = parent;
+  return new c();
+};
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":55}],3:[function(require,module,exports){
+/*
+
+index.js - discover-tcp-transport: TCP transport for Discover node discovery
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2014 Tristan Slominski
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+"use strict";
+
+var events = require('events'),
+    net = require('net'),
+    util = require('util');
+
+var TcpTransport = module.exports = function TcpTransport (options) {
+    var self = this;
+    events.EventEmitter.call(self);
+
+    options = options || {};
+
+    self.id = options.id;
+    self.host = options.host || 'localhost';
+    self.port = options.port || 6742;
+
+    self.server = null;
+};
+
+util.inherits(TcpTransport, events.EventEmitter);
+
+/*
+  * `options`: See `new TcpTransport(options)` `options`.
+  * `callback`: See `tcpTransport.listen(callback)` `callback`.
+  Return: _Object_ An instance of TcpTransport with server running.
+*/
+TcpTransport.listen = function listen (options, callback) {
+    var tcpTransport = new TcpTransport(options);
+    tcpTransport.listen(callback);
+    return tcpTransport;
+};
+
+/*
+  * `callback`: _Function_ _(Default: undefined)_ Optional callback to call once
+      the server is stopped.
+*/
+TcpTransport.prototype.close = function close (callback) {
+    var self = this;
+    if (self.server)
+        self.server.close(callback);
+};
+
+/*
+  * `contact`: _Object_ The node to contact with request to find `nodeId`.
+    * `id`: _String (base64)_ Base64 encoded contact node id.
+    * `transport`: _Object_ TCP transport data.
+      * `host`: _String_ IP address to connect to.
+      * `port`: _Integer_ Port to connect to.
+  * `nodeId`: _String (base64)_ Base64 encoded string representation of the node id to find.
+  * `sender`: _Object_ The node making the request
+    * `id`: _String (base64)_ Base64 encoded sender node id.
+    * `data`: _Any_ Sender node data.
+    * `transport`: _Object_ TCP transport data.
+      * `host`: _String_ Host to connect to.
+      * `port`: _Integer_ Port to connect to.
+*/
+TcpTransport.prototype.findNode = function findNode (contact, nodeId, sender) {
+    var self = this;
+    self.rpc(contact, {
+        request: {
+            findNode: nodeId
+        },
+        sender: sender
+    }, function(error, data) {
+        if (error) {
+            self.emit('node', new Error('unreachable'), contact, nodeId);
+            self.emit('unreachable', contact);
+            return;
+        }
+        if (!data)
+            return self.emit('node', new Error('no data received'), contact, nodeId);
+
+        try {
+            data = JSON.parse(data.toString());
+            return self.emit('node', null, contact, nodeId, data);
+        } catch (exception) {
+            self.emit('node',
+                new Error('JSON parse error: ' + exception.message + ' when parsing ' + data),
+                contact, nodeId);
+        }
+    });
+};
+
+/*
+  * `callback`: _Function_ _(Default: undefined)_ Optional callback to call once
+      the server is up.
+*/
+TcpTransport.prototype.listen = function listen (callback) {
+    var self = this;
+    self.server = net.createServer(function (connection) {
+        var responseCallback = function (response) {
+            connection.write(JSON.stringify(response) + '\r\n');
+            connection.end();
+        };
+        var data = "";
+        connection.on('data', function (chunk) {
+            data += chunk.toString("utf8");
+            if (!~data.indexOf('\r\n')) {
+                return; // wait for more data
+            }
+
+            try {
+                data = JSON.parse(data.toString("utf8"));
+            } catch (exception) {
+                return connection.end(); // kill connection
+            }
+            if (data.request && data.request.findNode) {
+                self.emit('findNode', data.request.findNode, data.sender, function (error, response) {
+                    if (error)
+                        return connection.end();
+                    if (responseCallback)
+                        responseCallback(response);
+                });
+            } else if (data.request && data.request.ping) {
+                self.emit('ping', data.request.ping, data.sender, function (error, response) {
+                    if (error)
+                        return connection.end();
+                    if (responseCallback)
+                        responseCallback(response);
+                });
+            } else {
+                return connection.end(); // kill connection
+            }
+        });
+        connection.on('end', function () {
+            responseCallback = undefined;
+        });
+        connection.on('error', function (error) {
+            responseCallback = undefined;
+        });
+    });
+    self.server.listen(self.port, self.host, callback);
+};
+
+/*
+  * `contact`: _Object_ Contact to ping.
+    * `id`: _String (base64)_ Base64 encoded contact node id.
+    * `transport`: _Object_ TCP transport data.
+      * `host`: _String_ Host to connect to.
+      * `port`: _Integer_ Port to connect to.
+  * `sender`: _Object_ The contact making the request.
+    * `id`: _String (base64)_ Base64 encoded sender node id.
+    * `data`: _Any_ Sender node data.
+    * `transport`: _Object_ TCP transport data.
+      * `host`: _String_ Host of the sender.
+      * `port`: _Integer_ Port of the sender.
+*/
+TcpTransport.prototype.ping = function ping (contact, sender) {
+    var self = this;
+    self.rpc(contact, {
+        request: {
+            ping: contact.id
+        },
+        sender: sender
+    }, function(error, data) {
+        if (error || !data)
+            return self.emit('unreachable', contact);
+
+        try {
+            data = JSON.parse(data);
+            if (data.id === undefined || data.transport === undefined
+                || data.transport.host === undefined
+                || data.transport.port === undefined) { // data.data is optional
+                return self.emit('unreachable', contact);
+            }
+            return self.emit('reached', contact);
+        } catch (exception) {
+            // console.dir(exception);
+            return self.emit('unreachable', contact);
+        }
+    });
+};
+
+/*
+  * `contact`: _Object_ Contact to ping.
+    * `id`: _String (base64)_ Base64 encoded contact node id.
+    * `transport`: _Object_ TCP transport data.
+      * `host`: _String_ Host to connect to.
+      * `port`: _Integer_ Port to connect to.
+  * `payload`: _String_ or _Object_ Payload to send on the wire. If an _Object_
+      is provided, it will be `JSON.stringify()`'ed.
+  * `callback`: _Function_ Callback to call with an error or response.
+*/
+TcpTransport.prototype.rpc = function rpc (contact, payload, callback) {
+    var self = this;
+    var client = net.connect(
+        {
+            host: contact.transport.host,
+            port: contact.transport.port
+        },
+        function () {
+            if (typeof payload != "string")
+                payload = JSON.stringify(payload);
+            client.write(payload + '\r\n');
+        });
+
+    var hasError = false;
+    var data = "";
+    client.on('data', function (buf) {
+        data += buf.toString("utf8");
+    });
+    client.on('end', function () {
+        if (!hasError)
+            callback(null, data);
+    });
+    client.on('error', function (error) {
+        hasError = true;
+        callback(error);
+    });
+};
+
+/*
+  * `contact`: _Object_ A contact.
+  * Return: _Object_ `contact` with `contact.transport` populated.
+*/
+TcpTransport.prototype.setTransportInfo = function setTransportInfo(contact) {
+    var self = this;
+
+    contact.transport = {
+        host: self.host,
+        port: self.port
+    };
+    return contact;
+};
+
+},{"events":90,"net":8,"util":162}],4:[function(require,module,exports){
+/*
+index.js - Kademlia DHT K-bucket implementation as a binary tree.
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2018 Tristan Slominski
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+*/
+'use strict'
+
+const randomBytes = require('randombytes')
+const { EventEmitter } = require('events')
+
+/**
+ * @param  {Uint8Array} array1
+ * @param  {Uint8Array} array2
+ * @return {Boolean}
+ */
+function arrayEquals (array1, array2) {
+  if (array1 === array2) {
+    return true
+  }
+  if (array1.length !== array2.length) {
+    return false
+  }
+  for (let i = 0, length = array1.length; i < length; ++i) {
+    if (array1[i] !== array2[i]) {
+      return false
+    }
+  }
+  return true
+}
+
+function createNode () {
+  return { contacts: [], dontSplit: false, left: null, right: null }
+}
+
+function ensureInt8 (name, val) {
+  if (!(val instanceof Uint8Array)) {
+    throw new TypeError(name + ' is not a Uint8Array')
+  }
+}
+
+/**
+ * Implementation of a Kademlia DHT k-bucket used for storing
+ * contact (peer node) information.
+ *
+ * @extends EventEmitter
+ */
+class KBucket extends EventEmitter {
+  /**
+   * `options`:
+   *   `distance`: _Function_
+   *     `function (firstId, secondId) { return distance }` An optional
+   *     `distance` function that gets two `id` Uint8Arrays
+   *     and return distance (as number) between them.
+   *   `arbiter`: _Function_ _(Default: vectorClock arbiter)_
+   *     `function (incumbent, candidate) { return contact; }` An optional
+   *     `arbiter` function that givent two `contact` objects with the same `id`
+   *     returns the desired object to be used for updating the k-bucket. For
+   *     more details, see [arbiter function](#arbiter-function).
+   *   `localNodeId`: _Uint8Array_ An optional Uint8Array representing the local node id.
+   *     If not provided, a local node id will be created via `randomBytes(20)`.
+   *     `metadata`: _Object_ _(Default: {})_ Optional satellite data to include
+   *     with the k-bucket. `metadata` property is guaranteed not be altered by,
+   *     it is provided as an explicit container for users of k-bucket to store
+   *     implementation-specific data.
+   *   `numberOfNodesPerKBucket`: _Integer_ _(Default: 20)_ The number of nodes
+   *     that a k-bucket can contain before being full or split.
+   *     `numberOfNodesToPing`: _Integer_ _(Default: 3)_ The number of nodes to
+   *     ping when a bucket that should not be split becomes full. KBucket will
+   *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
+   *     not been contacted the longest.
+   *
+   * @param {Object=} options optional
+   */
+  constructor (options = {}) {
+    super()
+
+    this.localNodeId = options.localNodeId || randomBytes(20)
+    this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
+    this.numberOfNodesToPing = options.numberOfNodesToPing || 3
+    this.distance = options.distance || KBucket.distance
+    // use an arbiter from options or vectorClock arbiter by default
+    this.arbiter = options.arbiter || KBucket.arbiter
+    this.metadata = Object.assign({}, options.metadata)
+
+    ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
+
+    this.root = createNode()
+  }
+
+  /**
+   * Default arbiter function for contacts with the same id. Uses
+   * contact.vectorClock to select which contact to update the k-bucket with.
+   * Contact with larger vectorClock field will be selected. If vectorClock is
+   * the same, candidat will be selected.
+   *
+   * @param  {Object} incumbent Contact currently stored in the k-bucket.
+   * @param  {Object} candidate Contact being added to the k-bucket.
+   * @return {Object}           Contact to updated the k-bucket with.
+   */
+  static arbiter (incumbent, candidate) {
+    return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
+  }
+
+  /**
+   * Default distance function. Finds the XOR
+   * distance between firstId and secondId.
+   *
+   * @param  {Uint8Array} firstId  Uint8Array containing first id.
+   * @param  {Uint8Array} secondId Uint8Array containing second id.
+   * @return {Number}              Integer The XOR distance between firstId
+   *                               and secondId.
+   */
+  static distance (firstId, secondId) {
+    let distance = 0
+    let i = 0
+    const min = Math.min(firstId.length, secondId.length)
+    const max = Math.max(firstId.length, secondId.length)
+    for (; i < min; ++i) {
+      distance = distance * 256 + (firstId[i] ^ secondId[i])
+    }
+    for (; i < max; ++i) distance = distance * 256 + 255
+    return distance
+  }
+
+  /**
+   * Adds a contact to the k-bucket.
+   *
+   * @param {Object} contact the contact object to add
+   */
+  add (contact) {
+    ensureInt8('contact.id', (contact || {}).id)
+
+    let bitIndex = 0
+    let node = this.root
+
+    while (node.contacts === null) {
+      // this is not a leaf node but an inner node with 'low' and 'high'
+      // branches; we will check the appropriate bit of the identifier and
+      // delegate to the appropriate node for further processing
+      node = this._determineNode(node, contact.id, bitIndex++)
+    }
+
+    // check if the contact already exists
+    const index = this._indexOf(node, contact.id)
+    if (index >= 0) {
+      this._update(node, index, contact)
+      return this
+    }
+
+    if (node.contacts.length < this.numberOfNodesPerKBucket) {
+      node.contacts.push(contact)
+      this.emit('added', contact)
+      return this
+    }
+
+    // the bucket is full
+    if (node.dontSplit) {
+      // we are not allowed to split the bucket
+      // we need to ping the first this.numberOfNodesToPing
+      // in order to determine if they are alive
+      // only if one of the pinged nodes does not respond, can the new contact
+      // be added (this prevents DoS flodding with new invalid contacts)
+      this.emit('ping', node.contacts.slice(0, this.numberOfNodesToPing), contact)
+      return this
+    }
+
+    this._split(node, bitIndex)
+    return this.add(contact)
+  }
+
+  /**
+   * Get the n closest contacts to the provided node id. "Closest" here means:
+   * closest according to the XOR metric of the contact node id.
+   *
+   * @param  {Uint8Array} id  Contact node id
+   * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
+   *                          closest contacts to return
+   * @return {Array}          Array Maximum of n closest contacts to the node id
+   */
+  closest (id, n = Infinity) {
+    ensureInt8('id', id)
+
+    if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
+      throw new TypeError('n is not positive number')
+    }
+
+    let contacts = []
+
+    for (let nodes = [ this.root ], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
+      const node = nodes.pop()
+      if (node.contacts === null) {
+        const detNode = this._determineNode(node, id, bitIndex++)
+        nodes.push(node.left === detNode ? node.right : node.left)
+        nodes.push(detNode)
+      } else {
+        contacts = contacts.concat(node.contacts)
+      }
+    }
+
+    return contacts
+      .map(a => [this.distance(a.id, id), a])
+      .sort((a, b) => a[0] - b[0])
+      .slice(0, n)
+      .map(a => a[1])
+  }
+
+  /**
+   * Counts the total number of contacts in the tree.
+   *
+   * @return {Number} The number of contacts held in the tree
+   */
+  count () {
+    // return this.toArray().length
+    let count = 0
+    for (const nodes = [ this.root ]; nodes.length > 0;) {
+      const node = nodes.pop()
+      if (node.contacts === null) nodes.push(node.right, node.left)
+      else count += node.contacts.length
+    }
+    return count
+  }
+
+  /**
+   * Determines whether the id at the bitIndex is 0 or 1.
+   * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
+   *
+   * @param  {Object} node     internal object that has 2 leafs: left and right
+   * @param  {Uint8Array} id   Id to compare localNodeId with.
+   * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
+   *                           to check in the id Uint8Array.
+   * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
+   */
+  _determineNode (node, id, bitIndex) {
+    // **NOTE** remember that id is a Uint8Array and has granularity of
+    // bytes (8 bits), whereas the bitIndex is the _bit_ index (not byte)
+
+    // id's that are too short are put in low bucket (1 byte = 8 bits)
+    // (bitIndex >> 3) finds how many bytes the bitIndex describes
+    // bitIndex % 8 checks if we have extra bits beyond byte multiples
+    // if number of bytes is <= no. of bytes described by bitIndex and there
+    // are extra bits to consider, this means id has less bits than what
+    // bitIndex describes, id therefore is too short, and will be put in low
+    // bucket
+    const bytesDescribedByBitIndex = bitIndex >> 3
+    const bitIndexWithinByte = bitIndex % 8
+    if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
+      return node.left
+    }
+
+    const byteUnderConsideration = id[bytesDescribedByBitIndex]
+
+    // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
+    // where 255 is 11111111 and 0 is 00000000
+    // in order to find out whether the bit at bitIndexWithinByte is set
+    // we construct (1 << (7 - bitIndexWithinByte)) which will consist
+    // of all bits being 0, with only one bit set to 1
+    // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
+    // (1 << (7 - 3)) -> (1 << 4) -> 16
+    if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
+      return node.right
+    }
+
+    return node.left
+  }
+
+  /**
+   * Get a contact by its exact ID.
+   * If this is a leaf, loop through the bucket contents and return the correct
+   * contact if we have it or null if not. If this is an inner node, determine
+   * which branch of the tree to traverse and repeat.
+   *
+   * @param  {Uint8Array} id The ID of the contact to fetch.
+   * @return {Object|Null}   The contact if available, otherwise null
+   */
+  get (id) {
+    ensureInt8('id', id)
+
+    let bitIndex = 0
+
+    let node = this.root
+    while (node.contacts === null) {
+      node = this._determineNode(node, id, bitIndex++)
+    }
+
+    // index of uses contact id for matching
+    const index = this._indexOf(node, id)
+    return index >= 0 ? node.contacts[index] : null
+  }
+
+  /**
+   * Returns the index of the contact with provided
+   * id if it exists, returns -1 otherwise.
+   *
+   * @param  {Object} node    internal object that has 2 leafs: left and right
+   * @param  {Uint8Array} id  Contact node id.
+   * @return {Number}         Integer Index of contact with provided id if it
+   *                          exists, -1 otherwise.
+   */
+  _indexOf (node, id) {
+    for (let i = 0; i < node.contacts.length; ++i) {
+      if (arrayEquals(node.contacts[i].id, id)) return i
+    }
+
+    return -1
+  }
+
+  /**
+   * Removes contact with the provided id.
+   *
+   * @param  {Uint8Array} id The ID of the contact to remove.
+   * @return {Object}        The k-bucket itself.
+   */
+  remove (id) {
+    ensureInt8('the id as parameter 1', id)
+
+    let bitIndex = 0
+    let node = this.root
+
+    while (node.contacts === null) {
+      node = this._determineNode(node, id, bitIndex++)
+    }
+
+    const index = this._indexOf(node, id)
+    if (index >= 0) {
+      const contact = node.contacts.splice(index, 1)[0]
+      this.emit('removed', contact)
+    }
+
+    return this
+  }
+
+  /**
+   * Splits the node, redistributes contacts to the new nodes, and marks the
+   * node that was split as an inner node of the binary tree of nodes by
+   * setting this.root.contacts = null
+   *
+   * @param  {Object} node     node for splitting
+   * @param  {Number} bitIndex the bitIndex to which byte to check in the
+   *                           Uint8Array for navigating the binary tree
+   */
+  _split (node, bitIndex) {
+    node.left = createNode()
+    node.right = createNode()
+
+    // redistribute existing contacts amongst the two newly created nodes
+    for (const contact of node.contacts) {
+      this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
+    }
+
+    node.contacts = null // mark as inner tree node
+
+    // don't split the "far away" node
+    // we check where the local node would end up and mark the other one as
+    // "dontSplit" (i.e. "far away")
+    const detNode = this._determineNode(node, this.localNodeId, bitIndex)
+    const otherNode = node.left === detNode ? node.right : node.left
+    otherNode.dontSplit = true
+  }
+
+  /**
+   * Returns all the contacts contained in the tree as an array.
+   * If this is a leaf, return a copy of the bucket. `slice` is used so that we
+   * don't accidentally leak an internal reference out that might be
+   * accidentally misused. If this is not a leaf, return the union of the low
+   * and high branches (themselves also as arrays).
+   *
+   * @return {Array} All of the contacts in the tree, as an array
+   */
+  toArray () {
+    let result = []
+    for (const nodes = [ this.root ]; nodes.length > 0;) {
+      const node = nodes.pop()
+      if (node.contacts === null) nodes.push(node.right, node.left)
+      else result = result.concat(node.contacts)
+    }
+    return result
+  }
+
+  /**
+   * Updates the contact selected by the arbiter.
+   * If the selection is our old contact and the candidate is some new contact
+   * then the new contact is abandoned (not added).
+   * If the selection is our old contact and the candidate is our old contact
+   * then we are refreshing the contact and it is marked as most recently
+   * contacted (by being moved to the right/end of the bucket array).
+   * If the selection is our new contact, the old contact is removed and the new
+   * contact is marked as most recently contacted.
+   *
+   * @param  {Object} node    internal object that has 2 leafs: left and right
+   * @param  {Number} index   the index in the bucket where contact exists
+   *                          (index has already been computed in a previous
+   *                          calculation)
+   * @param  {Object} contact The contact object to update.
+   */
+  _update (node, index, contact) {
+    // sanity check
+    if (!arrayEquals(node.contacts[index].id, contact.id)) {
+      throw new Error('wrong index for _update')
+    }
+
+    const incumbent = node.contacts[index]
+    const selection = this.arbiter(incumbent, contact)
+    // if the selection is our old contact and the candidate is some new
+    // contact, then there is nothing to do
+    if (selection === incumbent && incumbent !== contact) return
+
+    node.contacts.splice(index, 1) // remove old contact
+    node.contacts.push(selection) // add more recent contact version
+    this.emit('updated', incumbent, selection)
+  }
+}
+
+module.exports = KBucket
+
+},{"events":90,"randombytes":6}],5:[function(require,module,exports){
+;(function () { // closure for web browsers
+
+if (typeof module === 'object' && module.exports) {
+  module.exports = LRUCache
+} else {
+  // just set the global for non-node platforms.
+  this.LRUCache = LRUCache
+}
+
+function hOP (obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key)
+}
+
+function naiveLength () { return 1 }
+
+function LRUCache (options) {
+  if (!(this instanceof LRUCache))
+    return new LRUCache(options)
+
+  if (typeof options === 'number')
+    options = { max: options }
+
+  if (!options)
+    options = {}
+
+  this._max = options.max
+  // Kind of weird to have a default max of Infinity, but oh well.
+  if (!this._max || !(typeof this._max === "number") || this._max <= 0 )
+    this._max = Infinity
+
+  this._lengthCalculator = options.length || naiveLength
+  if (typeof this._lengthCalculator !== "function")
+    this._lengthCalculator = naiveLength
+
+  this._allowStale = options.stale || false
+  this._maxAge = options.maxAge || null
+  this._dispose = options.dispose
+  this.reset()
+}
+
+// resize the cache when the max changes.
+Object.defineProperty(LRUCache.prototype, "max",
+  { set : function (mL) {
+      if (!mL || !(typeof mL === "number") || mL <= 0 ) mL = Infinity
+      this._max = mL
+      if (this._length > this._max) trim(this)
+    }
+  , get : function () { return this._max }
+  , enumerable : true
+  })
+
+// resize the cache when the lengthCalculator changes.
+Object.defineProperty(LRUCache.prototype, "lengthCalculator",
+  { set : function (lC) {
+      if (typeof lC !== "function") {
+        this._lengthCalculator = naiveLength
+        this._length = this._itemCount
+        for (var key in this._cache) {
+          this._cache[key].length = 1
+        }
+      } else {
+        this._lengthCalculator = lC
+        this._length = 0
+        for (var key in this._cache) {
+          this._cache[key].length = this._lengthCalculator(this._cache[key].value)
+          this._length += this._cache[key].length
+        }
+      }
+
+      if (this._length > this._max) trim(this)
+    }
+  , get : function () { return this._lengthCalculator }
+  , enumerable : true
+  })
+
+Object.defineProperty(LRUCache.prototype, "length",
+  { get : function () { return this._length }
+  , enumerable : true
+  })
+
+
+Object.defineProperty(LRUCache.prototype, "itemCount",
+  { get : function () { return this._itemCount }
+  , enumerable : true
+  })
+
+LRUCache.prototype.forEach = function (fn, thisp) {
+  thisp = thisp || this
+  var i = 0;
+  for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--) if (this._lruList[k]) {
+    i++
+    var hit = this._lruList[k]
+    if (this._maxAge && (Date.now() - hit.now > this._maxAge)) {
+      del(this, hit)
+      if (!this._allowStale) hit = undefined
+    }
+    if (hit) {
+      fn.call(thisp, hit.value, hit.key, this)
+    }
+  }
+}
+
+LRUCache.prototype.keys = function () {
+  var keys = new Array(this._itemCount)
+  var i = 0
+  for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--) if (this._lruList[k]) {
+    var hit = this._lruList[k]
+    keys[i++] = hit.key
+  }
+  return keys
+}
+
+LRUCache.prototype.values = function () {
+  var values = new Array(this._itemCount)
+  var i = 0
+  for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--) if (this._lruList[k]) {
+    var hit = this._lruList[k]
+    values[i++] = hit.value
+  }
+  return values
+}
+
+LRUCache.prototype.reset = function () {
+  if (this._dispose && this._cache) {
+    for (var k in this._cache) {
+      this._dispose(k, this._cache[k].value)
+    }
+  }
+
+  this._cache = Object.create(null) // hash of items by key
+  this._lruList = Object.create(null) // list of items in order of use recency
+  this._mru = 0 // most recently used
+  this._lru = 0 // least recently used
+  this._length = 0 // number of items in the list
+  this._itemCount = 0
+}
+
+// Provided for debugging/dev purposes only. No promises whatsoever that
+// this API stays stable.
+LRUCache.prototype.dump = function () {
+  return this._cache
+}
+
+LRUCache.prototype.dumpLru = function () {
+  return this._lruList
+}
+
+LRUCache.prototype.set = function (key, value) {
+  if (hOP(this._cache, key)) {
+    // dispose of the old one before overwriting
+    if (this._dispose) this._dispose(key, this._cache[key].value)
+    if (this._maxAge) this._cache[key].now = Date.now()
+    this._cache[key].value = value
+    this.get(key)
+    return true
+  }
+
+  var len = this._lengthCalculator(value)
+  var age = this._maxAge ? Date.now() : 0
+  var hit = new Entry(key, value, this._mru++, len, age)
+
+  // oversized objects fall out of cache automatically.
+  if (hit.length > this._max) {
+    if (this._dispose) this._dispose(key, value)
+    return false
+  }
+
+  this._length += hit.length
+  this._lruList[hit.lu] = this._cache[key] = hit
+  this._itemCount ++
+
+  if (this._length > this._max) trim(this)
+  return true
+}
+
+LRUCache.prototype.has = function (key) {
+  if (!hOP(this._cache, key)) return false
+  var hit = this._cache[key]
+  if (this._maxAge && (Date.now() - hit.now > this._maxAge)) {
+    return false
+  }
+  return true
+}
+
+LRUCache.prototype.get = function (key) {
+  return get(this, key, true)
+}
+
+LRUCache.prototype.peek = function (key) {
+  return get(this, key, false)
+}
+
+LRUCache.prototype.pop = function () {
+  var hit = this._lruList[this._lru]
+  del(this, hit)
+  return hit || null
+}
+
+LRUCache.prototype.del = function (key) {
+  del(this, this._cache[key])
+}
+
+function get (self, key, doUse) {
+  var hit = self._cache[key]
+  if (hit) {
+    if (self._maxAge && (Date.now() - hit.now > self._maxAge)) {
+      del(self, hit)
+      if (!self._allowStale) hit = undefined
+    } else {
+      if (doUse) use(self, hit)
+    }
+    if (hit) hit = hit.value
+  }
+  return hit
+}
+
+function use (self, hit) {
+  shiftLU(self, hit)
+  hit.lu = self._mru ++
+  self._lruList[hit.lu] = hit
+}
+
+function trim (self) {
+  while (self._lru < self._mru && self._length > self._max)
+    del(self, self._lruList[self._lru])
+}
+
+function shiftLU (self, hit) {
+  delete self._lruList[ hit.lu ]
+  while (self._lru < self._mru && !self._lruList[self._lru]) self._lru ++
+}
+
+function del (self, hit) {
+  if (hit) {
+    if (self._dispose) self._dispose(hit.key, hit.value)
+    self._length -= hit.length
+    self._itemCount --
+    delete self._cache[ hit.key ]
+    shiftLU(self, hit)
+  }
+}
+
+// classy, since V8 prefers predictable objects.
+function Entry (key, value, lu, length, now) {
+  this.key = key
+  this.value = value
+  this.lu = lu
+  this.length = length
+  this.now = now
+}
+
+})()
+
+},{}],6:[function(require,module,exports){
+(function (process,global){
+'use strict'
+
+function oldBrowser () {
+  throw new Error('Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11')
+}
+
+var Buffer = require('safe-buffer').Buffer
+var crypto = global.crypto || global.msCrypto
+
+if (crypto && crypto.getRandomValues) {
+  module.exports = randomBytes
+} else {
+  module.exports = oldBrowser
+}
+
+function randomBytes (size, cb) {
+  // phantomjs needs to throw
+  if (size > 65536) throw new Error('requested too many random bytes')
+  // in case browserify  isn't using the Uint8Array version
+  var rawBytes = new global.Uint8Array(size)
+
+  // This will not work in older browsers.
+  // See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
+  if (size > 0) {  // getRandomValues fails on IE if size == 0
+    crypto.getRandomValues(rawBytes)
+  }
+
+  // XXX: phantomjs doesn't like a buffer being passed here
+  var bytes = Buffer.from(rawBytes.buffer)
+
+  if (typeof cb === 'function') {
+    return process.nextTick(function () {
+      cb(null, bytes)
+    })
+  }
+
+  return bytes
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"_process":125,"safe-buffer":7}],7:[function(require,module,exports){
+/* eslint-disable node/no-deprecated-api */
+var buffer = require('buffer')
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+  for (var key in src) {
+    dst[key] = src[key]
+  }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+  module.exports = buffer
+} else {
+  // Copy properties from require('buffer')
+  copyProps(buffer, exports)
+  exports.Buffer = SafeBuffer
+}
+
+function SafeBuffer (arg, encodingOrOffset, length) {
+  return Buffer(arg, encodingOrOffset, length)
+}
+
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+  if (typeof arg === 'number') {
+    throw new TypeError('Argument must not be a number')
+  }
+  return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.alloc = function (size, fill, encoding) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  var buf = Buffer(size)
+  if (fill !== undefined) {
+    if (typeof encoding === 'string') {
+      buf.fill(fill, encoding)
+    } else {
+      buf.fill(fill)
+    }
+  } else {
+    buf.fill(0)
+  }
+  return buf
+}
+
+SafeBuffer.allocUnsafe = function (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  return Buffer(size)
+}
+
+SafeBuffer.allocUnsafeSlow = function (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  return buffer.SlowBuffer(size)
+}
+
+},{"buffer":55}],8:[function(require,module,exports){
+
+},{}],9:[function(require,module,exports){
+var asn1 = exports;
+
+asn1.bignum = require('bn.js');
+
+asn1.define = require('./asn1/api').define;
+asn1.base = require('./asn1/base');
+asn1.constants = require('./asn1/constants');
+asn1.decoders = require('./asn1/decoders');
+asn1.encoders = require('./asn1/encoders');
+
+},{"./asn1/api":10,"./asn1/base":12,"./asn1/constants":16,"./asn1/decoders":18,"./asn1/encoders":21,"bn.js":24}],10:[function(require,module,exports){
+var asn1 = require('../asn1');
+var inherits = require('inherits');
+
+var api = exports;
+
+api.define = function define(name, body) {
+  return new Entity(name, body);
+};
+
+function Entity(name, body) {
+  this.name = name;
+  this.body = body;
+
+  this.decoders = {};
+  this.encoders = {};
+};
+
+Entity.prototype._createNamed = function createNamed(base) {
+  var named;
+  try {
+    named = require('vm').runInThisContext(
+      '(function ' + this.name + '(entity) {\n' +
+      '  this._initNamed(entity);\n' +
+      '})'
+    );
+  } catch (e) {
+    named = function (entity) {
+      this._initNamed(entity);
+    };
+  }
+  inherits(named, base);
+  named.prototype._initNamed = function initnamed(entity) {
+    base.call(this, entity);
+  };
+
+  return new named(this);
+};
+
+Entity.prototype._getDecoder = function _getDecoder(enc) {
+  enc = enc || 'der';
+  // Lazily create decoder
+  if (!this.decoders.hasOwnProperty(enc))
+    this.decoders[enc] = this._createNamed(asn1.decoders[enc]);
+  return this.decoders[enc];
+};
+
+Entity.prototype.decode = function decode(data, enc, options) {
+  return this._getDecoder(enc).decode(data, options);
+};
+
+Entity.prototype._getEncoder = function _getEncoder(enc) {
+  enc = enc || 'der';
+  // Lazily create encoder
+  if (!this.encoders.hasOwnProperty(enc))
+    this.encoders[enc] = this._createNamed(asn1.encoders[enc]);
+  return this.encoders[enc];
+};
+
+Entity.prototype.encode = function encode(data, enc, /* internal */ reporter) {
+  return this._getEncoder(enc).encode(data, reporter);
+};
+
+},{"../asn1":9,"inherits":107,"vm":163}],11:[function(require,module,exports){
+var inherits = require('inherits');
+var Reporter = require('../base').Reporter;
+var Buffer = require('buffer').Buffer;
+
+function DecoderBuffer(base, options) {
+  Reporter.call(this, options);
+  if (!Buffer.isBuffer(base)) {
+    this.error('Input not Buffer');
+    return;
+  }
+
+  this.base = base;
+  this.offset = 0;
+  this.length = base.length;
+}
+inherits(DecoderBuffer, Reporter);
+exports.DecoderBuffer = DecoderBuffer;
+
+DecoderBuffer.prototype.save = function save() {
+  return { offset: this.offset, reporter: Reporter.prototype.save.call(this) };
+};
+
+DecoderBuffer.prototype.restore = function restore(save) {
+  // Return skipped data
+  var res = new DecoderBuffer(this.base);
+  res.offset = save.offset;
+  res.length = this.offset;
+
+  this.offset = save.offset;
+  Reporter.prototype.restore.call(this, save.reporter);
+
+  return res;
+};
+
+DecoderBuffer.prototype.isEmpty = function isEmpty() {
+  return this.offset === this.length;
+};
+
+DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {
+  if (this.offset + 1 <= this.length)
+    return this.base.readUInt8(this.offset++, true);
+  else
+    return this.error(fail || 'DecoderBuffer overrun');
+}
+
+DecoderBuffer.prototype.skip = function skip(bytes, fail) {
+  if (!(this.offset + bytes <= this.length))
+    return this.error(fail || 'DecoderBuffer overrun');
+
+  var res = new DecoderBuffer(this.base);
+
+  // Share reporter state
+  res._reporterState = this._reporterState;
+
+  res.offset = this.offset;
+  res.length = this.offset + bytes;
+  this.offset += bytes;
+  return res;
+}
+
+DecoderBuffer.prototype.raw = function raw(save) {
+  return this.base.slice(save ? save.offset : this.offset, this.length);
+}
+
+function EncoderBuffer(value, reporter) {
+  if (Array.isArray(value)) {
+    this.length = 0;
+    this.value = value.map(function(item) {
+      if (!(item instanceof EncoderBuffer))
+        item = new EncoderBuffer(item, reporter);
+      this.length += item.length;
+      return item;
+    }, this);
+  } else if (typeof value === 'number') {
+    if (!(0 <= value && value <= 0xff))
+      return reporter.error('non-byte EncoderBuffer value');
+    this.value = value;
+    this.length = 1;
+  } else if (typeof value === 'string') {
+    this.value = value;
+    this.length = Buffer.byteLength(value);
+  } else if (Buffer.isBuffer(value)) {
+    this.value = value;
+    this.length = value.length;
+  } else {
+    return reporter.error('Unsupported type: ' + typeof value);
+  }
+}
+exports.EncoderBuffer = EncoderBuffer;
+
+EncoderBuffer.prototype.join = function join(out, offset) {
+  if (!out)
+    out = new Buffer(this.length);
+  if (!offset)
+    offset = 0;
+
+  if (this.length === 0)
+    return out;
+
+  if (Array.isArray(this.value)) {
+    this.value.forEach(function(item) {
+      item.join(out, offset);
+      offset += item.length;
+    });
+  } else {
+    if (typeof this.value === 'number')
+      out[offset] = this.value;
+    else if (typeof this.value === 'string')
+      out.write(this.value, offset);
+    else if (Buffer.isBuffer(this.value))
+      this.value.copy(out, offset);
+    offset += this.length;
+  }
+
+  return out;
+};
+
+},{"../base":12,"buffer":55,"inherits":107}],12:[function(require,module,exports){
+var base = exports;
+
+base.Reporter = require('./reporter').Reporter;
+base.DecoderBuffer = require('./buffer').DecoderBuffer;
+base.EncoderBuffer = require('./buffer').EncoderBuffer;
+base.Node = require('./node');
+
+},{"./buffer":11,"./node":13,"./reporter":14}],13:[function(require,module,exports){
+var Reporter = require('../base').Reporter;
+var EncoderBuffer = require('../base').EncoderBuffer;
+var DecoderBuffer = require('../base').DecoderBuffer;
+var assert = require('minimalistic-assert');
+
+// Supported tags
+var tags = [
+  'seq', 'seqof', 'set', 'setof', 'objid', 'bool',
+  'gentime', 'utctime', 'null_', 'enum', 'int', 'objDesc',
+  'bitstr', 'bmpstr', 'charstr', 'genstr', 'graphstr', 'ia5str', 'iso646str',
+  'numstr', 'octstr', 'printstr', 't61str', 'unistr', 'utf8str', 'videostr'
+];
+
+// Public methods list
+var methods = [
+  'key', 'obj', 'use', 'optional', 'explicit', 'implicit', 'def', 'choice',
+  'any', 'contains'
+].concat(tags);
+
+// Overrided methods list
+var overrided = [
+  '_peekTag', '_decodeTag', '_use',
+  '_decodeStr', '_decodeObjid', '_decodeTime',
+  '_decodeNull', '_decodeInt', '_decodeBool', '_decodeList',
+
+  '_encodeComposite', '_encodeStr', '_encodeObjid', '_encodeTime',
+  '_encodeNull', '_encodeInt', '_encodeBool'
+];
+
+function Node(enc, parent) {
+  var state = {};
+  this._baseState = state;
+
+  state.enc = enc;
+
+  state.parent = parent || null;
+  state.children = null;
+
+  // State
+  state.tag = null;
+  state.args = null;
+  state.reverseArgs = null;
+  state.choice = null;
+  state.optional = false;
+  state.any = false;
+  state.obj = false;
+  state.use = null;
+  state.useDecoder = null;
+  state.key = null;
+  state['default'] = null;
+  state.explicit = null;
+  state.implicit = null;
+  state.contains = null;
+
+  // Should create new instance on each method
+  if (!state.parent) {
+    state.children = [];
+    this._wrap();
+  }
+}
+module.exports = Node;
+
+var stateProps = [
+  'enc', 'parent', 'children', 'tag', 'args', 'reverseArgs', 'choice',
+  'optional', 'any', 'obj', 'use', 'alteredUse', 'key', 'default', 'explicit',
+  'implicit', 'contains'
+];
+
+Node.prototype.clone = function clone() {
+  var state = this._baseState;
+  var cstate = {};
+  stateProps.forEach(function(prop) {
+    cstate[prop] = state[prop];
+  });
+  var res = new this.constructor(cstate.parent);
+  res._baseState = cstate;
+  return res;
+};
+
+Node.prototype._wrap = function wrap() {
+  var state = this._baseState;
+  methods.forEach(function(method) {
+    this[method] = function _wrappedMethod() {
+      var clone = new this.constructor(this);
+      state.children.push(clone);
+      return clone[method].apply(clone, arguments);
+    };
+  }, this);
+};
+
+Node.prototype._init = function init(body) {
+  var state = this._baseState;
+
+  assert(state.parent === null);
+  body.call(this);
+
+  // Filter children
+  state.children = state.children.filter(function(child) {
+    return child._baseState.parent === this;
+  }, this);
+  assert.equal(state.children.length, 1, 'Root node can have only one child');
+};
+
+Node.prototype._useArgs = function useArgs(args) {
+  var state = this._baseState;
+
+  // Filter children and args
+  var children = args.filter(function(arg) {
+    return arg instanceof this.constructor;
+  }, this);
+  args = args.filter(function(arg) {
+    return !(arg instanceof this.constructor);
+  }, this);
+
+  if (children.length !== 0) {
+    assert(state.children === null);
+    state.children = children;
+
+    // Replace parent to maintain backward link
+    children.forEach(function(child) {
+      child._baseState.parent = this;
+    }, this);
+  }
+  if (args.length !== 0) {
+    assert(state.args === null);
+    state.args = args;
+    state.reverseArgs = args.map(function(arg) {
+      if (typeof arg !== 'object' || arg.constructor !== Object)
+        return arg;
+
+      var res = {};
+      Object.keys(arg).forEach(function(key) {
+        if (key == (key | 0))
+          key |= 0;
+        var value = arg[key];
+        res[value] = key;
+      });
+      return res;
+    });
+  }
+};
+
+//
+// Overrided methods
+//
+
+overrided.forEach(function(method) {
+  Node.prototype[method] = function _overrided() {
+    var state = this._baseState;
+    throw new Error(method + ' not implemented for encoding: ' + state.enc);
+  };
+});
+
+//
+// Public methods
+//
+
+tags.forEach(function(tag) {
+  Node.prototype[tag] = function _tagMethod() {
+    var state = this._baseState;
+    var args = Array.prototype.slice.call(arguments);
+
+    assert(state.tag === null);
+    state.tag = tag;
+
+    this._useArgs(args);
+
+    return this;
+  };
+});
+
+Node.prototype.use = function use(item) {
+  assert(item);
+  var state = this._baseState;
+
+  assert(state.use === null);
+  state.use = item;
+
+  return this;
+};
+
+Node.prototype.optional = function optional() {
+  var state = this._baseState;
+
+  state.optional = true;
+
+  return this;
+};
+
+Node.prototype.def = function def(val) {
+  var state = this._baseState;
+
+  assert(state['default'] === null);
+  state['default'] = val;
+  state.optional = true;
+
+  return this;
+};
+
+Node.prototype.explicit = function explicit(num) {
+  var state = this._baseState;
+
+  assert(state.explicit === null && state.implicit === null);
+  state.explicit = num;
+
+  return this;
+};
+
+Node.prototype.implicit = function implicit(num) {
+  var state = this._baseState;
+
+  assert(state.explicit === null && state.implicit === null);
+  state.implicit = num;
+
+  return this;
+};
+
+Node.prototype.obj = function obj() {
+  var state = this._baseState;
+  var args = Array.prototype.slice.call(arguments);
+
+  state.obj = true;
+
+  if (args.length !== 0)
+    this._useArgs(args);
+
+  return this;
+};
+
+Node.prototype.key = function key(newKey) {
+  var state = this._baseState;
+
+  assert(state.key === null);
+  state.key = newKey;
+
+  return this;
+};
+
+Node.prototype.any = function any() {
+  var state = this._baseState;
+
+  state.any = true;
+
+  return this;
+};
+
+Node.prototype.choice = function choice(obj) {
+  var state = this._baseState;
+
+  assert(state.choice === null);
+  state.choice = obj;
+  this._useArgs(Object.keys(obj).map(function(key) {
+    return obj[key];
+  }));
+
+  return this;
+};
+
+Node.prototype.contains = function contains(item) {
+  var state = this._baseState;
+
+  assert(state.use === null);
+  state.contains = item;
+
+  return this;
+};
+
+//
+// Decoding
+//
+
+Node.prototype._decode = function decode(input, options) {
+  var state = this._baseState;
+
+  // Decode root node
+  if (state.parent === null)
+    return input.wrapResult(state.children[0]._decode(input, options));
+
+  var result = state['default'];
+  var present = true;
+
+  var prevKey = null;
+  if (state.key !== null)
+    prevKey = input.enterKey(state.key);
+
+  // Check if tag is there
+  if (state.optional) {
+    var tag = null;
+    if (state.explicit !== null)
+      tag = state.explicit;
+    else if (state.implicit !== null)
+      tag = state.implicit;
+    else if (state.tag !== null)
+      tag = state.tag;
+
+    if (tag === null && !state.any) {
+      // Trial and Error
+      var save = input.save();
+      try {
+        if (state.choice === null)
+          this._decodeGeneric(state.tag, input, options);
+        else
+          this._decodeChoice(input, options);
+        present = true;
+      } catch (e) {
+        present = false;
+      }
+      input.restore(save);
+    } else {
+      present = this._peekTag(input, tag, state.any);
+
+      if (input.isError(present))
+        return present;
+    }
+  }
+
+  // Push object on stack
+  var prevObj;
+  if (state.obj && present)
+    prevObj = input.enterObject();
+
+  if (present) {
+    // Unwrap explicit values
+    if (state.explicit !== null) {
+      var explicit = this._decodeTag(input, state.explicit);
+      if (input.isError(explicit))
+        return explicit;
+      input = explicit;
+    }
+
+    var start = input.offset;
+
+    // Unwrap implicit and normal values
+    if (state.use === null && state.choice === null) {
+      if (state.any)
+        var save = input.save();
+      var body = this._decodeTag(
+        input,
+        state.implicit !== null ? state.implicit : state.tag,
+        state.any
+      );
+      if (input.isError(body))
+        return body;
+
+      if (state.any)
+        result = input.raw(save);
+      else
+        input = body;
+    }
+
+    if (options && options.track && state.tag !== null)
+      options.track(input.path(), start, input.length, 'tagged');
+
+    if (options && options.track && state.tag !== null)
+      options.track(input.path(), input.offset, input.length, 'content');
+
+    // Select proper method for tag
+    if (state.any)
+      result = result;
+    else if (state.choice === null)
+      result = this._decodeGeneric(state.tag, input, options);
+    else
+      result = this._decodeChoice(input, options);
+
+    if (input.isError(result))
+      return result;
+
+    // Decode children
+    if (!state.any && state.choice === null && state.children !== null) {
+      state.children.forEach(function decodeChildren(child) {
+        // NOTE: We are ignoring errors here, to let parser continue with other
+        // parts of encoded data
+        child._decode(input, options);
+      });
+    }
+
+    // Decode contained/encoded by schema, only in bit or octet strings
+    if (state.contains && (state.tag === 'octstr' || state.tag === 'bitstr')) {
+      var data = new DecoderBuffer(result);
+      result = this._getUse(state.contains, input._reporterState.obj)
+          ._decode(data, options);
+    }
+  }
+
+  // Pop object
+  if (state.obj && present)
+    result = input.leaveObject(prevObj);
+
+  // Set key
+  if (state.key !== null && (result !== null || present === true))
+    input.leaveKey(prevKey, state.key, result);
+  else if (prevKey !== null)
+    input.exitKey(prevKey);
+
+  return result;
+};
+
+Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
+  var state = this._baseState;
+
+  if (tag === 'seq' || tag === 'set')
+    return null;
+  if (tag === 'seqof' || tag === 'setof')
+    return this._decodeList(input, tag, state.args[0], options);
+  else if (/str$/.test(tag))
+    return this._decodeStr(input, tag, options);
+  else if (tag === 'objid' && state.args)
+    return this._decodeObjid(input, state.args[0], state.args[1], options);
+  else if (tag === 'objid')
+    return this._decodeObjid(input, null, null, options);
+  else if (tag === 'gentime' || tag === 'utctime')
+    return this._decodeTime(input, tag, options);
+  else if (tag === 'null_')
+    return this._decodeNull(input, options);
+  else if (tag === 'bool')
+    return this._decodeBool(input, options);
+  else if (tag === 'objDesc')
+    return this._decodeStr(input, tag, options);
+  else if (tag === 'int' || tag === 'enum')
+    return this._decodeInt(input, state.args && state.args[0], options);
+
+  if (state.use !== null) {
+    return this._getUse(state.use, input._reporterState.obj)
+        ._decode(input, options);
+  } else {
+    return input.error('unknown tag: ' + tag);
+  }
+};
+
+Node.prototype._getUse = function _getUse(entity, obj) {
+
+  var state = this._baseState;
+  // Create altered use decoder if implicit is set
+  state.useDecoder = this._use(entity, obj);
+  assert(state.useDecoder._baseState.parent === null);
+  state.useDecoder = state.useDecoder._baseState.children[0];
+  if (state.implicit !== state.useDecoder._baseState.implicit) {
+    state.useDecoder = state.useDecoder.clone();
+    state.useDecoder._baseState.implicit = state.implicit;
+  }
+  return state.useDecoder;
+};
+
+Node.prototype._decodeChoice = function decodeChoice(input, options) {
+  var state = this._baseState;
+  var result = null;
+  var match = false;
+
+  Object.keys(state.choice).some(function(key) {
+    var save = input.save();
+    var node = state.choice[key];
+    try {
+      var value = node._decode(input, options);
+      if (input.isError(value))
+        return false;
+
+      result = { type: key, value: value };
+      match = true;
+    } catch (e) {
+      input.restore(save);
+      return false;
+    }
+    return true;
+  }, this);
+
+  if (!match)
+    return input.error('Choice not matched');
+
+  return result;
+};
+
+//
+// Encoding
+//
+
+Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
+  return new EncoderBuffer(data, this.reporter);
+};
+
+Node.prototype._encode = function encode(data, reporter, parent) {
+  var state = this._baseState;
+  if (state['default'] !== null && state['default'] === data)
+    return;
+
+  var result = this._encodeValue(data, reporter, parent);
+  if (result === undefined)
+    return;
+
+  if (this._skipDefault(result, reporter, parent))
+    return;
+
+  return result;
+};
+
+Node.prototype._encodeValue = function encode(data, reporter, parent) {
+  var state = this._baseState;
+
+  // Decode root node
+  if (state.parent === null)
+    return state.children[0]._encode(data, reporter || new Reporter());
+
+  var result = null;
+
+  // Set reporter to share it with a child class
+  this.reporter = reporter;
+
+  // Check if data is there
+  if (state.optional && data === undefined) {
+    if (state['default'] !== null)
+      data = state['default']
+    else
+      return;
+  }
+
+  // Encode children first
+  var content = null;
+  var primitive = false;
+  if (state.any) {
+    // Anything that was given is translated to buffer
+    result = this._createEncoderBuffer(data);
+  } else if (state.choice) {
+    result = this._encodeChoice(data, reporter);
+  } else if (state.contains) {
+    content = this._getUse(state.contains, parent)._encode(data, reporter);
+    primitive = true;
+  } else if (state.children) {
+    content = state.children.map(function(child) {
+      if (child._baseState.tag === 'null_')
+        return child._encode(null, reporter, data);
+
+      if (child._baseState.key === null)
+        return reporter.error('Child should have a key');
+      var prevKey = reporter.enterKey(child._baseState.key);
+
+      if (typeof data !== 'object')
+        return reporter.error('Child expected, but input is not object');
+
+      var res = child._encode(data[child._baseState.key], reporter, data);
+      reporter.leaveKey(prevKey);
+
+      return res;
+    }, this).filter(function(child) {
+      return child;
+    });
+    content = this._createEncoderBuffer(content);
+  } else {
+    if (state.tag === 'seqof' || state.tag === 'setof') {
+      // TODO(indutny): this should be thrown on DSL level
+      if (!(state.args && state.args.length === 1))
+        return reporter.error('Too many args for : ' + state.tag);
+
+      if (!Array.isArray(data))
+        return reporter.error('seqof/setof, but data is not Array');
+
+      var child = this.clone();
+      child._baseState.implicit = null;
+      content = this._createEncoderBuffer(data.map(function(item) {
+        var state = this._baseState;
+
+        return this._getUse(state.args[0], data)._encode(item, reporter);
+      }, child));
+    } else if (state.use !== null) {
+      result = this._getUse(state.use, parent)._encode(data, reporter);
+    } else {
+      content = this._encodePrimitive(state.tag, data);
+      primitive = true;
+    }
+  }
+
+  // Encode data itself
+  var result;
+  if (!state.any && state.choice === null) {
+    var tag = state.implicit !== null ? state.implicit : state.tag;
+    var cls = state.implicit === null ? 'universal' : 'context';
+
+    if (tag === null) {
+      if (state.use === null)
+        reporter.error('Tag could be omitted only for .use()');
+    } else {
+      if (state.use === null)
+        result = this._encodeComposite(tag, primitive, cls, content);
+    }
+  }
+
+  // Wrap in explicit
+  if (state.explicit !== null)
+    result = this._encodeComposite(state.explicit, false, 'context', result);
+
+  return result;
+};
+
+Node.prototype._encodeChoice = function encodeChoice(data, reporter) {
+  var state = this._baseState;
+
+  var node = state.choice[data.type];
+  if (!node) {
+    assert(
+        false,
+        data.type + ' not found in ' +
+            JSON.stringify(Object.keys(state.choice)));
+  }
+  return node._encode(data.value, reporter);
+};
+
+Node.prototype._encodePrimitive = function encodePrimitive(tag, data) {
+  var state = this._baseState;
+
+  if (/str$/.test(tag))
+    return this._encodeStr(data, tag);
+  else if (tag === 'objid' && state.args)
+    return this._encodeObjid(data, state.reverseArgs[0], state.args[1]);
+  else if (tag === 'objid')
+    return this._encodeObjid(data, null, null);
+  else if (tag === 'gentime' || tag === 'utctime')
+    return this._encodeTime(data, tag);
+  else if (tag === 'null_')
+    return this._encodeNull();
+  else if (tag === 'int' || tag === 'enum')
+    return this._encodeInt(data, state.args && state.reverseArgs[0]);
+  else if (tag === 'bool')
+    return this._encodeBool(data);
+  else if (tag === 'objDesc')
+    return this._encodeStr(data, tag);
+  else
+    throw new Error('Unsupported tag: ' + tag);
+};
+
+Node.prototype._isNumstr = function isNumstr(str) {
+  return /^[0-9 ]*$/.test(str);
+};
+
+Node.prototype._isPrintstr = function isPrintstr(str) {
+  return /^[A-Za-z0-9 '\(\)\+,\-\.\/:=\?]*$/.test(str);
+};
+
+},{"../base":12,"minimalistic-assert":112}],14:[function(require,module,exports){
+var inherits = require('inherits');
+
+function Reporter(options) {
+  this._reporterState = {
+    obj: null,
+    path: [],
+    options: options || {},
+    errors: []
+  };
+}
+exports.Reporter = Reporter;
+
+Reporter.prototype.isError = function isError(obj) {
+  return obj instanceof ReporterError;
+};
+
+Reporter.prototype.save = function save() {
+  var state = this._reporterState;
+
+  return { obj: state.obj, pathLen: state.path.length };
+};
+
+Reporter.prototype.restore = function restore(data) {
+  var state = this._reporterState;
+
+  state.obj = data.obj;
+  state.path = state.path.slice(0, data.pathLen);
+};
+
+Reporter.prototype.enterKey = function enterKey(key) {
+  return this._reporterState.path.push(key);
+};
+
+Reporter.prototype.exitKey = function exitKey(index) {
+  var state = this._reporterState;
+
+  state.path = state.path.slice(0, index - 1);
+};
+
+Reporter.prototype.leaveKey = function leaveKey(index, key, value) {
+  var state = this._reporterState;
+
+  this.exitKey(index);
+  if (state.obj !== null)
+    state.obj[key] = value;
+};
+
+Reporter.prototype.path = function path() {
+  return this._reporterState.path.join('/');
+};
+
+Reporter.prototype.enterObject = function enterObject() {
+  var state = this._reporterState;
+
+  var prev = state.obj;
+  state.obj = {};
+  return prev;
+};
+
+Reporter.prototype.leaveObject = function leaveObject(prev) {
+  var state = this._reporterState;
+
+  var now = state.obj;
+  state.obj = prev;
+  return now;
+};
+
+Reporter.prototype.error = function error(msg) {
+  var err;
+  var state = this._reporterState;
+
+  var inherited = msg instanceof ReporterError;
+  if (inherited) {
+    err = msg;
+  } else {
+    err = new ReporterError(state.path.map(function(elem) {
+      return '[' + JSON.stringify(elem) + ']';
+    }).join(''), msg.message || msg, msg.stack);
+  }
+
+  if (!state.options.partial)
+    throw err;
+
+  if (!inherited)
+    state.errors.push(err);
+
+  return err;
+};
+
+Reporter.prototype.wrapResult = function wrapResult(result) {
+  var state = this._reporterState;
+  if (!state.options.partial)
+    return result;
+
+  return {
+    result: this.isError(result) ? null : result,
+    errors: state.errors
+  };
+};
+
+function ReporterError(path, msg) {
+  this.path = path;
+  this.rethrow(msg);
+};
+inherits(ReporterError, Error);
+
+ReporterError.prototype.rethrow = function rethrow(msg) {
+  this.message = msg + ' at: ' + (this.path || '(shallow)');
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(this, ReporterError);
+
+  if (!this.stack) {
+    try {
+      // IE only adds stack when thrown
+      throw new Error(this.message);
+    } catch (e) {
+      this.stack = e.stack;
+    }
+  }
+  return this;
+};
+
+},{"inherits":107}],15:[function(require,module,exports){
+var constants = require('../constants');
+
+exports.tagClass = {
+  0: 'universal',
+  1: 'application',
+  2: 'context',
+  3: 'private'
+};
+exports.tagClassByName = constants._reverse(exports.tagClass);
+
+exports.tag = {
+  0x00: 'end',
+  0x01: 'bool',
+  0x02: 'int',
+  0x03: 'bitstr',
+  0x04: 'octstr',
+  0x05: 'null_',
+  0x06: 'objid',
+  0x07: 'objDesc',
+  0x08: 'external',
+  0x09: 'real',
+  0x0a: 'enum',
+  0x0b: 'embed',
+  0x0c: 'utf8str',
+  0x0d: 'relativeOid',
+  0x10: 'seq',
+  0x11: 'set',
+  0x12: 'numstr',
+  0x13: 'printstr',
+  0x14: 't61str',
+  0x15: 'videostr',
+  0x16: 'ia5str',
+  0x17: 'utctime',
+  0x18: 'gentime',
+  0x19: 'graphstr',
+  0x1a: 'iso646str',
+  0x1b: 'genstr',
+  0x1c: 'unistr',
+  0x1d: 'charstr',
+  0x1e: 'bmpstr'
+};
+exports.tagByName = constants._reverse(exports.tag);
+
+},{"../constants":16}],16:[function(require,module,exports){
+var constants = exports;
+
+// Helper
+constants._reverse = function reverse(map) {
+  var res = {};
+
+  Object.keys(map).forEach(function(key) {
+    // Convert key to integer if it is stringified
+    if ((key | 0) == key)
+      key = key | 0;
+
+    var value = map[key];
+    res[value] = key;
+  });
+
+  return res;
+};
+
+constants.der = require('./der');
+
+},{"./der":15}],17:[function(require,module,exports){
+var inherits = require('inherits');
+
+var asn1 = require('../../asn1');
+var base = asn1.base;
+var bignum = asn1.bignum;
+
+// Import DER constants
+var der = asn1.constants.der;
+
+function DERDecoder(entity) {
+  this.enc = 'der';
+  this.name = entity.name;
+  this.entity = entity;
+
+  // Construct base tree
+  this.tree = new DERNode();
+  this.tree._init(entity.body);
+};
+module.exports = DERDecoder;
+
+DERDecoder.prototype.decode = function decode(data, options) {
+  if (!(data instanceof base.DecoderBuffer))
+    data = new base.DecoderBuffer(data, options);
+
+  return this.tree._decode(data, options);
+};
+
+// Tree methods
+
+function DERNode(parent) {
+  base.Node.call(this, 'der', parent);
+}
+inherits(DERNode, base.Node);
+
+DERNode.prototype._peekTag = function peekTag(buffer, tag, any) {
+  if (buffer.isEmpty())
+    return false;
+
+  var state = buffer.save();
+  var decodedTag = derDecodeTag(buffer, 'Failed to peek tag: "' + tag + '"');
+  if (buffer.isError(decodedTag))
+    return decodedTag;
+
+  buffer.restore(state);
+
+  return decodedTag.tag === tag || decodedTag.tagStr === tag ||
+    (decodedTag.tagStr + 'of') === tag || any;
+};
+
+DERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {
+  var decodedTag = derDecodeTag(buffer,
+                                'Failed to decode tag of "' + tag + '"');
+  if (buffer.isError(decodedTag))
+    return decodedTag;
+
+  var len = derDecodeLen(buffer,
+                         decodedTag.primitive,
+                         'Failed to get length of "' + tag + '"');
+
+  // Failure
+  if (buffer.isError(len))
+    return len;
+
+  if (!any &&
+      decodedTag.tag !== tag &&
+      decodedTag.tagStr !== tag &&
+      decodedTag.tagStr + 'of' !== tag) {
+    return buffer.error('Failed to match tag: "' + tag + '"');
+  }
+
+  if (decodedTag.primitive || len !== null)
+    return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
+
+  // Indefinite length... find END tag
+  var state = buffer.save();
+  var res = this._skipUntilEnd(
+      buffer,
+      'Failed to skip indefinite length body: "' + this.tag + '"');
+  if (buffer.isError(res))
+    return res;
+
+  len = buffer.offset - state.offset;
+  buffer.restore(state);
+  return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
+};
+
+DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {
+  while (true) {
+    var tag = derDecodeTag(buffer, fail);
+    if (buffer.isError(tag))
+      return tag;
+    var len = derDecodeLen(buffer, tag.primitive, fail);
+    if (buffer.isError(len))
+      return len;
+
+    var res;
+    if (tag.primitive || len !== null)
+      res = buffer.skip(len)
+    else
+      res = this._skipUntilEnd(buffer, fail);
+
+    // Failure
+    if (buffer.isError(res))
+      return res;
+
+    if (tag.tagStr === 'end')
+      break;
+  }
+};
+
+DERNode.prototype._decodeList = function decodeList(buffer, tag, decoder,
+                                                    options) {
+  var result = [];
+  while (!buffer.isEmpty()) {
+    var possibleEnd = this._peekTag(buffer, 'end');
+    if (buffer.isError(possibleEnd))
+      return possibleEnd;
+
+    var res = decoder.decode(buffer, 'der', options);
+    if (buffer.isError(res) && possibleEnd)
+      break;
+    result.push(res);
+  }
+  return result;
+};
+
+DERNode.prototype._decodeStr = function decodeStr(buffer, tag) {
+  if (tag === 'bitstr') {
+    var unused = buffer.readUInt8();
+    if (buffer.isError(unused))
+      return unused;
+    return { unused: unused, data: buffer.raw() };
+  } else if (tag === 'bmpstr') {
+    var raw = buffer.raw();
+    if (raw.length % 2 === 1)
+      return buffer.error('Decoding of string type: bmpstr length mismatch');
+
+    var str = '';
+    for (var i = 0; i < raw.length / 2; i++) {
+      str += String.fromCharCode(raw.readUInt16BE(i * 2));
+    }
+    return str;
+  } else if (tag === 'numstr') {
+    var numstr = buffer.raw().toString('ascii');
+    if (!this._isNumstr(numstr)) {
+      return buffer.error('Decoding of string type: ' +
+                          'numstr unsupported characters');
+    }
+    return numstr;
+  } else if (tag === 'octstr') {
+    return buffer.raw();
+  } else if (tag === 'objDesc') {
+    return buffer.raw();
+  } else if (tag === 'printstr') {
+    var printstr = buffer.raw().toString('ascii');
+    if (!this._isPrintstr(printstr)) {
+      return buffer.error('Decoding of string type: ' +
+                          'printstr unsupported characters');
+    }
+    return printstr;
+  } else if (/str$/.test(tag)) {
+    return buffer.raw().toString();
+  } else {
+    return buffer.error('Decoding of string type: ' + tag + ' unsupported');
+  }
+};
+
+DERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {
+  var result;
+  var identifiers = [];
+  var ident = 0;
+  while (!buffer.isEmpty()) {
+    var subident = buffer.readUInt8();
+    ident <<= 7;
+    ident |= subident & 0x7f;
+    if ((subident & 0x80) === 0) {
+      identifiers.push(ident);
+      ident = 0;
+    }
+  }
+  if (subident & 0x80)
+    identifiers.push(ident);
+
+  var first = (identifiers[0] / 40) | 0;
+  var second = identifiers[0] % 40;
+
+  if (relative)
+    result = identifiers;
+  else
+    result = [first, second].concat(identifiers.slice(1));
+
+  if (values) {
+    var tmp = values[result.join(' ')];
+    if (tmp === undefined)
+      tmp = values[result.join('.')];
+    if (tmp !== undefined)
+      result = tmp;
+  }
+
+  return result;
+};
+
+DERNode.prototype._decodeTime = function decodeTime(buffer, tag) {
+  var str = buffer.raw().toString();
+  if (tag === 'gentime') {
+    var year = str.slice(0, 4) | 0;
+    var mon = str.slice(4, 6) | 0;
+    var day = str.slice(6, 8) | 0;
+    var hour = str.slice(8, 10) | 0;
+    var min = str.slice(10, 12) | 0;
+    var sec = str.slice(12, 14) | 0;
+  } else if (tag === 'utctime') {
+    var year = str.slice(0, 2) | 0;
+    var mon = str.slice(2, 4) | 0;
+    var day = str.slice(4, 6) | 0;
+    var hour = str.slice(6, 8) | 0;
+    var min = str.slice(8, 10) | 0;
+    var sec = str.slice(10, 12) | 0;
+    if (year < 70)
+      year = 2000 + year;
+    else
+      year = 1900 + year;
+  } else {
+    return buffer.error('Decoding ' + tag + ' time is not supported yet');
+  }
+
+  return Date.UTC(year, mon - 1, day, hour, min, sec, 0);
+};
+
+DERNode.prototype._decodeNull = function decodeNull(buffer) {
+  return null;
+};
+
+DERNode.prototype._decodeBool = function decodeBool(buffer) {
+  var res = buffer.readUInt8();
+  if (buffer.isError(res))
+    return res;
+  else
+    return res !== 0;
+};
+
+DERNode.prototype._decodeInt = function decodeInt(buffer, values) {
+  // Bigint, return as it is (assume big endian)
+  var raw = buffer.raw();
+  var res = new bignum(raw);
+
+  if (values)
+    res = values[res.toString(10)] || res;
+
+  return res;
+};
+
+DERNode.prototype._use = function use(entity, obj) {
+  if (typeof entity === 'function')
+    entity = entity(obj);
+  return entity._getDecoder('der').tree;
+};
+
+// Utility methods
+
+function derDecodeTag(buf, fail) {
+  var tag = buf.readUInt8(fail);
+  if (buf.isError(tag))
+    return tag;
+
+  var cls = der.tagClass[tag >> 6];
+  var primitive = (tag & 0x20) === 0;
+
+  // Multi-octet tag - load
+  if ((tag & 0x1f) === 0x1f) {
+    var oct = tag;
+    tag = 0;
+    while ((oct & 0x80) === 0x80) {
+      oct = buf.readUInt8(fail);
+      if (buf.isError(oct))
+        return oct;
+
+      tag <<= 7;
+      tag |= oct & 0x7f;
+    }
+  } else {
+    tag &= 0x1f;
+  }
+  var tagStr = der.tag[tag];
+
+  return {
+    cls: cls,
+    primitive: primitive,
+    tag: tag,
+    tagStr: tagStr
+  };
+}
+
+function derDecodeLen(buf, primitive, fail) {
+  var len = buf.readUInt8(fail);
+  if (buf.isError(len))
+    return len;
+
+  // Indefinite form
+  if (!primitive && len === 0x80)
+    return null;
+
+  // Definite form
+  if ((len & 0x80) === 0) {
+    // Short form
+    return len;
+  }
+
+  // Long form
+  var num = len & 0x7f;
+  if (num > 4)
+    return buf.error('length octect is too long');
+
+  len = 0;
+  for (var i = 0; i < num; i++) {
+    len <<= 8;
+    var j = buf.readUInt8(fail);
+    if (buf.isError(j))
+      return j;
+    len |= j;
+  }
+
+  return len;
+}
+
+},{"../../asn1":9,"inherits":107}],18:[function(require,module,exports){
+var decoders = exports;
+
+decoders.der = require('./der');
+decoders.pem = require('./pem');
+
+},{"./der":17,"./pem":19}],19:[function(require,module,exports){
+var inherits = require('inherits');
+var Buffer = require('buffer').Buffer;
+
+var DERDecoder = require('./der');
+
+function PEMDecoder(entity) {
+  DERDecoder.call(this, entity);
+  this.enc = 'pem';
+};
+inherits(PEMDecoder, DERDecoder);
+module.exports = PEMDecoder;
+
+PEMDecoder.prototype.decode = function decode(data, options) {
+  var lines = data.toString().split(/[\r\n]+/g);
+
+  var label = options.label.toUpperCase();
+
+  var re = /^-----(BEGIN|END) ([^-]+)-----$/;
+  var start = -1;
+  var end = -1;
+  for (var i = 0; i < lines.length; i++) {
+    var match = lines[i].match(re);
+    if (match === null)
+      continue;
+
+    if (match[2] !== label)
+      continue;
+
+    if (start === -1) {
+      if (match[1] !== 'BEGIN')
+        break;
+      start = i;
+    } else {
+      if (match[1] !== 'END')
+        break;
+      end = i;
+      break;
+    }
+  }
+  if (start === -1 || end === -1)
+    throw new Error('PEM section not found for: ' + label);
+
+  var base64 = lines.slice(start + 1, end).join('');
+  // Remove excessive symbols
+  base64.replace(/[^a-z0-9\+\/=]+/gi, '');
+
+  var input = new Buffer(base64, 'base64');
+  return DERDecoder.prototype.decode.call(this, input, options);
+};
+
+},{"./der":17,"buffer":55,"inherits":107}],20:[function(require,module,exports){
+var inherits = require('inherits');
+var Buffer = require('buffer').Buffer;
+
+var asn1 = require('../../asn1');
+var base = asn1.base;
+
+// Import DER constants
+var der = asn1.constants.der;
+
+function DEREncoder(entity) {
+  this.enc = 'der';
+  this.name = entity.name;
+  this.entity = entity;
+
+  // Construct base tree
+  this.tree = new DERNode();
+  this.tree._init(entity.body);
+};
+module.exports = DEREncoder;
+
+DEREncoder.prototype.encode = function encode(data, reporter) {
+  return this.tree._encode(data, reporter).join();
+};
+
+// Tree methods
+
+function DERNode(parent) {
+  base.Node.call(this, 'der', parent);
+}
+inherits(DERNode, base.Node);
+
+DERNode.prototype._encodeComposite = function encodeComposite(tag,
+                                                              primitive,
+                                                              cls,
+                                                              content) {
+  var encodedTag = encodeTag(tag, primitive, cls, this.reporter);
+
+  // Short form
+  if (content.length < 0x80) {
+    var header = new Buffer(2);
+    header[0] = encodedTag;
+    header[1] = content.length;
+    return this._createEncoderBuffer([ header, content ]);
+  }
+
+  // Long form
+  // Count octets required to store length
+  var lenOctets = 1;
+  for (var i = content.length; i >= 0x100; i >>= 8)
+    lenOctets++;
+
+  var header = new Buffer(1 + 1 + lenOctets);
+  header[0] = encodedTag;
+  header[1] = 0x80 | lenOctets;
+
+  for (var i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8)
+    header[i] = j & 0xff;
+
+  return this._createEncoderBuffer([ header, content ]);
+};
+
+DERNode.prototype._encodeStr = function encodeStr(str, tag) {
+  if (tag === 'bitstr') {
+    return this._createEncoderBuffer([ str.unused | 0, str.data ]);
+  } else if (tag === 'bmpstr') {
+    var buf = new Buffer(str.length * 2);
+    for (var i = 0; i < str.length; i++) {
+      buf.writeUInt16BE(str.charCodeAt(i), i * 2);
+    }
+    return this._createEncoderBuffer(buf);
+  } else if (tag === 'numstr') {
+    if (!this._isNumstr(str)) {
+      return this.reporter.error('Encoding of string type: numstr supports ' +
+                                 'only digits and space');
+    }
+    return this._createEncoderBuffer(str);
+  } else if (tag === 'printstr') {
+    if (!this._isPrintstr(str)) {
+      return this.reporter.error('Encoding of string type: printstr supports ' +
+                                 'only latin upper and lower case letters, ' +
+                                 'digits, space, apostrophe, left and rigth ' +
+                                 'parenthesis, plus sign, comma, hyphen, ' +
+                                 'dot, slash, colon, equal sign, ' +
+                                 'question mark');
+    }
+    return this._createEncoderBuffer(str);
+  } else if (/str$/.test(tag)) {
+    return this._createEncoderBuffer(str);
+  } else if (tag === 'objDesc') {
+    return this._createEncoderBuffer(str);
+  } else {
+    return this.reporter.error('Encoding of string type: ' + tag +
+                               ' unsupported');
+  }
+};
+
+DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {
+  if (typeof id === 'string') {
+    if (!values)
+      return this.reporter.error('string objid given, but no values map found');
+    if (!values.hasOwnProperty(id))
+      return this.reporter.error('objid not found in values map');
+    id = values[id].split(/[\s\.]+/g);
+    for (var i = 0; i < id.length; i++)
+      id[i] |= 0;
+  } else if (Array.isArray(id)) {
+    id = id.slice();
+    for (var i = 0; i < id.length; i++)
+      id[i] |= 0;
+  }
+
+  if (!Array.isArray(id)) {
+    return this.reporter.error('objid() should be either array or string, ' +
+                               'got: ' + JSON.stringify(id));
+  }
+
+  if (!relative) {
+    if (id[1] >= 40)
+      return this.reporter.error('Second objid identifier OOB');
+    id.splice(0, 2, id[0] * 40 + id[1]);
+  }
+
+  // Count number of octets
+  var size = 0;
+  for (var i = 0; i < id.length; i++) {
+    var ident = id[i];
+    for (size++; ident >= 0x80; ident >>= 7)
+      size++;
+  }
+
+  var objid = new Buffer(size);
+  var offset = objid.length - 1;
+  for (var i = id.length - 1; i >= 0; i--) {
+    var ident = id[i];
+    objid[offset--] = ident & 0x7f;
+    while ((ident >>= 7) > 0)
+      objid[offset--] = 0x80 | (ident & 0x7f);
+  }
+
+  return this._createEncoderBuffer(objid);
+};
+
+function two(num) {
+  if (num < 10)
+    return '0' + num;
+  else
+    return num;
+}
+
+DERNode.prototype._encodeTime = function encodeTime(time, tag) {
+  var str;
+  var date = new Date(time);
+
+  if (tag === 'gentime') {
+    str = [
+      two(date.getFullYear()),
+      two(date.getUTCMonth() + 1),
+      two(date.getUTCDate()),
+      two(date.getUTCHours()),
+      two(date.getUTCMinutes()),
+      two(date.getUTCSeconds()),
+      'Z'
+    ].join('');
+  } else if (tag === 'utctime') {
+    str = [
+      two(date.getFullYear() % 100),
+      two(date.getUTCMonth() + 1),
+      two(date.getUTCDate()),
+      two(date.getUTCHours()),
+      two(date.getUTCMinutes()),
+      two(date.getUTCSeconds()),
+      'Z'
+    ].join('');
+  } else {
+    this.reporter.error('Encoding ' + tag + ' time is not supported yet');
+  }
+
+  return this._encodeStr(str, 'octstr');
+};
+
+DERNode.prototype._encodeNull = function encodeNull() {
+  return this._createEncoderBuffer('');
+};
+
+DERNode.prototype._encodeInt = function encodeInt(num, values) {
+  if (typeof num === 'string') {
+    if (!values)
+      return this.reporter.error('String int or enum given, but no values map');
+    if (!values.hasOwnProperty(num)) {
+      return this.reporter.error('Values map doesn\'t contain: ' +
+                                 JSON.stringify(num));
+    }
+    num = values[num];
+  }
+
+  // Bignum, assume big endian
+  if (typeof num !== 'number' && !Buffer.isBuffer(num)) {
+    var numArray = num.toArray();
+    if (!num.sign && numArray[0] & 0x80) {
+      numArray.unshift(0);
+    }
+    num = new Buffer(numArray);
+  }
+
+  if (Buffer.isBuffer(num)) {
+    var size = num.length;
+    if (num.length === 0)
+      size++;
+
+    var out = new Buffer(size);
+    num.copy(out);
+    if (num.length === 0)
+      out[0] = 0
+    return this._createEncoderBuffer(out);
+  }
+
+  if (num < 0x80)
+    return this._createEncoderBuffer(num);
+
+  if (num < 0x100)
+    return this._createEncoderBuffer([0, num]);
+
+  var size = 1;
+  for (var i = num; i >= 0x100; i >>= 8)
+    size++;
+
+  var out = new Array(size);
+  for (var i = out.length - 1; i >= 0; i--) {
+    out[i] = num & 0xff;
+    num >>= 8;
+  }
+  if(out[0] & 0x80) {
+    out.unshift(0);
+  }
+
+  return this._createEncoderBuffer(new Buffer(out));
+};
+
+DERNode.prototype._encodeBool = function encodeBool(value) {
+  return this._createEncoderBuffer(value ? 0xff : 0);
+};
+
+DERNode.prototype._use = function use(entity, obj) {
+  if (typeof entity === 'function')
+    entity = entity(obj);
+  return entity._getEncoder('der').tree;
+};
+
+DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) {
+  var state = this._baseState;
+  var i;
+  if (state['default'] === null)
+    return false;
+
+  var data = dataBuffer.join();
+  if (state.defaultBuffer === undefined)
+    state.defaultBuffer = this._encodeValue(state['default'], reporter, parent).join();
+
+  if (data.length !== state.defaultBuffer.length)
+    return false;
+
+  for (i=0; i < data.length; i++)
+    if (data[i] !== state.defaultBuffer[i])
+      return false;
+
+  return true;
+};
+
+// Utility methods
+
+function encodeTag(tag, primitive, cls, reporter) {
+  var res;
+
+  if (tag === 'seqof')
+    tag = 'seq';
+  else if (tag === 'setof')
+    tag = 'set';
+
+  if (der.tagByName.hasOwnProperty(tag))
+    res = der.tagByName[tag];
+  else if (typeof tag === 'number' && (tag | 0) === tag)
+    res = tag;
+  else
+    return reporter.error('Unknown tag: ' + tag);
+
+  if (res >= 0x1f)
+    return reporter.error('Multi-octet tag encoding unsupported');
+
+  if (!primitive)
+    res |= 0x20;
+
+  res |= (der.tagClassByName[cls || 'universal'] << 6);
+
+  return res;
+}
+
+},{"../../asn1":9,"buffer":55,"inherits":107}],21:[function(require,module,exports){
+var encoders = exports;
+
+encoders.der = require('./der');
+encoders.pem = require('./pem');
+
+},{"./der":20,"./pem":22}],22:[function(require,module,exports){
+var inherits = require('inherits');
+
+var DEREncoder = require('./der');
+
+function PEMEncoder(entity) {
+  DEREncoder.call(this, entity);
+  this.enc = 'pem';
+};
+inherits(PEMEncoder, DEREncoder);
+module.exports = PEMEncoder;
+
+PEMEncoder.prototype.encode = function encode(data, options) {
+  var buf = DEREncoder.prototype.encode.call(this, data);
+
+  var p = buf.toString('base64');
+  var out = [ '-----BEGIN ' + options.label + '-----' ];
+  for (var i = 0; i < p.length; i += 64)
+    out.push(p.slice(i, i + 64));
+  out.push('-----END ' + options.label + '-----');
+  return out.join('\n');
+};
+
+},{"./der":20,"inherits":107}],23:[function(require,module,exports){
+'use strict'
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i]
+  revLookup[code.charCodeAt(i)] = i
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function getLens (b64) {
+  var len = b64.length
+
+  if (len % 4 > 0) {
+    throw new Error('Invalid string. Length must be a multiple of 4')
+  }
+
+  // Trim off extra bytes after placeholder bytes are found
+  // See: https://github.com/beatgammit/base64-js/issues/42
+  var validLen = b64.indexOf('=')
+  if (validLen === -1) validLen = len
+
+  var placeHoldersLen = validLen === len
+    ? 0
+    : 4 - (validLen % 4)
+
+  return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+  var lens = getLens(b64)
+  var validLen = lens[0]
+  var placeHoldersLen = lens[1]
+  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength (b64, validLen, placeHoldersLen) {
+  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray (b64) {
+  var tmp
+  var lens = getLens(b64)
+  var validLen = lens[0]
+  var placeHoldersLen = lens[1]
+
+  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+  var curByte = 0
+
+  // if there are placeholders, only get up to the last complete 4 chars
+  var len = placeHoldersLen > 0
+    ? validLen - 4
+    : validLen
+
+  for (var i = 0; i < len; i += 4) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 18) |
+      (revLookup[b64.charCodeAt(i + 1)] << 12) |
+      (revLookup[b64.charCodeAt(i + 2)] << 6) |
+      revLookup[b64.charCodeAt(i + 3)]
+    arr[curByte++] = (tmp >> 16) & 0xFF
+    arr[curByte++] = (tmp >> 8) & 0xFF
+    arr[curByte++] = tmp & 0xFF
+  }
+
+  if (placeHoldersLen === 2) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 2) |
+      (revLookup[b64.charCodeAt(i + 1)] >> 4)
+    arr[curByte++] = tmp & 0xFF
+  }
+
+  if (placeHoldersLen === 1) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 10) |
+      (revLookup[b64.charCodeAt(i + 1)] << 4) |
+      (revLookup[b64.charCodeAt(i + 2)] >> 2)
+    arr[curByte++] = (tmp >> 8) & 0xFF
+    arr[curByte++] = 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) & 0xFF0000) +
+      ((uint8[i + 1] << 8) & 0xFF00) +
+      (uint8[i + 2] & 0xFF)
+    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 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]
+    parts.push(
+      lookup[tmp >> 2] +
+      lookup[(tmp << 4) & 0x3F] +
+      '=='
+    )
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+    parts.push(
+      lookup[tmp >> 10] +
+      lookup[(tmp >> 4) & 0x3F] +
+      lookup[(tmp << 2) & 0x3F] +
+      '='
+    )
+  }
+
+  return parts.join('')
+}
+
+},{}],24:[function(require,module,exports){
+(function (module, exports) {
+  'use strict';
+
+  // Utils
+  function assert (val, msg) {
+    if (!val) throw new Error(msg || 'Assertion failed');
+  }
+
+  // Could use `inherits` module, but don't want to move from single file
+  // architecture yet.
+  function inherits (ctor, superCtor) {
+    ctor.super_ = superCtor;
+    var TempCtor = function () {};
+    TempCtor.prototype = superCtor.prototype;
+    ctor.prototype = new TempCtor();
+    ctor.prototype.constructor = ctor;
+  }
+
+  // BN
+
+  function BN (number, base, endian) {
+    if (BN.isBN(number)) {
+      return number;
+    }
+
+    this.negative = 0;
+    this.words = null;
+    this.length = 0;
+
+    // Reduction context
+    this.red = null;
+
+    if (number !== null) {
+      if (base === 'le' || base === 'be') {
+        endian = base;
+        base = 10;
+      }
+
+      this._init(number || 0, base || 10, endian || 'be');
+    }
+  }
+  if (typeof module === 'object') {
+    module.exports = BN;
+  } else {
+    exports.BN = BN;
+  }
+
+  BN.BN = BN;
+  BN.wordSize = 26;
+
+  var Buffer;
+  try {
+    Buffer = require('buffer').Buffer;
+  } catch (e) {
+  }
+
+  BN.isBN = function isBN (num) {
+    if (num instanceof BN) {
+      return true;
+    }
+
+    return num !== null && typeof num === 'object' &&
+      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
+  };
+
+  BN.max = function max (left, right) {
+    if (left.cmp(right) > 0) return left;
+    return right;
+  };
+
+  BN.min = function min (left, right) {
+    if (left.cmp(right) < 0) return left;
+    return right;
+  };
+
+  BN.prototype._init = function init (number, base, endian) {
+    if (typeof number === 'number') {
+      return this._initNumber(number, base, endian);
+    }
+
+    if (typeof number === 'object') {
+      return this._initArray(number, base, endian);
+    }
+
+    if (base === 'hex') {
+      base = 16;
+    }
+    assert(base === (base | 0) && base >= 2 && base <= 36);
+
+    number = number.toString().replace(/\s+/g, '');
+    var start = 0;
+    if (number[0] === '-') {
+      start++;
+    }
+
+    if (base === 16) {
+      this._parseHex(number, start);
+    } else {
+      this._parseBase(number, base, start);
+    }
+
+    if (number[0] === '-') {
+      this.negative = 1;
+    }
+
+    this.strip();
+
+    if (endian !== 'le') return;
+
+    this._initArray(this.toArray(), base, endian);
+  };
+
+  BN.prototype._initNumber = function _initNumber (number, base, endian) {
+    if (number < 0) {
+      this.negative = 1;
+      number = -number;
+    }
+    if (number < 0x4000000) {
+      this.words = [ number & 0x3ffffff ];
+      this.length = 1;
+    } else if (number < 0x10000000000000) {
+      this.words = [
+        number & 0x3ffffff,
+        (number / 0x4000000) & 0x3ffffff
+      ];
+      this.length = 2;
+    } else {
+      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
+      this.words = [
+        number & 0x3ffffff,
+        (number / 0x4000000) & 0x3ffffff,
+        1
+      ];
+      this.length = 3;
+    }
+
+    if (endian !== 'le') return;
+
+    // Reverse the bytes
+    this._initArray(this.toArray(), base, endian);
+  };
+
+  BN.prototype._initArray = function _initArray (number, base, endian) {
+    // Perhaps a Uint8Array
+    assert(typeof number.length === 'number');
+    if (number.length <= 0) {
+      this.words = [ 0 ];
+      this.length = 1;
+      return this;
+    }
+
+    this.length = Math.ceil(number.length / 3);
+    this.words = new Array(this.length);
+    for (var i = 0; i < this.length; i++) {
+      this.words[i] = 0;
+    }
+
+    var j, w;
+    var off = 0;
+    if (endian === 'be') {
+      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
+        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
+        this.words[j] |= (w << off) & 0x3ffffff;
+        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+        off += 24;
+        if (off >= 26) {
+          off -= 26;
+          j++;
+        }
+      }
+    } else if (endian === 'le') {
+      for (i = 0, j = 0; i < number.length; i += 3) {
+        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
+        this.words[j] |= (w << off) & 0x3ffffff;
+        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+        off += 24;
+        if (off >= 26) {
+          off -= 26;
+          j++;
+        }
+      }
+    }
+    return this.strip();
+  };
+
+  function parseHex (str, start, end) {
+    var r = 0;
+    var len = Math.min(str.length, end);
+    for (var i = start; i < len; i++) {
+      var c = str.charCodeAt(i) - 48;
+
+      r <<= 4;
+
+      // 'a' - 'f'
+      if (c >= 49 && c <= 54) {
+        r |= c - 49 + 0xa;
+
+      // 'A' - 'F'
+      } else if (c >= 17 && c <= 22) {
+        r |= c - 17 + 0xa;
+
+      // '0' - '9'
+      } else {
+        r |= c & 0xf;
+      }
+    }
+    return r;
+  }
+
+  BN.prototype._parseHex = function _parseHex (number, start) {
+    // Create possibly bigger array to ensure that it fits the number
+    this.length = Math.ceil((number.length - start) / 6);
+    this.words = new Array(this.length);
+    for (var i = 0; i < this.length; i++) {
+      this.words[i] = 0;
+    }
+
+    var j, w;
+    // Scan 24-bit chunks and add them to the number
+    var off = 0;
+    for (i = number.length - 6, j = 0; i >= start; i -= 6) {
+      w = parseHex(number, i, i + 6);
+      this.words[j] |= (w << off) & 0x3ffffff;
+      // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb
+      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
+      off += 24;
+      if (off >= 26) {
+        off -= 26;
+        j++;
+      }
+    }
+    if (i + 6 !== start) {
+      w = parseHex(number, start, i + 6);
+      this.words[j] |= (w << off) & 0x3ffffff;
+      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
+    }
+    this.strip();
+  };
+
+  function parseBase (str, start, end, mul) {
+    var r = 0;
+    var len = Math.min(str.length, end);
+    for (var i = start; i < len; i++) {
+      var c = str.charCodeAt(i) - 48;
+
+      r *= mul;
+
+      // 'a'
+      if (c >= 49) {
+        r += c - 49 + 0xa;
+
+      // 'A'
+      } else if (c >= 17) {
+        r += c - 17 + 0xa;
+
+      // '0' - '9'
+      } else {
+        r += c;
+      }
+    }
+    return r;
+  }
+
+  BN.prototype._parseBase = function _parseBase (number, base, start) {
+    // Initialize as zero
+    this.words = [ 0 ];
+    this.length = 1;
+
+    // Find length of limb in base
+    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
+      limbLen++;
+    }
+    limbLen--;
+    limbPow = (limbPow / base) | 0;
+
+    var total = number.length - start;
+    var mod = total % limbLen;
+    var end = Math.min(total, total - mod) + start;
+
+    var word = 0;
+    for (var i = start; i < end; i += limbLen) {
+      word = parseBase(number, i, i + limbLen, base);
+
+      this.imuln(limbPow);
+      if (this.words[0] + word < 0x4000000) {
+        this.words[0] += word;
+      } else {
+        this._iaddn(word);
+      }
+    }
+
+    if (mod !== 0) {
+      var pow = 1;
+      word = parseBase(number, i, number.length, base);
+
+      for (i = 0; i < mod; i++) {
+        pow *= base;
+      }
+
+      this.imuln(pow);
+      if (this.words[0] + word < 0x4000000) {
+        this.words[0] += word;
+      } else {
+        this._iaddn(word);
+      }
+    }
+  };
+
+  BN.prototype.copy = function copy (dest) {
+    dest.words = new Array(this.length);
+    for (var i = 0; i < this.length; i++) {
+      dest.words[i] = this.words[i];
+    }
+    dest.length = this.length;
+    dest.negative = this.negative;
+    dest.red = this.red;
+  };
+
+  BN.prototype.clone = function clone () {
+    var r = new BN(null);
+    this.copy(r);
+    return r;
+  };
+
+  BN.prototype._expand = function _expand (size) {
+    while (this.length < size) {
+      this.words[this.length++] = 0;
+    }
+    return this;
+  };
+
+  // Remove leading `0` from `this`
+  BN.prototype.strip = function strip () {
+    while (this.length > 1 && this.words[this.length - 1] === 0) {
+      this.length--;
+    }
+    return this._normSign();
+  };
+
+  BN.prototype._normSign = function _normSign () {
+    // -0 = 0
+    if (this.length === 1 && this.words[0] === 0) {
+      this.negative = 0;
+    }
+    return this;
+  };
+
+  BN.prototype.inspect = function inspect () {
+    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
+  };
+
+  /*
+
+  var zeros = [];
+  var groupSizes = [];
+  var groupBases = [];
+
+  var s = '';
+  var i = -1;
+  while (++i < BN.wordSize) {
+    zeros[i] = s;
+    s += '0';
+  }
+  groupSizes[0] = 0;
+  groupSizes[1] = 0;
+  groupBases[0] = 0;
+  groupBases[1] = 0;
+  var base = 2 - 1;
+  while (++base < 36 + 1) {
+    var groupSize = 0;
+    var groupBase = 1;
+    while (groupBase < (1 << BN.wordSize) / base) {
+      groupBase *= base;
+      groupSize += 1;
+    }
+    groupSizes[base] = groupSize;
+    groupBases[base] = groupBase;
+  }
+
+  */
+
+  var zeros = [
+    '',
+    '0',
+    '00',
+    '000',
+    '0000',
+    '00000',
+    '000000',
+    '0000000',
+    '00000000',
+    '000000000',
+    '0000000000',
+    '00000000000',
+    '000000000000',
+    '0000000000000',
+    '00000000000000',
+    '000000000000000',
+    '0000000000000000',
+    '00000000000000000',
+    '000000000000000000',
+    '0000000000000000000',
+    '00000000000000000000',
+    '000000000000000000000',
+    '0000000000000000000000',
+    '00000000000000000000000',
+    '000000000000000000000000',
+    '0000000000000000000000000'
+  ];
+
+  var groupSizes = [
+    0, 0,
+    25, 16, 12, 11, 10, 9, 8,
+    8, 7, 7, 7, 7, 6, 6,
+    6, 6, 6, 6, 6, 5, 5,
+    5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5
+  ];
+
+  var groupBases = [
+    0, 0,
+    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
+    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
+    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
+    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
+    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
+  ];
+
+  BN.prototype.toString = function toString (base, padding) {
+    base = base || 10;
+    padding = padding | 0 || 1;
+
+    var out;
+    if (base === 16 || base === 'hex') {
+      out = '';
+      var off = 0;
+      var carry = 0;
+      for (var i = 0; i < this.length; i++) {
+        var w = this.words[i];
+        var word = (((w << off) | carry) & 0xffffff).toString(16);
+        carry = (w >>> (24 - off)) & 0xffffff;
+        if (carry !== 0 || i !== this.length - 1) {
+          out = zeros[6 - word.length] + word + out;
+        } else {
+          out = word + out;
+        }
+        off += 2;
+        if (off >= 26) {
+          off -= 26;
+          i--;
+        }
+      }
+      if (carry !== 0) {
+        out = carry.toString(16) + out;
+      }
+      while (out.length % padding !== 0) {
+        out = '0' + out;
+      }
+      if (this.negative !== 0) {
+        out = '-' + out;
+      }
+      return out;
+    }
+
+    if (base === (base | 0) && base >= 2 && base <= 36) {
+      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
+      var groupSize = groupSizes[base];
+      // var groupBase = Math.pow(base, groupSize);
+      var groupBase = groupBases[base];
+      out = '';
+      var c = this.clone();
+      c.negative = 0;
+      while (!c.isZero()) {
+        var r = c.modn(groupBase).toString(base);
+        c = c.idivn(groupBase);
+
+        if (!c.isZero()) {
+          out = zeros[groupSize - r.length] + r + out;
+        } else {
+          out = r + out;
+        }
+      }
+      if (this.isZero()) {
+        out = '0' + out;
+      }
+      while (out.length % padding !== 0) {
+        out = '0' + out;
+      }
+      if (this.negative !== 0) {
+        out = '-' + out;
+      }
+      return out;
+    }
+
+    assert(false, 'Base should be between 2 and 36');
+  };
+
+  BN.prototype.toNumber = function toNumber () {
+    var ret = this.words[0];
+    if (this.length === 2) {
+      ret += this.words[1] * 0x4000000;
+    } else if (this.length === 3 && this.words[2] === 0x01) {
+      // NOTE: at this stage it is known that the top bit is set
+      ret += 0x10000000000000 + (this.words[1] * 0x4000000);
+    } else if (this.length > 2) {
+      assert(false, 'Number can only safely store up to 53 bits');
+    }
+    return (this.negative !== 0) ? -ret : ret;
+  };
+
+  BN.prototype.toJSON = function toJSON () {
+    return this.toString(16);
+  };
+
+  BN.prototype.toBuffer = function toBuffer (endian, length) {
+    assert(typeof Buffer !== 'undefined');
+    return this.toArrayLike(Buffer, endian, length);
+  };
+
+  BN.prototype.toArray = function toArray (endian, length) {
+    return this.toArrayLike(Array, endian, length);
+  };
+
+  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
+    var byteLength = this.byteLength();
+    var reqLength = length || Math.max(1, byteLength);
+    assert(byteLength <= reqLength, 'byte array longer than desired length');
+    assert(reqLength > 0, 'Requested array length <= 0');
+
+    this.strip();
+    var littleEndian = endian === 'le';
+    var res = new ArrayType(reqLength);
+
+    var b, i;
+    var q = this.clone();
+    if (!littleEndian) {
+      // Assume big-endian
+      for (i = 0; i < reqLength - byteLength; i++) {
+        res[i] = 0;
+      }
+
+      for (i = 0; !q.isZero(); i++) {
+        b = q.andln(0xff);
+        q.iushrn(8);
+
+        res[reqLength - i - 1] = b;
+      }
+    } else {
+      for (i = 0; !q.isZero(); i++) {
+        b = q.andln(0xff);
+        q.iushrn(8);
+
+        res[i] = b;
+      }
+
+      for (; i < reqLength; i++) {
+        res[i] = 0;
+      }
+    }
+
+    return res;
+  };
+
+  if (Math.clz32) {
+    BN.prototype._countBits = function _countBits (w) {
+      return 32 - Math.clz32(w);
+    };
+  } else {
+    BN.prototype._countBits = function _countBits (w) {
+      var t = w;
+      var r = 0;
+      if (t >= 0x1000) {
+        r += 13;
+        t >>>= 13;
+      }
+      if (t >= 0x40) {
+        r += 7;
+        t >>>= 7;
+      }
+      if (t >= 0x8) {
+        r += 4;
+        t >>>= 4;
+      }
+      if (t >= 0x02) {
+        r += 2;
+        t >>>= 2;
+      }
+      return r + t;
+    };
+  }
+
+  BN.prototype._zeroBits = function _zeroBits (w) {
+    // Short-cut
+    if (w === 0) return 26;
+
+    var t = w;
+    var r = 0;
+    if ((t & 0x1fff) === 0) {
+      r += 13;
+      t >>>= 13;
+    }
+    if ((t & 0x7f) === 0) {
+      r += 7;
+      t >>>= 7;
+    }
+    if ((t & 0xf) === 0) {
+      r += 4;
+      t >>>= 4;
+    }
+    if ((t & 0x3) === 0) {
+      r += 2;
+      t >>>= 2;
+    }
+    if ((t & 0x1) === 0) {
+      r++;
+    }
+    return r;
+  };
+
+  // Return number of used bits in a BN
+  BN.prototype.bitLength = function bitLength () {
+    var w = this.words[this.length - 1];
+    var hi = this._countBits(w);
+    return (this.length - 1) * 26 + hi;
+  };
+
+  function toBitArray (num) {
+    var w = new Array(num.bitLength());
+
+    for (var bit = 0; bit < w.length; bit++) {
+      var off = (bit / 26) | 0;
+      var wbit = bit % 26;
+
+      w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;
+    }
+
+    return w;
+  }
+
+  // Number of trailing zero bits
+  BN.prototype.zeroBits = function zeroBits () {
+    if (this.isZero()) return 0;
+
+    var r = 0;
+    for (var i = 0; i < this.length; i++) {
+      var b = this._zeroBits(this.words[i]);
+      r += b;
+      if (b !== 26) break;
+    }
+    return r;
+  };
+
+  BN.prototype.byteLength = function byteLength () {
+    return Math.ceil(this.bitLength() / 8);
+  };
+
+  BN.prototype.toTwos = function toTwos (width) {
+    if (this.negative !== 0) {
+      return this.abs().inotn(width).iaddn(1);
+    }
+    return this.clone();
+  };
+
+  BN.prototype.fromTwos = function fromTwos (width) {
+    if (this.testn(width - 1)) {
+      return this.notn(width).iaddn(1).ineg();
+    }
+    return this.clone();
+  };
+
+  BN.prototype.isNeg = function isNeg () {
+    return this.negative !== 0;
+  };
+
+  // Return negative clone of `this`
+  BN.prototype.neg = function neg () {
+    return this.clone().ineg();
+  };
+
+  BN.prototype.ineg = function ineg () {
+    if (!this.isZero()) {
+      this.negative ^= 1;
+    }
+
+    return this;
+  };
+
+  // Or `num` with `this` in-place
+  BN.prototype.iuor = function iuor (num) {
+    while (this.length < num.length) {
+      this.words[this.length++] = 0;
+    }
+
+    for (var i = 0; i < num.length; i++) {
+      this.words[i] = this.words[i] | num.words[i];
+    }
+
+    return this.strip();
+  };
+
+  BN.prototype.ior = function ior (num) {
+    assert((this.negative | num.negative) === 0);
+    return this.iuor(num);
+  };
+
+  // Or `num` with `this`
+  BN.prototype.or = function or (num) {
+    if (this.length > num.length) return this.clone().ior(num);
+    return num.clone().ior(this);
+  };
+
+  BN.prototype.uor = function uor (num) {
+    if (this.length > num.length) return this.clone().iuor(num);
+    return num.clone().iuor(this);
+  };
+
+  // And `num` with `this` in-place
+  BN.prototype.iuand = function iuand (num) {
+    // b = min-length(num, this)
+    var b;
+    if (this.length > num.length) {
+      b = num;
+    } else {
+      b = this;
+    }
+
+    for (var i = 0; i < b.length; i++) {
+      this.words[i] = this.words[i] & num.words[i];
+    }
+
+    this.length = b.length;
+
+    return this.strip();
+  };
+
+  BN.prototype.iand = function iand (num) {
+    assert((this.negative | num.negative) === 0);
+    return this.iuand(num);
+  };
+
+  // And `num` with `this`
+  BN.prototype.and = function and (num) {
+    if (this.length > num.length) return this.clone().iand(num);
+    return num.clone().iand(this);
+  };
+
+  BN.prototype.uand = function uand (num) {
+    if (this.length > num.length) return this.clone().iuand(num);
+    return num.clone().iuand(this);
+  };
+
+  // Xor `num` with `this` in-place
+  BN.prototype.iuxor = function iuxor (num) {
+    // a.length > b.length
+    var a;
+    var b;
+    if (this.length > num.length) {
+      a = this;
+      b = num;
+    } else {
+      a = num;
+      b = this;
+    }
+
+    for (var i = 0; i < b.length; i++) {
+      this.words[i] = a.words[i] ^ b.words[i];
+    }
+
+    if (this !== a) {
+      for (; i < a.length; i++) {
+        this.words[i] = a.words[i];
+      }
+    }
+
+    this.length = a.length;
+
+    return this.strip();
+  };
+
+  BN.prototype.ixor = function ixor (num) {
+    assert((this.negative | num.negative) === 0);
+    return this.iuxor(num);
+  };
+
+  // Xor `num` with `this`
+  BN.prototype.xor = function xor (num) {
+    if (this.length > num.length) return this.clone().ixor(num);
+    return num.clone().ixor(this);
+  };
+
+  BN.prototype.uxor = function uxor (num) {
+    if (this.length > num.length) return this.clone().iuxor(num);
+    return num.clone().iuxor(this);
+  };
+
+  // Not ``this`` with ``width`` bitwidth
+  BN.prototype.inotn = function inotn (width) {
+    assert(typeof width === 'number' && width >= 0);
+
+    var bytesNeeded = Math.ceil(width / 26) | 0;
+    var bitsLeft = width % 26;
+
+    // Extend the buffer with leading zeroes
+    this._expand(bytesNeeded);
+
+    if (bitsLeft > 0) {
+      bytesNeeded--;
+    }
+
+    // Handle complete words
+    for (var i = 0; i < bytesNeeded; i++) {
+      this.words[i] = ~this.words[i] & 0x3ffffff;
+    }
+
+    // Handle the residue
+    if (bitsLeft > 0) {
+      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
+    }
+
+    // And remove leading zeroes
+    return this.strip();
+  };
+
+  BN.prototype.notn = function notn (width) {
+    return this.clone().inotn(width);
+  };
+
+  // Set `bit` of `this`
+  BN.prototype.setn = function setn (bit, val) {
+    assert(typeof bit === 'number' && bit >= 0);
+
+    var off = (bit / 26) | 0;
+    var wbit = bit % 26;
+
+    this._expand(off + 1);
+
+    if (val) {
+      this.words[off] = this.words[off] | (1 << wbit);
+    } else {
+      this.words[off] = this.words[off] & ~(1 << wbit);
+    }
+
+    return this.strip();
+  };
+
+  // Add `num` to `this` in-place
+  BN.prototype.iadd = function iadd (num) {
+    var r;
+
+    // negative + positive
+    if (this.negative !== 0 && num.negative === 0) {
+      this.negative = 0;
+      r = this.isub(num);
+      this.negative ^= 1;
+      return this._normSign();
+
+    // positive + negative
+    } else if (this.negative === 0 && num.negative !== 0) {
+      num.negative = 0;
+      r = this.isub(num);
+      num.negative = 1;
+      return r._normSign();
+    }
+
+    // a.length > b.length
+    var a, b;
+    if (this.length > num.length) {
+      a = this;
+      b = num;
+    } else {
+      a = num;
+      b = this;
+    }
+
+    var carry = 0;
+    for (var i = 0; i < b.length; i++) {
+      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
+      this.words[i] = r & 0x3ffffff;
+      carry = r >>> 26;
+    }
+    for (; carry !== 0 && i < a.length; i++) {
+      r = (a.words[i] | 0) + carry;
+      this.words[i] = r & 0x3ffffff;
+      carry = r >>> 26;
+    }
+
+    this.length = a.length;
+    if (carry !== 0) {
+      this.words[this.length] = carry;
+      this.length++;
+    // Copy the rest of the words
+    } else if (a !== this) {
+      for (; i < a.length; i++) {
+        this.words[i] = a.words[i];
+      }
+    }
+
+    return this;
+  };
+
+  // Add `num` to `this`
+  BN.prototype.add = function add (num) {
+    var res;
+    if (num.negative !== 0 && this.negative === 0) {
+      num.negative = 0;
+      res = this.sub(num);
+      num.negative ^= 1;
+      return res;
+    } else if (num.negative === 0 && this.negative !== 0) {
+      this.negative = 0;
+      res = num.sub(this);
+      this.negative = 1;
+      return res;
+    }
+
+    if (this.length > num.length) return this.clone().iadd(num);
+
+    return num.clone().iadd(this);
+  };
+
+  // Subtract `num` from `this` in-place
+  BN.prototype.isub = function isub (num) {
+    // this - (-num) = this + num
+    if (num.negative !== 0) {
+      num.negative = 0;
+      var r = this.iadd(num);
+      num.negative = 1;
+      return r._normSign();
+
+    // -this - num = -(this + num)
+    } else if (this.negative !== 0) {
+      this.negative = 0;
+      this.iadd(num);
+      this.negative = 1;
+      return this._normSign();
+    }
+
+    // At this point both numbers are positive
+    var cmp = this.cmp(num);
+
+    // Optimization - zeroify
+    if (cmp === 0) {
+      this.negative = 0;
+      this.length = 1;
+      this.words[0] = 0;
+      return this;
+    }
+
+    // a > b
+    var a, b;
+    if (cmp > 0) {
+      a = this;
+      b = num;
+    } else {
+      a = num;
+      b = this;
+    }
+
+    var carry = 0;
+    for (var i = 0; i < b.length; i++) {
+      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
+      carry = r >> 26;
+      this.words[i] = r & 0x3ffffff;
+    }
+    for (; carry !== 0 && i < a.length; i++) {
+      r = (a.words[i] | 0) + carry;
+      carry = r >> 26;
+      this.words[i] = r & 0x3ffffff;
+    }
+
+    // Copy rest of the words
+    if (carry === 0 && i < a.length && a !== this) {
+      for (; i < a.length; i++) {
+        this.words[i] = a.words[i];
+      }
+    }
+
+    this.length = Math.max(this.length, i);
+
+    if (a !== this) {
+      this.negative = 1;
+    }
+
+    return this.strip();
+  };
+
+  // Subtract `num` from `this`
+  BN.prototype.sub = function sub (num) {
+    return this.clone().isub(num);
+  };
+
+  function smallMulTo (self, num, out) {
+    out.negative = num.negative ^ self.negative;
+    var len = (self.length + num.length) | 0;
+    out.length = len;
+    len = (len - 1) | 0;
+
+    // Peel one iteration (compiler can't do it, because of code complexity)
+    var a = self.words[0] | 0;
+    var b = num.words[0] | 0;
+    var r = a * b;
+
+    var lo = r & 0x3ffffff;
+    var carry = (r / 0x4000000) | 0;
+    out.words[0] = lo;
+
+    for (var k = 1; k < len; k++) {
+      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
+      // note that ncarry could be >= 0x3ffffff
+      var ncarry = carry >>> 26;
+      var rword = carry & 0x3ffffff;
+      var maxJ = Math.min(k, num.length - 1);
+      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+        var i = (k - j) | 0;
+        a = self.words[i] | 0;
+        b = num.words[j] | 0;
+        r = a * b + rword;
+        ncarry += (r / 0x4000000) | 0;
+        rword = r & 0x3ffffff;
+      }
+      out.words[k] = rword | 0;
+      carry = ncarry | 0;
+    }
+    if (carry !== 0) {
+      out.words[k] = carry | 0;
+    } else {
+      out.length--;
+    }
+
+    return out.strip();
+  }
+
+  // TODO(indutny): it may be reasonable to omit it for users who don't need
+  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
+  // multiplication (like elliptic secp256k1).
+  var comb10MulTo = function comb10MulTo (self, num, out) {
+    var a = self.words;
+    var b = num.words;
+    var o = out.words;
+    var c = 0;
+    var lo;
+    var mid;
+    var hi;
+    var a0 = a[0] | 0;
+    var al0 = a0 & 0x1fff;
+    var ah0 = a0 >>> 13;
+    var a1 = a[1] | 0;
+    var al1 = a1 & 0x1fff;
+    var ah1 = a1 >>> 13;
+    var a2 = a[2] | 0;
+    var al2 = a2 & 0x1fff;
+    var ah2 = a2 >>> 13;
+    var a3 = a[3] | 0;
+    var al3 = a3 & 0x1fff;
+    var ah3 = a3 >>> 13;
+    var a4 = a[4] | 0;
+    var al4 = a4 & 0x1fff;
+    var ah4 = a4 >>> 13;
+    var a5 = a[5] | 0;
+    var al5 = a5 & 0x1fff;
+    var ah5 = a5 >>> 13;
+    var a6 = a[6] | 0;
+    var al6 = a6 & 0x1fff;
+    var ah6 = a6 >>> 13;
+    var a7 = a[7] | 0;
+    var al7 = a7 & 0x1fff;
+    var ah7 = a7 >>> 13;
+    var a8 = a[8] | 0;
+    var al8 = a8 & 0x1fff;
+    var ah8 = a8 >>> 13;
+    var a9 = a[9] | 0;
+    var al9 = a9 & 0x1fff;
+    var ah9 = a9 >>> 13;
+    var b0 = b[0] | 0;
+    var bl0 = b0 & 0x1fff;
+    var bh0 = b0 >>> 13;
+    var b1 = b[1] | 0;
+    var bl1 = b1 & 0x1fff;
+    var bh1 = b1 >>> 13;
+    var b2 = b[2] | 0;
+    var bl2 = b2 & 0x1fff;
+    var bh2 = b2 >>> 13;
+    var b3 = b[3] | 0;
+    var bl3 = b3 & 0x1fff;
+    var bh3 = b3 >>> 13;
+    var b4 = b[4] | 0;
+    var bl4 = b4 & 0x1fff;
+    var bh4 = b4 >>> 13;
+    var b5 = b[5] | 0;
+    var bl5 = b5 & 0x1fff;
+    var bh5 = b5 >>> 13;
+    var b6 = b[6] | 0;
+    var bl6 = b6 & 0x1fff;
+    var bh6 = b6 >>> 13;
+    var b7 = b[7] | 0;
+    var bl7 = b7 & 0x1fff;
+    var bh7 = b7 >>> 13;
+    var b8 = b[8] | 0;
+    var bl8 = b8 & 0x1fff;
+    var bh8 = b8 >>> 13;
+    var b9 = b[9] | 0;
+    var bl9 = b9 & 0x1fff;
+    var bh9 = b9 >>> 13;
+
+    out.negative = self.negative ^ num.negative;
+    out.length = 19;
+    /* k = 0 */
+    lo = Math.imul(al0, bl0);
+    mid = Math.imul(al0, bh0);
+    mid = (mid + Math.imul(ah0, bl0)) | 0;
+    hi = Math.imul(ah0, bh0);
+    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;
+    w0 &= 0x3ffffff;
+    /* k = 1 */
+    lo = Math.imul(al1, bl0);
+    mid = Math.imul(al1, bh0);
+    mid = (mid + Math.imul(ah1, bl0)) | 0;
+    hi = Math.imul(ah1, bh0);
+    lo = (lo + Math.imul(al0, bl1)) | 0;
+    mid = (mid + Math.imul(al0, bh1)) | 0;
+    mid = (mid + Math.imul(ah0, bl1)) | 0;
+    hi = (hi + Math.imul(ah0, bh1)) | 0;
+    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;
+    w1 &= 0x3ffffff;
+    /* k = 2 */
+    lo = Math.imul(al2, bl0);
+    mid = Math.imul(al2, bh0);
+    mid = (mid + Math.imul(ah2, bl0)) | 0;
+    hi = Math.imul(ah2, bh0);
+    lo = (lo + Math.imul(al1, bl1)) | 0;
+    mid = (mid + Math.imul(al1, bh1)) | 0;
+    mid = (mid + Math.imul(ah1, bl1)) | 0;
+    hi = (hi + Math.imul(ah1, bh1)) | 0;
+    lo = (lo + Math.imul(al0, bl2)) | 0;
+    mid = (mid + Math.imul(al0, bh2)) | 0;
+    mid = (mid + Math.imul(ah0, bl2)) | 0;
+    hi = (hi + Math.imul(ah0, bh2)) | 0;
+    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;
+    w2 &= 0x3ffffff;
+    /* k = 3 */
+    lo = Math.imul(al3, bl0);
+    mid = Math.imul(al3, bh0);
+    mid = (mid + Math.imul(ah3, bl0)) | 0;
+    hi = Math.imul(ah3, bh0);
+    lo = (lo + Math.imul(al2, bl1)) | 0;
+    mid = (mid + Math.imul(al2, bh1)) | 0;
+    mid = (mid + Math.imul(ah2, bl1)) | 0;
+    hi = (hi + Math.imul(ah2, bh1)) | 0;
+    lo = (lo + Math.imul(al1, bl2)) | 0;
+    mid = (mid + Math.imul(al1, bh2)) | 0;
+    mid = (mid + Math.imul(ah1, bl2)) | 0;
+    hi = (hi + Math.imul(ah1, bh2)) | 0;
+    lo = (lo + Math.imul(al0, bl3)) | 0;
+    mid = (mid + Math.imul(al0, bh3)) | 0;
+    mid = (mid + Math.imul(ah0, bl3)) | 0;
+    hi = (hi + Math.imul(ah0, bh3)) | 0;
+    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;
+    w3 &= 0x3ffffff;
+    /* k = 4 */
+    lo = Math.imul(al4, bl0);
+    mid = Math.imul(al4, bh0);
+    mid = (mid + Math.imul(ah4, bl0)) | 0;
+    hi = Math.imul(ah4, bh0);
+    lo = (lo + Math.imul(al3, bl1)) | 0;
+    mid = (mid + Math.imul(al3, bh1)) | 0;
+    mid = (mid + Math.imul(ah3, bl1)) | 0;
+    hi = (hi + Math.imul(ah3, bh1)) | 0;
+    lo = (lo + Math.imul(al2, bl2)) | 0;
+    mid = (mid + Math.imul(al2, bh2)) | 0;
+    mid = (mid + Math.imul(ah2, bl2)) | 0;
+    hi = (hi + Math.imul(ah2, bh2)) | 0;
+    lo = (lo + Math.imul(al1, bl3)) | 0;
+    mid = (mid + Math.imul(al1, bh3)) | 0;
+    mid = (mid + Math.imul(ah1, bl3)) | 0;
+    hi = (hi + Math.imul(ah1, bh3)) | 0;
+    lo = (lo + Math.imul(al0, bl4)) | 0;
+    mid = (mid + Math.imul(al0, bh4)) | 0;
+    mid = (mid + Math.imul(ah0, bl4)) | 0;
+    hi = (hi + Math.imul(ah0, bh4)) | 0;
+    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;
+    w4 &= 0x3ffffff;
+    /* k = 5 */
+    lo = Math.imul(al5, bl0);
+    mid = Math.imul(al5, bh0);
+    mid = (mid + Math.imul(ah5, bl0)) | 0;
+    hi = Math.imul(ah5, bh0);
+    lo = (lo + Math.imul(al4, bl1)) | 0;
+    mid = (mid + Math.imul(al4, bh1)) | 0;
+    mid = (mid + Math.imul(ah4, bl1)) | 0;
+    hi = (hi + Math.imul(ah4, bh1)) | 0;
+    lo = (lo + Math.imul(al3, bl2)) | 0;
+    mid = (mid + Math.imul(al3, bh2)) | 0;
+    mid = (mid + Math.imul(ah3, bl2)) | 0;
+    hi = (hi + Math.imul(ah3, bh2)) | 0;
+    lo = (lo + Math.imul(al2, bl3)) | 0;
+    mid = (mid + Math.imul(al2, bh3)) | 0;
+    mid = (mid + Math.imul(ah2, bl3)) | 0;
+    hi = (hi + Math.imul(ah2, bh3)) | 0;
+    lo = (lo + Math.imul(al1, bl4)) | 0;
+    mid = (mid + Math.imul(al1, bh4)) | 0;
+    mid = (mid + Math.imul(ah1, bl4)) | 0;
+    hi = (hi + Math.imul(ah1, bh4)) | 0;
+    lo = (lo + Math.imul(al0, bl5)) | 0;
+    mid = (mid + Math.imul(al0, bh5)) | 0;
+    mid = (mid + Math.imul(ah0, bl5)) | 0;
+    hi = (hi + Math.imul(ah0, bh5)) | 0;
+    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;
+    w5 &= 0x3ffffff;
+    /* k = 6 */
+    lo = Math.imul(al6, bl0);
+    mid = Math.imul(al6, bh0);
+    mid = (mid + Math.imul(ah6, bl0)) | 0;
+    hi = Math.imul(ah6, bh0);
+    lo = (lo + Math.imul(al5, bl1)) | 0;
+    mid = (mid + Math.imul(al5, bh1)) | 0;
+    mid = (mid + Math.imul(ah5, bl1)) | 0;
+    hi = (hi + Math.imul(ah5, bh1)) | 0;
+    lo = (lo + Math.imul(al4, bl2)) | 0;
+    mid = (mid + Math.imul(al4, bh2)) | 0;
+    mid = (mid + Math.imul(ah4, bl2)) | 0;
+    hi = (hi + Math.imul(ah4, bh2)) | 0;
+    lo = (lo + Math.imul(al3, bl3)) | 0;
+    mid = (mid + Math.imul(al3, bh3)) | 0;
+    mid = (mid + Math.imul(ah3, bl3)) | 0;
+    hi = (hi + Math.imul(ah3, bh3)) | 0;
+    lo = (lo + Math.imul(al2, bl4)) | 0;
+    mid = (mid + Math.imul(al2, bh4)) | 0;
+    mid = (mid + Math.imul(ah2, bl4)) | 0;
+    hi = (hi + Math.imul(ah2, bh4)) | 0;
+    lo = (lo + Math.imul(al1, bl5)) | 0;
+    mid = (mid + Math.imul(al1, bh5)) | 0;
+    mid = (mid + Math.imul(ah1, bl5)) | 0;
+    hi = (hi + Math.imul(ah1, bh5)) | 0;
+    lo = (lo + Math.imul(al0, bl6)) | 0;
+    mid = (mid + Math.imul(al0, bh6)) | 0;
+    mid = (mid + Math.imul(ah0, bl6)) | 0;
+    hi = (hi + Math.imul(ah0, bh6)) | 0;
+    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;
+    w6 &= 0x3ffffff;
+    /* k = 7 */
+    lo = Math.imul(al7, bl0);
+    mid = Math.imul(al7, bh0);
+    mid = (mid + Math.imul(ah7, bl0)) | 0;
+    hi = Math.imul(ah7, bh0);
+    lo = (lo + Math.imul(al6, bl1)) | 0;
+    mid = (mid + Math.imul(al6, bh1)) | 0;
+    mid = (mid + Math.imul(ah6, bl1)) | 0;
+    hi = (hi + Math.imul(ah6, bh1)) | 0;
+    lo = (lo + Math.imul(al5, bl2)) | 0;
+    mid = (mid + Math.imul(al5, bh2)) | 0;
+    mid = (mid + Math.imul(ah5, bl2)) | 0;
+    hi = (hi + Math.imul(ah5, bh2)) | 0;
+    lo = (lo + Math.imul(al4, bl3)) | 0;
+    mid = (mid + Math.imul(al4, bh3)) | 0;
+    mid = (mid + Math.imul(ah4, bl3)) | 0;
+    hi = (hi + Math.imul(ah4, bh3)) | 0;
+    lo = (lo + Math.imul(al3, bl4)) | 0;
+    mid = (mid + Math.imul(al3, bh4)) | 0;
+    mid = (mid + Math.imul(ah3, bl4)) | 0;
+    hi = (hi + Math.imul(ah3, bh4)) | 0;
+    lo = (lo + Math.imul(al2, bl5)) | 0;
+    mid = (mid + Math.imul(al2, bh5)) | 0;
+    mid = (mid + Math.imul(ah2, bl5)) | 0;
+    hi = (hi + Math.imul(ah2, bh5)) | 0;
+    lo = (lo + Math.imul(al1, bl6)) | 0;
+    mid = (mid + Math.imul(al1, bh6)) | 0;
+    mid = (mid + Math.imul(ah1, bl6)) | 0;
+    hi = (hi + Math.imul(ah1, bh6)) | 0;
+    lo = (lo + Math.imul(al0, bl7)) | 0;
+    mid = (mid + Math.imul(al0, bh7)) | 0;
+    mid = (mid + Math.imul(ah0, bl7)) | 0;
+    hi = (hi + Math.imul(ah0, bh7)) | 0;
+    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;
+    w7 &= 0x3ffffff;
+    /* k = 8 */
+    lo = Math.imul(al8, bl0);
+    mid = Math.imul(al8, bh0);
+    mid = (mid + Math.imul(ah8, bl0)) | 0;
+    hi = Math.imul(ah8, bh0);
+    lo = (lo + Math.imul(al7, bl1)) | 0;
+    mid = (mid + Math.imul(al7, bh1)) | 0;
+    mid = (mid + Math.imul(ah7, bl1)) | 0;
+    hi = (hi + Math.imul(ah7, bh1)) | 0;
+    lo = (lo + Math.imul(al6, bl2)) | 0;
+    mid = (mid + Math.imul(al6, bh2)) | 0;
+    mid = (mid + Math.imul(ah6, bl2)) | 0;
+    hi = (hi + Math.imul(ah6, bh2)) | 0;
+    lo = (lo + Math.imul(al5, bl3)) | 0;
+    mid = (mid + Math.imul(al5, bh3)) | 0;
+    mid = (mid + Math.imul(ah5, bl3)) | 0;
+    hi = (hi + Math.imul(ah5, bh3)) | 0;
+    lo = (lo + Math.imul(al4, bl4)) | 0;
+    mid = (mid + Math.imul(al4, bh4)) | 0;
+    mid = (mid + Math.imul(ah4, bl4)) | 0;
+    hi = (hi + Math.imul(ah4, bh4)) | 0;
+    lo = (lo + Math.imul(al3, bl5)) | 0;
+    mid = (mid + Math.imul(al3, bh5)) | 0;
+    mid = (mid + Math.imul(ah3, bl5)) | 0;
+    hi = (hi + Math.imul(ah3, bh5)) | 0;
+    lo = (lo + Math.imul(al2, bl6)) | 0;
+    mid = (mid + Math.imul(al2, bh6)) | 0;
+    mid = (mid + Math.imul(ah2, bl6)) | 0;
+    hi = (hi + Math.imul(ah2, bh6)) | 0;
+    lo = (lo + Math.imul(al1, bl7)) | 0;
+    mid = (mid + Math.imul(al1, bh7)) | 0;
+    mid = (mid + Math.imul(ah1, bl7)) | 0;
+    hi = (hi + Math.imul(ah1, bh7)) | 0;
+    lo = (lo + Math.imul(al0, bl8)) | 0;
+    mid = (mid + Math.imul(al0, bh8)) | 0;
+    mid = (mid + Math.imul(ah0, bl8)) | 0;
+    hi = (hi + Math.imul(ah0, bh8)) | 0;
+    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;
+    w8 &= 0x3ffffff;
+    /* k = 9 */
+    lo = Math.imul(al9, bl0);
+    mid = Math.imul(al9, bh0);
+    mid = (mid + Math.imul(ah9, bl0)) | 0;
+    hi = Math.imul(ah9, bh0);
+    lo = (lo + Math.imul(al8, bl1)) | 0;
+    mid = (mid + Math.imul(al8, bh1)) | 0;
+    mid = (mid + Math.imul(ah8, bl1)) | 0;
+    hi = (hi + Math.imul(ah8, bh1)) | 0;
+    lo = (lo + Math.imul(al7, bl2)) | 0;
+    mid = (mid + Math.imul(al7, bh2)) | 0;
+    mid = (mid + Math.imul(ah7, bl2)) | 0;
+    hi = (hi + Math.imul(ah7, bh2)) | 0;
+    lo = (lo + Math.imul(al6, bl3)) | 0;
+    mid = (mid + Math.imul(al6, bh3)) | 0;
+    mid = (mid + Math.imul(ah6, bl3)) | 0;
+    hi = (hi + Math.imul(ah6, bh3)) | 0;
+    lo = (lo + Math.imul(al5, bl4)) | 0;
+    mid = (mid + Math.imul(al5, bh4)) | 0;
+    mid = (mid + Math.imul(ah5, bl4)) | 0;
+    hi = (hi + Math.imul(ah5, bh4)) | 0;
+    lo = (lo + Math.imul(al4, bl5)) | 0;
+    mid = (mid + Math.imul(al4, bh5)) | 0;
+    mid = (mid + Math.imul(ah4, bl5)) | 0;
+    hi = (hi + Math.imul(ah4, bh5)) | 0;
+    lo = (lo + Math.imul(al3, bl6)) | 0;
+    mid = (mid + Math.imul(al3, bh6)) | 0;
+    mid = (mid + Math.imul(ah3, bl6)) | 0;
+    hi = (hi + Math.imul(ah3, bh6)) | 0;
+    lo = (lo + Math.imul(al2, bl7)) | 0;
+    mid = (mid + Math.imul(al2, bh7)) | 0;
+    mid = (mid + Math.imul(ah2, bl7)) | 0;
+    hi = (hi + Math.imul(ah2, bh7)) | 0;
+    lo = (lo + Math.imul(al1, bl8)) | 0;
+    mid = (mid + Math.imul(al1, bh8)) | 0;
+    mid = (mid + Math.imul(ah1, bl8)) | 0;
+    hi = (hi + Math.imul(ah1, bh8)) | 0;
+    lo = (lo + Math.imul(al0, bl9)) | 0;
+    mid = (mid + Math.imul(al0, bh9)) | 0;
+    mid = (mid + Math.imul(ah0, bl9)) | 0;
+    hi = (hi + Math.imul(ah0, bh9)) | 0;
+    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;
+    w9 &= 0x3ffffff;
+    /* k = 10 */
+    lo = Math.imul(al9, bl1);
+    mid = Math.imul(al9, bh1);
+    mid = (mid + Math.imul(ah9, bl1)) | 0;
+    hi = Math.imul(ah9, bh1);
+    lo = (lo + Math.imul(al8, bl2)) | 0;
+    mid = (mid + Math.imul(al8, bh2)) | 0;
+    mid = (mid + Math.imul(ah8, bl2)) | 0;
+    hi = (hi + Math.imul(ah8, bh2)) | 0;
+    lo = (lo + Math.imul(al7, bl3)) | 0;
+    mid = (mid + Math.imul(al7, bh3)) | 0;
+    mid = (mid + Math.imul(ah7, bl3)) | 0;
+    hi = (hi + Math.imul(ah7, bh3)) | 0;
+    lo = (lo + Math.imul(al6, bl4)) | 0;
+    mid = (mid + Math.imul(al6, bh4)) | 0;
+    mid = (mid + Math.imul(ah6, bl4)) | 0;
+    hi = (hi + Math.imul(ah6, bh4)) | 0;
+    lo = (lo + Math.imul(al5, bl5)) | 0;
+    mid = (mid + Math.imul(al5, bh5)) | 0;
+    mid = (mid + Math.imul(ah5, bl5)) | 0;
+    hi = (hi + Math.imul(ah5, bh5)) | 0;
+    lo = (lo + Math.imul(al4, bl6)) | 0;
+    mid = (mid + Math.imul(al4, bh6)) | 0;
+    mid = (mid + Math.imul(ah4, bl6)) | 0;
+    hi = (hi + Math.imul(ah4, bh6)) | 0;
+    lo = (lo + Math.imul(al3, bl7)) | 0;
+    mid = (mid + Math.imul(al3, bh7)) | 0;
+    mid = (mid + Math.imul(ah3, bl7)) | 0;
+    hi = (hi + Math.imul(ah3, bh7)) | 0;
+    lo = (lo + Math.imul(al2, bl8)) | 0;
+    mid = (mid + Math.imul(al2, bh8)) | 0;
+    mid = (mid + Math.imul(ah2, bl8)) | 0;
+    hi = (hi + Math.imul(ah2, bh8)) | 0;
+    lo = (lo + Math.imul(al1, bl9)) | 0;
+    mid = (mid + Math.imul(al1, bh9)) | 0;
+    mid = (mid + Math.imul(ah1, bl9)) | 0;
+    hi = (hi + Math.imul(ah1, bh9)) | 0;
+    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;
+    w10 &= 0x3ffffff;
+    /* k = 11 */
+    lo = Math.imul(al9, bl2);
+    mid = Math.imul(al9, bh2);
+    mid = (mid + Math.imul(ah9, bl2)) | 0;
+    hi = Math.imul(ah9, bh2);
+    lo = (lo + Math.imul(al8, bl3)) | 0;
+    mid = (mid + Math.imul(al8, bh3)) | 0;
+    mid = (mid + Math.imul(ah8, bl3)) | 0;
+    hi = (hi + Math.imul(ah8, bh3)) | 0;
+    lo = (lo + Math.imul(al7, bl4)) | 0;
+    mid = (mid + Math.imul(al7, bh4)) | 0;
+    mid = (mid + Math.imul(ah7, bl4)) | 0;
+    hi = (hi + Math.imul(ah7, bh4)) | 0;
+    lo = (lo + Math.imul(al6, bl5)) | 0;
+    mid = (mid + Math.imul(al6, bh5)) | 0;
+    mid = (mid + Math.imul(ah6, bl5)) | 0;
+    hi = (hi + Math.imul(ah6, bh5)) | 0;
+    lo = (lo + Math.imul(al5, bl6)) | 0;
+    mid = (mid + Math.imul(al5, bh6)) | 0;
+    mid = (mid + Math.imul(ah5, bl6)) | 0;
+    hi = (hi + Math.imul(ah5, bh6)) | 0;
+    lo = (lo + Math.imul(al4, bl7)) | 0;
+    mid = (mid + Math.imul(al4, bh7)) | 0;
+    mid = (mid + Math.imul(ah4, bl7)) | 0;
+    hi = (hi + Math.imul(ah4, bh7)) | 0;
+    lo = (lo + Math.imul(al3, bl8)) | 0;
+    mid = (mid + Math.imul(al3, bh8)) | 0;
+    mid = (mid + Math.imul(ah3, bl8)) | 0;
+    hi = (hi + Math.imul(ah3, bh8)) | 0;
+    lo = (lo + Math.imul(al2, bl9)) | 0;
+    mid = (mid + Math.imul(al2, bh9)) | 0;
+    mid = (mid + Math.imul(ah2, bl9)) | 0;
+    hi = (hi + Math.imul(ah2, bh9)) | 0;
+    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;
+    w11 &= 0x3ffffff;
+    /* k = 12 */
+    lo = Math.imul(al9, bl3);
+    mid = Math.imul(al9, bh3);
+    mid = (mid + Math.imul(ah9, bl3)) | 0;
+    hi = Math.imul(ah9, bh3);
+    lo = (lo + Math.imul(al8, bl4)) | 0;
+    mid = (mid + Math.imul(al8, bh4)) | 0;
+    mid = (mid + Math.imul(ah8, bl4)) | 0;
+    hi = (hi + Math.imul(ah8, bh4)) | 0;
+    lo = (lo + Math.imul(al7, bl5)) | 0;
+    mid = (mid + Math.imul(al7, bh5)) | 0;
+    mid = (mid + Math.imul(ah7, bl5)) | 0;
+    hi = (hi + Math.imul(ah7, bh5)) | 0;
+    lo = (lo + Math.imul(al6, bl6)) | 0;
+    mid = (mid + Math.imul(al6, bh6)) | 0;
+    mid = (mid + Math.imul(ah6, bl6)) | 0;
+    hi = (hi + Math.imul(ah6, bh6)) | 0;
+    lo = (lo + Math.imul(al5, bl7)) | 0;
+    mid = (mid + Math.imul(al5, bh7)) | 0;
+    mid = (mid + Math.imul(ah5, bl7)) | 0;
+    hi = (hi + Math.imul(ah5, bh7)) | 0;
+    lo = (lo + Math.imul(al4, bl8)) | 0;
+    mid = (mid + Math.imul(al4, bh8)) | 0;
+    mid = (mid + Math.imul(ah4, bl8)) | 0;
+    hi = (hi + Math.imul(ah4, bh8)) | 0;
+    lo = (lo + Math.imul(al3, bl9)) | 0;
+    mid = (mid + Math.imul(al3, bh9)) | 0;
+    mid = (mid + Math.imul(ah3, bl9)) | 0;
+    hi = (hi + Math.imul(ah3, bh9)) | 0;
+    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;
+    w12 &= 0x3ffffff;
+    /* k = 13 */
+    lo = Math.imul(al9, bl4);
+    mid = Math.imul(al9, bh4);
+    mid = (mid + Math.imul(ah9, bl4)) | 0;
+    hi = Math.imul(ah9, bh4);
+    lo = (lo + Math.imul(al8, bl5)) | 0;
+    mid = (mid + Math.imul(al8, bh5)) | 0;
+    mid = (mid + Math.imul(ah8, bl5)) | 0;
+    hi = (hi + Math.imul(ah8, bh5)) | 0;
+    lo = (lo + Math.imul(al7, bl6)) | 0;
+    mid = (mid + Math.imul(al7, bh6)) | 0;
+    mid = (mid + Math.imul(ah7, bl6)) | 0;
+    hi = (hi + Math.imul(ah7, bh6)) | 0;
+    lo = (lo + Math.imul(al6, bl7)) | 0;
+    mid = (mid + Math.imul(al6, bh7)) | 0;
+    mid = (mid + Math.imul(ah6, bl7)) | 0;
+    hi = (hi + Math.imul(ah6, bh7)) | 0;
+    lo = (lo + Math.imul(al5, bl8)) | 0;
+    mid = (mid + Math.imul(al5, bh8)) | 0;
+    mid = (mid + Math.imul(ah5, bl8)) | 0;
+    hi = (hi + Math.imul(ah5, bh8)) | 0;
+    lo = (lo + Math.imul(al4, bl9)) | 0;
+    mid = (mid + Math.imul(al4, bh9)) | 0;
+    mid = (mid + Math.imul(ah4, bl9)) | 0;
+    hi = (hi + Math.imul(ah4, bh9)) | 0;
+    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;
+    w13 &= 0x3ffffff;
+    /* k = 14 */
+    lo = Math.imul(al9, bl5);
+    mid = Math.imul(al9, bh5);
+    mid = (mid + Math.imul(ah9, bl5)) | 0;
+    hi = Math.imul(ah9, bh5);
+    lo = (lo + Math.imul(al8, bl6)) | 0;
+    mid = (mid + Math.imul(al8, bh6)) | 0;
+    mid = (mid + Math.imul(ah8, bl6)) | 0;
+    hi = (hi + Math.imul(ah8, bh6)) | 0;
+    lo = (lo + Math.imul(al7, bl7)) | 0;
+    mid = (mid + Math.imul(al7, bh7)) | 0;
+    mid = (mid + Math.imul(ah7, bl7)) | 0;
+    hi = (hi + Math.imul(ah7, bh7)) | 0;
+    lo = (lo + Math.imul(al6, bl8)) | 0;
+    mid = (mid + Math.imul(al6, bh8)) | 0;
+    mid = (mid + Math.imul(ah6, bl8)) | 0;
+    hi = (hi + Math.imul(ah6, bh8)) | 0;
+    lo = (lo + Math.imul(al5, bl9)) | 0;
+    mid = (mid + Math.imul(al5, bh9)) | 0;
+    mid = (mid + Math.imul(ah5, bl9)) | 0;
+    hi = (hi + Math.imul(ah5, bh9)) | 0;
+    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;
+    w14 &= 0x3ffffff;
+    /* k = 15 */
+    lo = Math.imul(al9, bl6);
+    mid = Math.imul(al9, bh6);
+    mid = (mid + Math.imul(ah9, bl6)) | 0;
+    hi = Math.imul(ah9, bh6);
+    lo = (lo + Math.imul(al8, bl7)) | 0;
+    mid = (mid + Math.imul(al8, bh7)) | 0;
+    mid = (mid + Math.imul(ah8, bl7)) | 0;
+    hi = (hi + Math.imul(ah8, bh7)) | 0;
+    lo = (lo + Math.imul(al7, bl8)) | 0;
+    mid = (mid + Math.imul(al7, bh8)) | 0;
+    mid = (mid + Math.imul(ah7, bl8)) | 0;
+    hi = (hi + Math.imul(ah7, bh8)) | 0;
+    lo = (lo + Math.imul(al6, bl9)) | 0;
+    mid = (mid + Math.imul(al6, bh9)) | 0;
+    mid = (mid + Math.imul(ah6, bl9)) | 0;
+    hi = (hi + Math.imul(ah6, bh9)) | 0;
+    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;
+    w15 &= 0x3ffffff;
+    /* k = 16 */
+    lo = Math.imul(al9, bl7);
+    mid = Math.imul(al9, bh7);
+    mid = (mid + Math.imul(ah9, bl7)) | 0;
+    hi = Math.imul(ah9, bh7);
+    lo = (lo + Math.imul(al8, bl8)) | 0;
+    mid = (mid + Math.imul(al8, bh8)) | 0;
+    mid = (mid + Math.imul(ah8, bl8)) | 0;
+    hi = (hi + Math.imul(ah8, bh8)) | 0;
+    lo = (lo + Math.imul(al7, bl9)) | 0;
+    mid = (mid + Math.imul(al7, bh9)) | 0;
+    mid = (mid + Math.imul(ah7, bl9)) | 0;
+    hi = (hi + Math.imul(ah7, bh9)) | 0;
+    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;
+    w16 &= 0x3ffffff;
+    /* k = 17 */
+    lo = Math.imul(al9, bl8);
+    mid = Math.imul(al9, bh8);
+    mid = (mid + Math.imul(ah9, bl8)) | 0;
+    hi = Math.imul(ah9, bh8);
+    lo = (lo + Math.imul(al8, bl9)) | 0;
+    mid = (mid + Math.imul(al8, bh9)) | 0;
+    mid = (mid + Math.imul(ah8, bl9)) | 0;
+    hi = (hi + Math.imul(ah8, bh9)) | 0;
+    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;
+    w17 &= 0x3ffffff;
+    /* k = 18 */
+    lo = Math.imul(al9, bl9);
+    mid = Math.imul(al9, bh9);
+    mid = (mid + Math.imul(ah9, bl9)) | 0;
+    hi = Math.imul(ah9, bh9);
+    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;
+    w18 &= 0x3ffffff;
+    o[0] = w0;
+    o[1] = w1;
+    o[2] = w2;
+    o[3] = w3;
+    o[4] = w4;
+    o[5] = w5;
+    o[6] = w6;
+    o[7] = w7;
+    o[8] = w8;
+    o[9] = w9;
+    o[10] = w10;
+    o[11] = w11;
+    o[12] = w12;
+    o[13] = w13;
+    o[14] = w14;
+    o[15] = w15;
+    o[16] = w16;
+    o[17] = w17;
+    o[18] = w18;
+    if (c !== 0) {
+      o[19] = c;
+      out.length++;
+    }
+    return out;
+  };
+
+  // Polyfill comb
+  if (!Math.imul) {
+    comb10MulTo = smallMulTo;
+  }
+
+  function bigMulTo (self, num, out) {
+    out.negative = num.negative ^ self.negative;
+    out.length = self.length + num.length;
+
+    var carry = 0;
+    var hncarry = 0;
+    for (var k = 0; k < out.length - 1; k++) {
+      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
+      // note that ncarry could be >= 0x3ffffff
+      var ncarry = hncarry;
+      hncarry = 0;
+      var rword = carry & 0x3ffffff;
+      var maxJ = Math.min(k, num.length - 1);
+      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+        var i = k - j;
+        var a = self.words[i] | 0;
+        var b = num.words[j] | 0;
+        var r = a * b;
+
+        var lo = r & 0x3ffffff;
+        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
+        lo = (lo + rword) | 0;
+        rword = lo & 0x3ffffff;
+        ncarry = (ncarry + (lo >>> 26)) | 0;
+
+        hncarry += ncarry >>> 26;
+        ncarry &= 0x3ffffff;
+      }
+      out.words[k] = rword;
+      carry = ncarry;
+      ncarry = hncarry;
+    }
+    if (carry !== 0) {
+      out.words[k] = carry;
+    } else {
+      out.length--;
+    }
+
+    return out.strip();
+  }
+
+  function jumboMulTo (self, num, out) {
+    var fftm = new FFTM();
+    return fftm.mulp(self, num, out);
+  }
+
+  BN.prototype.mulTo = function mulTo (num, out) {
+    var res;
+    var len = this.length + num.length;
+    if (this.length === 10 && num.length === 10) {
+      res = comb10MulTo(this, num, out);
+    } else if (len < 63) {
+      res = smallMulTo(this, num, out);
+    } else if (len < 1024) {
+      res = bigMulTo(this, num, out);
+    } else {
+      res = jumboMulTo(this, num, out);
+    }
+
+    return res;
+  };
+
+  // Cooley-Tukey algorithm for FFT
+  // slightly revisited to rely on looping instead of recursion
+
+  function FFTM (x, y) {
+    this.x = x;
+    this.y = y;
+  }
+
+  FFTM.prototype.makeRBT = function makeRBT (N) {
+    var t = new Array(N);
+    var l = BN.prototype._countBits(N) - 1;
+    for (var i = 0; i < N; i++) {
+      t[i] = this.revBin(i, l, N);
+    }
+
+    return t;
+  };
+
+  // Returns binary-reversed representation of `x`
+  FFTM.prototype.revBin = function revBin (x, l, N) {
+    if (x === 0 || x === N - 1) return x;
+
+    var rb = 0;
+    for (var i = 0; i < l; i++) {
+      rb |= (x & 1) << (l - i - 1);
+      x >>= 1;
+    }
+
+    return rb;
+  };
+
+  // Performs "tweedling" phase, therefore 'emulating'
+  // behaviour of the recursive algorithm
+  FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {
+    for (var i = 0; i < N; i++) {
+      rtws[i] = rws[rbt[i]];
+      itws[i] = iws[rbt[i]];
+    }
+  };
+
+  FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {
+    this.permute(rbt, rws, iws, rtws, itws, N);
+
+    for (var s = 1; s < N; s <<= 1) {
+      var l = s << 1;
+
+      var rtwdf = Math.cos(2 * Math.PI / l);
+      var itwdf = Math.sin(2 * Math.PI / l);
+
+      for (var p = 0; p < N; p += l) {
+        var rtwdf_ = rtwdf;
+        var itwdf_ = itwdf;
+
+        for (var j = 0; j < s; j++) {
+          var re = rtws[p + j];
+          var ie = itws[p + j];
+
+          var ro = rtws[p + j + s];
+          var io = itws[p + j + s];
+
+          var rx = rtwdf_ * ro - itwdf_ * io;
+
+          io = rtwdf_ * io + itwdf_ * ro;
+          ro = rx;
+
+          rtws[p + j] = re + ro;
+          itws[p + j] = ie + io;
+
+          rtws[p + j + s] = re - ro;
+          itws[p + j + s] = ie - io;
+
+          /* jshint maxdepth : false */
+          if (j !== l) {
+            rx = rtwdf * rtwdf_ - itwdf * itwdf_;
+
+            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
+            rtwdf_ = rx;
+          }
+        }
+      }
+    }
+  };
+
+  FFTM.prototype.guessLen13b = function guessLen13b (n, m) {
+    var N = Math.max(m, n) | 1;
+    var odd = N & 1;
+    var i = 0;
+    for (N = N / 2 | 0; N; N = N >>> 1) {
+      i++;
+    }
+
+    return 1 << i + 1 + odd;
+  };
+
+  FFTM.prototype.conjugate = function conjugate (rws, iws, N) {
+    if (N <= 1) return;
+
+    for (var i = 0; i < N / 2; i++) {
+      var t = rws[i];
+
+      rws[i] = rws[N - i - 1];
+      rws[N - i - 1] = t;
+
+      t = iws[i];
+
+      iws[i] = -iws[N - i - 1];
+      iws[N - i - 1] = -t;
+    }
+  };
+
+  FFTM.prototype.normalize13b = function normalize13b (ws, N) {
+    var carry = 0;
+    for (var i = 0; i < N / 2; i++) {
+      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
+        Math.round(ws[2 * i] / N) +
+        carry;
+
+      ws[i] = w & 0x3ffffff;
+
+      if (w < 0x4000000) {
+        carry = 0;
+      } else {
+        carry = w / 0x4000000 | 0;
+      }
+    }
+
+    return ws;
+  };
+
+  FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {
+    var carry = 0;
+    for (var i = 0; i < len; i++) {
+      carry = carry + (ws[i] | 0);
+
+      rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;
+      rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;
+    }
+
+    // Pad with zeroes
+    for (i = 2 * len; i < N; ++i) {
+      rws[i] = 0;
+    }
+
+    assert(carry === 0);
+    assert((carry & ~0x1fff) === 0);
+  };
+
+  FFTM.prototype.stub = function stub (N) {
+    var ph = new Array(N);
+    for (var i = 0; i < N; i++) {
+      ph[i] = 0;
+    }
+
+    return ph;
+  };
+
+  FFTM.prototype.mulp = function mulp (x, y, out) {
+    var N = 2 * this.guessLen13b(x.length, y.length);
+
+    var rbt = this.makeRBT(N);
+
+    var _ = this.stub(N);
+
+    var rws = new Array(N);
+    var rwst = new Array(N);
+    var iwst = new Array(N);
+
+    var nrws = new Array(N);
+    var nrwst = new Array(N);
+    var niwst = new Array(N);
+
+    var rmws = out.words;
+    rmws.length = N;
+
+    this.convert13b(x.words, x.length, rws, N);
+    this.convert13b(y.words, y.length, nrws, N);
+
+    this.transform(rws, _, rwst, iwst, N, rbt);
+    this.transform(nrws, _, nrwst, niwst, N, rbt);
+
+    for (var i = 0; i < N; i++) {
+      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
+      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
+      rwst[i] = rx;
+    }
+
+    this.conjugate(rwst, iwst, N);
+    this.transform(rwst, iwst, rmws, _, N, rbt);
+    this.conjugate(rmws, _, N);
+    this.normalize13b(rmws, N);
+
+    out.negative = x.negative ^ y.negative;
+    out.length = x.length + y.length;
+    return out.strip();
+  };
+
+  // Multiply `this` by `num`
+  BN.prototype.mul = function mul (num) {
+    var out = new BN(null);
+    out.words = new Array(this.length + num.length);
+    return this.mulTo(num, out);
+  };
+
+  // Multiply employing FFT
+  BN.prototype.mulf = function mulf (num) {
+    var out = new BN(null);
+    out.words = new Array(this.length + num.length);
+    return jumboMulTo(this, num, out);
+  };
+
+  // In-place Multiplication
+  BN.prototype.imul = function imul (num) {
+    return this.clone().mulTo(num, this);
+  };
+
+  BN.prototype.imuln = function imuln (num) {
+    assert(typeof num === 'number');
+    assert(num < 0x4000000);
+
+    // Carry
+    var carry = 0;
+    for (var i = 0; i < this.length; i++) {
+      var w = (this.words[i] | 0) * num;
+      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
+      carry >>= 26;
+      carry += (w / 0x4000000) | 0;
+      // NOTE: lo is 27bit maximum
+      carry += lo >>> 26;
+      this.words[i] = lo & 0x3ffffff;
+    }
+
+    if (carry !== 0) {
+      this.words[i] = carry;
+      this.length++;
+    }
+
+    return this;
+  };
+
+  BN.prototype.muln = function muln (num) {
+    return this.clone().imuln(num);
+  };
+
+  // `this` * `this`
+  BN.prototype.sqr = function sqr () {
+    return this.mul(this);
+  };
+
+  // `this` * `this` in-place
+  BN.prototype.isqr = function isqr () {
+    return this.imul(this.clone());
+  };
+
+  // Math.pow(`this`, `num`)
+  BN.prototype.pow = function pow (num) {
+    var w = toBitArray(num);
+    if (w.length === 0) return new BN(1);
+
+    // Skip leading zeroes
+    var res = this;
+    for (var i = 0; i < w.length; i++, res = res.sqr()) {
+      if (w[i] !== 0) break;
+    }
+
+    if (++i < w.length) {
+      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
+        if (w[i] === 0) continue;
+
+        res = res.mul(q);
+      }
+    }
+
+    return res;
+  };
+
+  // Shift-left in-place
+  BN.prototype.iushln = function iushln (bits) {
+    assert(typeof bits === 'number' && bits >= 0);
+    var r = bits % 26;
+    var s = (bits - r) / 26;
+    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
+    var i;
+
+    if (r !== 0) {
+      var carry = 0;
+
+      for (i = 0; i < this.length; i++) {
+        var newCarry = this.words[i] & carryMask;
+        var c = ((this.words[i] | 0) - newCarry) << r;
+        this.words[i] = c | carry;
+        carry = newCarry >>> (26 - r);
+      }
+
+      if (carry) {
+        this.words[i] = carry;
+        this.length++;
+      }
+    }
+
+    if (s !== 0) {
+      for (i = this.length - 1; i >= 0; i--) {
+        this.words[i + s] = this.words[i];
+      }
+
+      for (i = 0; i < s; i++) {
+        this.words[i] = 0;
+      }
+
+      this.length += s;
+    }
+
+    return this.strip();
+  };
+
+  BN.prototype.ishln = function ishln (bits) {
+    // TODO(indutny): implement me
+    assert(this.negative === 0);
+    return this.iushln(bits);
+  };
+
+  // Shift-right in-place
+  // NOTE: `hint` is a lowest bit before trailing zeroes
+  // NOTE: if `extended` is present - it will be filled with destroyed bits
+  BN.prototype.iushrn = function iushrn (bits, hint, extended) {
+    assert(typeof bits === 'number' && bits >= 0);
+    var h;
+    if (hint) {
+      h = (hint - (hint % 26)) / 26;
+    } else {
+      h = 0;
+    }
+
+    var r = bits % 26;
+    var s = Math.min((bits - r) / 26, this.length);
+    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+    var maskedWords = extended;
+
+    h -= s;
+    h = Math.max(0, h);
+
+    // Extended mode, copy masked part
+    if (maskedWords) {
+      for (var i = 0; i < s; i++) {
+        maskedWords.words[i] = this.words[i];
+      }
+      maskedWords.length = s;
+    }
+
+    if (s === 0) {
+      // No-op, we should not move anything at all
+    } else if (this.length > s) {
+      this.length -= s;
+      for (i = 0; i < this.length; i++) {
+        this.words[i] = this.words[i + s];
+      }
+    } else {
+      this.words[0] = 0;
+      this.length = 1;
+    }
+
+    var carry = 0;
+    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
+      var word = this.words[i] | 0;
+      this.words[i] = (carry << (26 - r)) | (word >>> r);
+      carry = word & mask;
+    }
+
+    // Push carried bits as a mask
+    if (maskedWords && carry !== 0) {
+      maskedWords.words[maskedWords.length++] = carry;
+    }
+
+    if (this.length === 0) {
+      this.words[0] = 0;
+      this.length = 1;
+    }
+
+    return this.strip();
+  };
+
+  BN.prototype.ishrn = function ishrn (bits, hint, extended) {
+    // TODO(indutny): implement me
+    assert(this.negative === 0);
+    return this.iushrn(bits, hint, extended);
+  };
+
+  // Shift-left
+  BN.prototype.shln = function shln (bits) {
+    return this.clone().ishln(bits);
+  };
+
+  BN.prototype.ushln = function ushln (bits) {
+    return this.clone().iushln(bits);
+  };
+
+  // Shift-right
+  BN.prototype.shrn = function shrn (bits) {
+    return this.clone().ishrn(bits);
+  };
+
+  BN.prototype.ushrn = function ushrn (bits) {
+    return this.clone().iushrn(bits);
+  };
+
+  // Test if n bit is set
+  BN.prototype.testn = function testn (bit) {
+    assert(typeof bit === 'number' && bit >= 0);
+    var r = bit % 26;
+    var s = (bit - r) / 26;
+    var q = 1 << r;
+
+    // Fast case: bit is much higher than all existing words
+    if (this.length <= s) return false;
+
+    // Check bit and return
+    var w = this.words[s];
+
+    return !!(w & q);
+  };
+
+  // Return only lowers bits of number (in-place)
+  BN.prototype.imaskn = function imaskn (bits) {
+    assert(typeof bits === 'number' && bits >= 0);
+    var r = bits % 26;
+    var s = (bits - r) / 26;
+
+    assert(this.negative === 0, 'imaskn works only with positive numbers');
+
+    if (this.length <= s) {
+      return this;
+    }
+
+    if (r !== 0) {
+      s++;
+    }
+    this.length = Math.min(s, this.length);
+
+    if (r !== 0) {
+      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+      this.words[this.length - 1] &= mask;
+    }
+
+    return this.strip();
+  };
+
+  // Return only lowers bits of number
+  BN.prototype.maskn = function maskn (bits) {
+    return this.clone().imaskn(bits);
+  };
+
+  // Add plain number `num` to `this`
+  BN.prototype.iaddn = function iaddn (num) {
+    assert(typeof num === 'number');
+    assert(num < 0x4000000);
+    if (num < 0) return this.isubn(-num);
+
+    // Possible sign change
+    if (this.negative !== 0) {
+      if (this.length === 1 && (this.words[0] | 0) < num) {
+        this.words[0] = num - (this.words[0] | 0);
+        this.negative = 0;
+        return this;
+      }
+
+      this.negative = 0;
+      this.isubn(num);
+      this.negative = 1;
+      return this;
+    }
+
+    // Add without checks
+    return this._iaddn(num);
+  };
+
+  BN.prototype._iaddn = function _iaddn (num) {
+    this.words[0] += num;
+
+    // Carry
+    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
+      this.words[i] -= 0x4000000;
+      if (i === this.length - 1) {
+        this.words[i + 1] = 1;
+      } else {
+        this.words[i + 1]++;
+      }
+    }
+    this.length = Math.max(this.length, i + 1);
+
+    return this;
+  };
+
+  // Subtract plain number `num` from `this`
+  BN.prototype.isubn = function isubn (num) {
+    assert(typeof num === 'number');
+    assert(num < 0x4000000);
+    if (num < 0) return this.iaddn(-num);
+
+    if (this.negative !== 0) {
+      this.negative = 0;
+      this.iaddn(num);
+      this.negative = 1;
+      return this;
+    }
+
+    this.words[0] -= num;
+
+    if (this.length === 1 && this.words[0] < 0) {
+      this.words[0] = -this.words[0];
+      this.negative = 1;
+    } else {
+      // Carry
+      for (var i = 0; i < this.length && this.words[i] < 0; i++) {
+        this.words[i] += 0x4000000;
+        this.words[i + 1] -= 1;
+      }
+    }
+
+    return this.strip();
+  };
+
+  BN.prototype.addn = function addn (num) {
+    return this.clone().iaddn(num);
+  };
+
+  BN.prototype.subn = function subn (num) {
+    return this.clone().isubn(num);
+  };
+
+  BN.prototype.iabs = function iabs () {
+    this.negative = 0;
+
+    return this;
+  };
+
+  BN.prototype.abs = function abs () {
+    return this.clone().iabs();
+  };
+
+  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {
+    var len = num.length + shift;
+    var i;
+
+    this._expand(len);
+
+    var w;
+    var carry = 0;
+    for (i = 0; i < num.length; i++) {
+      w = (this.words[i + shift] | 0) + carry;
+      var right = (num.words[i] | 0) * mul;
+      w -= right & 0x3ffffff;
+      carry = (w >> 26) - ((right / 0x4000000) | 0);
+      this.words[i + shift] = w & 0x3ffffff;
+    }
+    for (; i < this.length - shift; i++) {
+      w = (this.words[i + shift] | 0) + carry;
+      carry = w >> 26;
+      this.words[i + shift] = w & 0x3ffffff;
+    }
+
+    if (carry === 0) return this.strip();
+
+    // Subtraction overflow
+    assert(carry === -1);
+    carry = 0;
+    for (i = 0; i < this.length; i++) {
+      w = -(this.words[i] | 0) + carry;
+      carry = w >> 26;
+      this.words[i] = w & 0x3ffffff;
+    }
+    this.negative = 1;
+
+    return this.strip();
+  };
+
+  BN.prototype._wordDiv = function _wordDiv (num, mode) {
+    var shift = this.length - num.length;
+
+    var a = this.clone();
+    var b = num;
+
+    // Normalize
+    var bhi = b.words[b.length - 1] | 0;
+    var bhiBits = this._countBits(bhi);
+    shift = 26 - bhiBits;
+    if (shift !== 0) {
+      b = b.ushln(shift);
+      a.iushln(shift);
+      bhi = b.words[b.length - 1] | 0;
+    }
+
+    // Initialize quotient
+    var m = a.length - b.length;
+    var q;
+
+    if (mode !== 'mod') {
+      q = new BN(null);
+      q.length = m + 1;
+      q.words = new Array(q.length);
+      for (var i = 0; i < q.length; i++) {
+        q.words[i] = 0;
+      }
+    }
+
+    var diff = a.clone()._ishlnsubmul(b, 1, m);
+    if (diff.negative === 0) {
+      a = diff;
+      if (q) {
+        q.words[m] = 1;
+      }
+    }
+
+    for (var j = m - 1; j >= 0; j--) {
+      var qj = (a.words[b.length + j] | 0) * 0x4000000 +
+        (a.words[b.length + j - 1] | 0);
+
+      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
+      // (0x7ffffff)
+      qj = Math.min((qj / bhi) | 0, 0x3ffffff);
+
+      a._ishlnsubmul(b, qj, j);
+      while (a.negative !== 0) {
+        qj--;
+        a.negative = 0;
+        a._ishlnsubmul(b, 1, j);
+        if (!a.isZero()) {
+          a.negative ^= 1;
+        }
+      }
+      if (q) {
+        q.words[j] = qj;
+      }
+    }
+    if (q) {
+      q.strip();
+    }
+    a.strip();
+
+    // Denormalize
+    if (mode !== 'div' && shift !== 0) {
+      a.iushrn(shift);
+    }
+
+    return {
+      div: q || null,
+      mod: a
+    };
+  };
+
+  // NOTE: 1) `mode` can be set to `mod` to request mod only,
+  //       to `div` to request div only, or be absent to
+  //       request both div & mod
+  //       2) `positive` is true if unsigned mod is requested
+  BN.prototype.divmod = function divmod (num, mode, positive) {
+    assert(!num.isZero());
+
+    if (this.isZero()) {
+      return {
+        div: new BN(0),
+        mod: new BN(0)
+      };
+    }
+
+    var div, mod, res;
+    if (this.negative !== 0 && num.negative === 0) {
+      res = this.neg().divmod(num, mode);
+
+      if (mode !== 'mod') {
+        div = res.div.neg();
+      }
+
+      if (mode !== 'div') {
+        mod = res.mod.neg();
+        if (positive && mod.negative !== 0) {
+          mod.iadd(num);
+        }
+      }
+
+      return {
+        div: div,
+        mod: mod
+      };
+    }
+
+    if (this.negative === 0 && num.negative !== 0) {
+      res = this.divmod(num.neg(), mode);
+
+      if (mode !== 'mod') {
+        div = res.div.neg();
+      }
+
+      return {
+        div: div,
+        mod: res.mod
+      };
+    }
+
+    if ((this.negative & num.negative) !== 0) {
+      res = this.neg().divmod(num.neg(), mode);
+
+      if (mode !== 'div') {
+        mod = res.mod.neg();
+        if (positive && mod.negative !== 0) {
+          mod.isub(num);
+        }
+      }
+
+      return {
+        div: res.div,
+        mod: mod
+      };
+    }
+
+    // Both numbers are positive at this point
+
+    // Strip both numbers to approximate shift value
+    if (num.length > this.length || this.cmp(num) < 0) {
+      return {
+        div: new BN(0),
+        mod: this
+      };
+    }
+
+    // Very short reduction
+    if (num.length === 1) {
+      if (mode === 'div') {
+        return {
+          div: this.divn(num.words[0]),
+          mod: null
+        };
+      }
+
+      if (mode === 'mod') {
+        return {
+          div: null,
+          mod: new BN(this.modn(num.words[0]))
+        };
+      }
+
+      return {
+        div: this.divn(num.words[0]),
+        mod: new BN(this.modn(num.words[0]))
+      };
+    }
+
+    return this._wordDiv(num, mode);
+  };
+
+  // Find `this` / `num`
+  BN.prototype.div = function div (num) {
+    return this.divmod(num, 'div', false).div;
+  };
+
+  // Find `this` % `num`
+  BN.prototype.mod = function mod (num) {
+    return this.divmod(num, 'mod', false).mod;
+  };
+
+  BN.prototype.umod = function umod (num) {
+    return this.divmod(num, 'mod', true).mod;
+  };
+
+  // Find Round(`this` / `num`)
+  BN.prototype.divRound = function divRound (num) {
+    var dm = this.divmod(num);
+
+    // Fast case - exact division
+    if (dm.mod.isZero()) return dm.div;
+
+    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+
+    var half = num.ushrn(1);
+    var r2 = num.andln(1);
+    var cmp = mod.cmp(half);
+
+    // Round down
+    if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
+
+    // Round up
+    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
+  };
+
+  BN.prototype.modn = function modn (num) {
+    assert(num <= 0x3ffffff);
+    var p = (1 << 26) % num;
+
+    var acc = 0;
+    for (var i = this.length - 1; i >= 0; i--) {
+      acc = (p * acc + (this.words[i] | 0)) % num;
+    }
+
+    return acc;
+  };
+
+  // In-place division by number
+  BN.prototype.idivn = function idivn (num) {
+    assert(num <= 0x3ffffff);
+
+    var carry = 0;
+    for (var i = this.length - 1; i >= 0; i--) {
+      var w = (this.words[i] | 0) + carry * 0x4000000;
+      this.words[i] = (w / num) | 0;
+      carry = w % num;
+    }
+
+    return this.strip();
+  };
+
+  BN.prototype.divn = function divn (num) {
+    return this.clone().idivn(num);
+  };
+
+  BN.prototype.egcd = function egcd (p) {
+    assert(p.negative === 0);
+    assert(!p.isZero());
+
+    var x = this;
+    var y = p.clone();
+
+    if (x.negative !== 0) {
+      x = x.umod(p);
+    } else {
+      x = x.clone();
+    }
+
+    // A * x + B * y = x
+    var A = new BN(1);
+    var B = new BN(0);
+
+    // C * x + D * y = y
+    var C = new BN(0);
+    var D = new BN(1);
+
+    var g = 0;
+
+    while (x.isEven() && y.isEven()) {
+      x.iushrn(1);
+      y.iushrn(1);
+      ++g;
+    }
+
+    var yp = y.clone();
+    var xp = x.clone();
+
+    while (!x.isZero()) {
+      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+      if (i > 0) {
+        x.iushrn(i);
+        while (i-- > 0) {
+          if (A.isOdd() || B.isOdd()) {
+            A.iadd(yp);
+            B.isub(xp);
+          }
+
+          A.iushrn(1);
+          B.iushrn(1);
+        }
+      }
+
+      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+      if (j > 0) {
+        y.iushrn(j);
+        while (j-- > 0) {
+          if (C.isOdd() || D.isOdd()) {
+            C.iadd(yp);
+            D.isub(xp);
+          }
+
+          C.iushrn(1);
+          D.iushrn(1);
+        }
+      }
+
+      if (x.cmp(y) >= 0) {
+        x.isub(y);
+        A.isub(C);
+        B.isub(D);
+      } else {
+        y.isub(x);
+        C.isub(A);
+        D.isub(B);
+      }
+    }
+
+    return {
+      a: C,
+      b: D,
+      gcd: y.iushln(g)
+    };
+  };
+
+  // This is reduced incarnation of the binary EEA
+  // above, designated to invert members of the
+  // _prime_ fields F(p) at a maximal speed
+  BN.prototype._invmp = function _invmp (p) {
+    assert(p.negative === 0);
+    assert(!p.isZero());
+
+    var a = this;
+    var b = p.clone();
+
+    if (a.negative !== 0) {
+      a = a.umod(p);
+    } else {
+      a = a.clone();
+    }
+
+    var x1 = new BN(1);
+    var x2 = new BN(0);
+
+    var delta = b.clone();
+
+    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
+      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+      if (i > 0) {
+        a.iushrn(i);
+        while (i-- > 0) {
+          if (x1.isOdd()) {
+            x1.iadd(delta);
+          }
+
+          x1.iushrn(1);
+        }
+      }
+
+      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+      if (j > 0) {
+        b.iushrn(j);
+        while (j-- > 0) {
+          if (x2.isOdd()) {
+            x2.iadd(delta);
+          }
+
+          x2.iushrn(1);
+        }
+      }
+
+      if (a.cmp(b) >= 0) {
+        a.isub(b);
+        x1.isub(x2);
+      } else {
+        b.isub(a);
+        x2.isub(x1);
+      }
+    }
+
+    var res;
+    if (a.cmpn(1) === 0) {
+      res = x1;
+    } else {
+      res = x2;
+    }
+
+    if (res.cmpn(0) < 0) {
+      res.iadd(p);
+    }
+
+    return res;
+  };
+
+  BN.prototype.gcd = function gcd (num) {
+    if (this.isZero()) return num.abs();
+    if (num.isZero()) return this.abs();
+
+    var a = this.clone();
+    var b = num.clone();
+    a.negative = 0;
+    b.negative = 0;
+
+    // Remove common factor of two
+    for (var shift = 0; a.isEven() && b.isEven(); shift++) {
+      a.iushrn(1);
+      b.iushrn(1);
+    }
+
+    do {
+      while (a.isEven()) {
+        a.iushrn(1);
+      }
+      while (b.isEven()) {
+        b.iushrn(1);
+      }
+
+      var r = a.cmp(b);
+      if (r < 0) {
+        // Swap `a` and `b` to make `a` always bigger than `b`
+        var t = a;
+        a = b;
+        b = t;
+      } else if (r === 0 || b.cmpn(1) === 0) {
+        break;
+      }
+
+      a.isub(b);
+    } while (true);
+
+    return b.iushln(shift);
+  };
+
+  // Invert number in the field F(num)
+  BN.prototype.invm = function invm (num) {
+    return this.egcd(num).a.umod(num);
+  };
+
+  BN.prototype.isEven = function isEven () {
+    return (this.words[0] & 1) === 0;
+  };
+
+  BN.prototype.isOdd = function isOdd () {
+    return (this.words[0] & 1) === 1;
+  };
+
+  // And first word and num
+  BN.prototype.andln = function andln (num) {
+    return this.words[0] & num;
+  };
+
+  // Increment at the bit position in-line
+  BN.prototype.bincn = function bincn (bit) {
+    assert(typeof bit === 'number');
+    var r = bit % 26;
+    var s = (bit - r) / 26;
+    var q = 1 << r;
+
+    // Fast case: bit is much higher than all existing words
+    if (this.length <= s) {
+      this._expand(s + 1);
+      this.words[s] |= q;
+      return this;
+    }
+
+    // Add bit and propagate, if needed
+    var carry = q;
+    for (var i = s; carry !== 0 && i < this.length; i++) {
+      var w = this.words[i] | 0;
+      w += carry;
+      carry = w >>> 26;
+      w &= 0x3ffffff;
+      this.words[i] = w;
+    }
+    if (carry !== 0) {
+      this.words[i] = carry;
+      this.length++;
+    }
+    return this;
+  };
+
+  BN.prototype.isZero = function isZero () {
+    return this.length === 1 && this.words[0] === 0;
+  };
+
+  BN.prototype.cmpn = function cmpn (num) {
+    var negative = num < 0;
+
+    if (this.negative !== 0 && !negative) return -1;
+    if (this.negative === 0 && negative) return 1;
+
+    this.strip();
+
+    var res;
+    if (this.length > 1) {
+      res = 1;
+    } else {
+      if (negative) {
+        num = -num;
+      }
+
+      assert(num <= 0x3ffffff, 'Number is too big');
+
+      var w = this.words[0] | 0;
+      res = w === num ? 0 : w < num ? -1 : 1;
+    }
+    if (this.negative !== 0) return -res | 0;
+    return res;
+  };
+
+  // Compare two numbers and return:
+  // 1 - if `this` > `num`
+  // 0 - if `this` == `num`
+  // -1 - if `this` < `num`
+  BN.prototype.cmp = function cmp (num) {
+    if (this.negative !== 0 && num.negative === 0) return -1;
+    if (this.negative === 0 && num.negative !== 0) return 1;
+
+    var res = this.ucmp(num);
+    if (this.negative !== 0) return -res | 0;
+    return res;
+  };
+
+  // Unsigned comparison
+  BN.prototype.ucmp = function ucmp (num) {
+    // At this point both numbers have the same sign
+    if (this.length > num.length) return 1;
+    if (this.length < num.length) return -1;
+
+    var res = 0;
+    for (var i = this.length - 1; i >= 0; i--) {
+      var a = this.words[i] | 0;
+      var b = num.words[i] | 0;
+
+      if (a === b) continue;
+      if (a < b) {
+        res = -1;
+      } else if (a > b) {
+        res = 1;
+      }
+      break;
+    }
+    return res;
+  };
+
+  BN.prototype.gtn = function gtn (num) {
+    return this.cmpn(num) === 1;
+  };
+
+  BN.prototype.gt = function gt (num) {
+    return this.cmp(num) === 1;
+  };
+
+  BN.prototype.gten = function gten (num) {
+    return this.cmpn(num) >= 0;
+  };
+
+  BN.prototype.gte = function gte (num) {
+    return this.cmp(num) >= 0;
+  };
+
+  BN.prototype.ltn = function ltn (num) {
+    return this.cmpn(num) === -1;
+  };
+
+  BN.prototype.lt = function lt (num) {
+    return this.cmp(num) === -1;
+  };
+
+  BN.prototype.lten = function lten (num) {
+    return this.cmpn(num) <= 0;
+  };
+
+  BN.prototype.lte = function lte (num) {
+    return this.cmp(num) <= 0;
+  };
+
+  BN.prototype.eqn = function eqn (num) {
+    return this.cmpn(num) === 0;
+  };
+
+  BN.prototype.eq = function eq (num) {
+    return this.cmp(num) === 0;
+  };
+
+  //
+  // A reduce context, could be using montgomery or something better, depending
+  // on the `m` itself.
+  //
+  BN.red = function red (num) {
+    return new Red(num);
+  };
+
+  BN.prototype.toRed = function toRed (ctx) {
+    assert(!this.red, 'Already a number in reduction context');
+    assert(this.negative === 0, 'red works only with positives');
+    return ctx.convertTo(this)._forceRed(ctx);
+  };
+
+  BN.prototype.fromRed = function fromRed () {
+    assert(this.red, 'fromRed works only with numbers in reduction context');
+    return this.red.convertFrom(this);
+  };
+
+  BN.prototype._forceRed = function _forceRed (ctx) {
+    this.red = ctx;
+    return this;
+  };
+
+  BN.prototype.forceRed = function forceRed (ctx) {
+    assert(!this.red, 'Already a number in reduction context');
+    return this._forceRed(ctx);
+  };
+
+  BN.prototype.redAdd = function redAdd (num) {
+    assert(this.red, 'redAdd works only with red numbers');
+    return this.red.add(this, num);
+  };
+
+  BN.prototype.redIAdd = function redIAdd (num) {
+    assert(this.red, 'redIAdd works only with red numbers');
+    return this.red.iadd(this, num);
+  };
+
+  BN.prototype.redSub = function redSub (num) {
+    assert(this.red, 'redSub works only with red numbers');
+    return this.red.sub(this, num);
+  };
+
+  BN.prototype.redISub = function redISub (num) {
+    assert(this.red, 'redISub works only with red numbers');
+    return this.red.isub(this, num);
+  };
+
+  BN.prototype.redShl = function redShl (num) {
+    assert(this.red, 'redShl works only with red numbers');
+    return this.red.shl(this, num);
+  };
+
+  BN.prototype.redMul = function redMul (num) {
+    assert(this.red, 'redMul works only with red numbers');
+    this.red._verify2(this, num);
+    return this.red.mul(this, num);
+  };
+
+  BN.prototype.redIMul = function redIMul (num) {
+    assert(this.red, 'redMul works only with red numbers');
+    this.red._verify2(this, num);
+    return this.red.imul(this, num);
+  };
+
+  BN.prototype.redSqr = function redSqr () {
+    assert(this.red, 'redSqr works only with red numbers');
+    this.red._verify1(this);
+    return this.red.sqr(this);
+  };
+
+  BN.prototype.redISqr = function redISqr () {
+    assert(this.red, 'redISqr works only with red numbers');
+    this.red._verify1(this);
+    return this.red.isqr(this);
+  };
+
+  // Square root over p
+  BN.prototype.redSqrt = function redSqrt () {
+    assert(this.red, 'redSqrt works only with red numbers');
+    this.red._verify1(this);
+    return this.red.sqrt(this);
+  };
+
+  BN.prototype.redInvm = function redInvm () {
+    assert(this.red, 'redInvm works only with red numbers');
+    this.red._verify1(this);
+    return this.red.invm(this);
+  };
+
+  // Return negative clone of `this` % `red modulo`
+  BN.prototype.redNeg = function redNeg () {
+    assert(this.red, 'redNeg works only with red numbers');
+    this.red._verify1(this);
+    return this.red.neg(this);
+  };
+
+  BN.prototype.redPow = function redPow (num) {
+    assert(this.red && !num.red, 'redPow(normalNum)');
+    this.red._verify1(this);
+    return this.red.pow(this, num);
+  };
+
+  // Prime numbers with efficient reduction
+  var primes = {
+    k256: null,
+    p224: null,
+    p192: null,
+    p25519: null
+  };
+
+  // Pseudo-Mersenne prime
+  function MPrime (name, p) {
+    // P = 2 ^ N - K
+    this.name = name;
+    this.p = new BN(p, 16);
+    this.n = this.p.bitLength();
+    this.k = new BN(1).iushln(this.n).isub(this.p);
+
+    this.tmp = this._tmp();
+  }
+
+  MPrime.prototype._tmp = function _tmp () {
+    var tmp = new BN(null);
+    tmp.words = new Array(Math.ceil(this.n / 13));
+    return tmp;
+  };
+
+  MPrime.prototype.ireduce = function ireduce (num) {
+    // Assumes that `num` is less than `P^2`
+    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
+    var r = num;
+    var rlen;
+
+    do {
+      this.split(r, this.tmp);
+      r = this.imulK(r);
+      r = r.iadd(this.tmp);
+      rlen = r.bitLength();
+    } while (rlen > this.n);
+
+    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
+    if (cmp === 0) {
+      r.words[0] = 0;
+      r.length = 1;
+    } else if (cmp > 0) {
+      r.isub(this.p);
+    } else {
+      r.strip();
+    }
+
+    return r;
+  };
+
+  MPrime.prototype.split = function split (input, out) {
+    input.iushrn(this.n, 0, out);
+  };
+
+  MPrime.prototype.imulK = function imulK (num) {
+    return num.imul(this.k);
+  };
+
+  function K256 () {
+    MPrime.call(
+      this,
+      'k256',
+      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
+  }
+  inherits(K256, MPrime);
+
+  K256.prototype.split = function split (input, output) {
+    // 256 = 9 * 26 + 22
+    var mask = 0x3fffff;
+
+    var outLen = Math.min(input.length, 9);
+    for (var i = 0; i < outLen; i++) {
+      output.words[i] = input.words[i];
+    }
+    output.length = outLen;
+
+    if (input.length <= 9) {
+      input.words[0] = 0;
+      input.length = 1;
+      return;
+    }
+
+    // Shift by 9 limbs
+    var prev = input.words[9];
+    output.words[output.length++] = prev & mask;
+
+    for (i = 10; i < input.length; i++) {
+      var next = input.words[i] | 0;
+      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);
+      prev = next;
+    }
+    prev >>>= 22;
+    input.words[i - 10] = prev;
+    if (prev === 0 && input.length > 10) {
+      input.length -= 10;
+    } else {
+      input.length -= 9;
+    }
+  };
+
+  K256.prototype.imulK = function imulK (num) {
+    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]
+    num.words[num.length] = 0;
+    num.words[num.length + 1] = 0;
+    num.length += 2;
+
+    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
+    var lo = 0;
+    for (var i = 0; i < num.length; i++) {
+      var w = num.words[i] | 0;
+      lo += w * 0x3d1;
+      num.words[i] = lo & 0x3ffffff;
+      lo = w * 0x40 + ((lo / 0x4000000) | 0);
+    }
+
+    // Fast length reduction
+    if (num.words[num.length - 1] === 0) {
+      num.length--;
+      if (num.words[num.length - 1] === 0) {
+        num.length--;
+      }
+    }
+    return num;
+  };
+
+  function P224 () {
+    MPrime.call(
+      this,
+      'p224',
+      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
+  }
+  inherits(P224, MPrime);
+
+  function P192 () {
+    MPrime.call(
+      this,
+      'p192',
+      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
+  }
+  inherits(P192, MPrime);
+
+  function P25519 () {
+    // 2 ^ 255 - 19
+    MPrime.call(
+      this,
+      '25519',
+      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
+  }
+  inherits(P25519, MPrime);
+
+  P25519.prototype.imulK = function imulK (num) {
+    // K = 0x13
+    var carry = 0;
+    for (var i = 0; i < num.length; i++) {
+      var hi = (num.words[i] | 0) * 0x13 + carry;
+      var lo = hi & 0x3ffffff;
+      hi >>>= 26;
+
+      num.words[i] = lo;
+      carry = hi;
+    }
+    if (carry !== 0) {
+      num.words[num.length++] = carry;
+    }
+    return num;
+  };
+
+  // Exported mostly for testing purposes, use plain name instead
+  BN._prime = function prime (name) {
+    // Cached version of prime
+    if (primes[name]) return primes[name];
+
+    var prime;
+    if (name === 'k256') {
+      prime = new K256();
+    } else if (name === 'p224') {
+      prime = new P224();
+    } else if (name === 'p192') {
+      prime = new P192();
+    } else if (name === 'p25519') {
+      prime = new P25519();
+    } else {
+      throw new Error('Unknown prime ' + name);
+    }
+    primes[name] = prime;
+
+    return prime;
+  };
+
+  //
+  // Base reduction engine
+  //
+  function Red (m) {
+    if (typeof m === 'string') {
+      var prime = BN._prime(m);
+      this.m = prime.p;
+      this.prime = prime;
+    } else {
+      assert(m.gtn(1), 'modulus must be greater than 1');
+      this.m = m;
+      this.prime = null;
+    }
+  }
+
+  Red.prototype._verify1 = function _verify1 (a) {
+    assert(a.negative === 0, 'red works only with positives');
+    assert(a.red, 'red works only with red numbers');
+  };
+
+  Red.prototype._verify2 = function _verify2 (a, b) {
+    assert((a.negative | b.negative) === 0, 'red works only with positives');
+    assert(a.red && a.red === b.red,
+      'red works only with red numbers');
+  };
+
+  Red.prototype.imod = function imod (a) {
+    if (this.prime) return this.prime.ireduce(a)._forceRed(this);
+    return a.umod(this.m)._forceRed(this);
+  };
+
+  Red.prototype.neg = function neg (a) {
+    if (a.isZero()) {
+      return a.clone();
+    }
+
+    return this.m.sub(a)._forceRed(this);
+  };
+
+  Red.prototype.add = function add (a, b) {
+    this._verify2(a, b);
+
+    var res = a.add(b);
+    if (res.cmp(this.m) >= 0) {
+      res.isub(this.m);
+    }
+    return res._forceRed(this);
+  };
+
+  Red.prototype.iadd = function iadd (a, b) {
+    this._verify2(a, b);
+
+    var res = a.iadd(b);
+    if (res.cmp(this.m) >= 0) {
+      res.isub(this.m);
+    }
+    return res;
+  };
+
+  Red.prototype.sub = function sub (a, b) {
+    this._verify2(a, b);
+
+    var res = a.sub(b);
+    if (res.cmpn(0) < 0) {
+      res.iadd(this.m);
+    }
+    return res._forceRed(this);
+  };
+
+  Red.prototype.isub = function isub (a, b) {
+    this._verify2(a, b);
+
+    var res = a.isub(b);
+    if (res.cmpn(0) < 0) {
+      res.iadd(this.m);
+    }
+    return res;
+  };
+
+  Red.prototype.shl = function shl (a, num) {
+    this._verify1(a);
+    return this.imod(a.ushln(num));
+  };
+
+  Red.prototype.imul = function imul (a, b) {
+    this._verify2(a, b);
+    return this.imod(a.imul(b));
+  };
+
+  Red.prototype.mul = function mul (a, b) {
+    this._verify2(a, b);
+    return this.imod(a.mul(b));
+  };
+
+  Red.prototype.isqr = function isqr (a) {
+    return this.imul(a, a.clone());
+  };
+
+  Red.prototype.sqr = function sqr (a) {
+    return this.mul(a, a);
+  };
+
+  Red.prototype.sqrt = function sqrt (a) {
+    if (a.isZero()) return a.clone();
+
+    var mod3 = this.m.andln(3);
+    assert(mod3 % 2 === 1);
+
+    // Fast case
+    if (mod3 === 3) {
+      var pow = this.m.add(new BN(1)).iushrn(2);
+      return this.pow(a, pow);
+    }
+
+    // Tonelli-Shanks algorithm (Totally unoptimized and slow)
+    //
+    // Find Q and S, that Q * 2 ^ S = (P - 1)
+    var q = this.m.subn(1);
+    var s = 0;
+    while (!q.isZero() && q.andln(1) === 0) {
+      s++;
+      q.iushrn(1);
+    }
+    assert(!q.isZero());
+
+    var one = new BN(1).toRed(this);
+    var nOne = one.redNeg();
+
+    // Find quadratic non-residue
+    // NOTE: Max is such because of generalized Riemann hypothesis.
+    var lpow = this.m.subn(1).iushrn(1);
+    var z = this.m.bitLength();
+    z = new BN(2 * z * z).toRed(this);
+
+    while (this.pow(z, lpow).cmp(nOne) !== 0) {
+      z.redIAdd(nOne);
+    }
+
+    var c = this.pow(z, q);
+    var r = this.pow(a, q.addn(1).iushrn(1));
+    var t = this.pow(a, q);
+    var m = s;
+    while (t.cmp(one) !== 0) {
+      var tmp = t;
+      for (var i = 0; tmp.cmp(one) !== 0; i++) {
+        tmp = tmp.redSqr();
+      }
+      assert(i < m);
+      var b = this.pow(c, new BN(1).iushln(m - i - 1));
+
+      r = r.redMul(b);
+      c = b.redSqr();
+      t = t.redMul(c);
+      m = i;
+    }
+
+    return r;
+  };
+
+  Red.prototype.invm = function invm (a) {
+    var inv = a._invmp(this.m);
+    if (inv.negative !== 0) {
+      inv.negative = 0;
+      return this.imod(inv).redNeg();
+    } else {
+      return this.imod(inv);
+    }
+  };
+
+  Red.prototype.pow = function pow (a, num) {
+    if (num.isZero()) return new BN(1).toRed(this);
+    if (num.cmpn(1) === 0) return a.clone();
+
+    var windowSize = 4;
+    var wnd = new Array(1 << windowSize);
+    wnd[0] = new BN(1).toRed(this);
+    wnd[1] = a;
+    for (var i = 2; i < wnd.length; i++) {
+      wnd[i] = this.mul(wnd[i - 1], a);
+    }
+
+    var res = wnd[0];
+    var current = 0;
+    var currentLen = 0;
+    var start = num.bitLength() % 26;
+    if (start === 0) {
+      start = 26;
+    }
+
+    for (i = num.length - 1; i >= 0; i--) {
+      var word = num.words[i];
+      for (var j = start - 1; j >= 0; j--) {
+        var bit = (word >> j) & 1;
+        if (res !== wnd[0]) {
+          res = this.sqr(res);
+        }
+
+        if (bit === 0 && current === 0) {
+          currentLen = 0;
+          continue;
+        }
+
+        current <<= 1;
+        current |= bit;
+        currentLen++;
+        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
+
+        res = this.mul(res, wnd[current]);
+        currentLen = 0;
+        current = 0;
+      }
+      start = 26;
+    }
+
+    return res;
+  };
+
+  Red.prototype.convertTo = function convertTo (num) {
+    var r = num.umod(this.m);
+
+    return r === num ? r.clone() : r;
+  };
+
+  Red.prototype.convertFrom = function convertFrom (num) {
+    var res = num.clone();
+    res.red = null;
+    return res;
+  };
+
+  //
+  // Montgomery method engine
+  //
+
+  BN.mont = function mont (num) {
+    return new Mont(num);
+  };
+
+  function Mont (m) {
+    Red.call(this, m);
+
+    this.shift = this.m.bitLength();
+    if (this.shift % 26 !== 0) {
+      this.shift += 26 - (this.shift % 26);
+    }
+
+    this.r = new BN(1).iushln(this.shift);
+    this.r2 = this.imod(this.r.sqr());
+    this.rinv = this.r._invmp(this.m);
+
+    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
+    this.minv = this.minv.umod(this.r);
+    this.minv = this.r.sub(this.minv);
+  }
+  inherits(Mont, Red);
+
+  Mont.prototype.convertTo = function convertTo (num) {
+    return this.imod(num.ushln(this.shift));
+  };
+
+  Mont.prototype.convertFrom = function convertFrom (num) {
+    var r = this.imod(num.mul(this.rinv));
+    r.red = null;
+    return r;
+  };
+
+  Mont.prototype.imul = function imul (a, b) {
+    if (a.isZero() || b.isZero()) {
+      a.words[0] = 0;
+      a.length = 1;
+      return a;
+    }
+
+    var t = a.imul(b);
+    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+    var u = t.isub(c).iushrn(this.shift);
+    var res = u;
+
+    if (u.cmp(this.m) >= 0) {
+      res = u.isub(this.m);
+    } else if (u.cmpn(0) < 0) {
+      res = u.iadd(this.m);
+    }
+
+    return res._forceRed(this);
+  };
+
+  Mont.prototype.mul = function mul (a, b) {
+    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
+
+    var t = a.mul(b);
+    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+    var u = t.isub(c).iushrn(this.shift);
+    var res = u;
+    if (u.cmp(this.m) >= 0) {
+      res = u.isub(this.m);
+    } else if (u.cmpn(0) < 0) {
+      res = u.iadd(this.m);
+    }
+
+    return res._forceRed(this);
+  };
+
+  Mont.prototype.invm = function invm (a) {
+    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R
+    var res = this.imod(a._invmp(this.m).mul(this.r2));
+    return res._forceRed(this);
+  };
+})(typeof module === 'undefined' || module, this);
+
+},{"buffer":26}],25:[function(require,module,exports){
+var r;
+
+module.exports = function rand(len) {
+  if (!r)
+    r = new Rand(null);
+
+  return r.generate(len);
+};
+
+function Rand(rand) {
+  this.rand = rand;
+}
+module.exports.Rand = Rand;
+
+Rand.prototype.generate = function generate(len) {
+  return this._rand(len);
+};
+
+// Emulate crypto API using randy
+Rand.prototype._rand = function _rand(n) {
+  if (this.rand.getBytes)
+    return this.rand.getBytes(n);
+
+  var res = new Uint8Array(n);
+  for (var i = 0; i < res.length; i++)
+    res[i] = this.rand.getByte();
+  return res;
+};
+
+if (typeof self === 'object') {
+  if (self.crypto && self.crypto.getRandomValues) {
+    // Modern browsers
+    Rand.prototype._rand = function _rand(n) {
+      var arr = new Uint8Array(n);
+      self.crypto.getRandomValues(arr);
+      return arr;
+    };
+  } else if (self.msCrypto && self.msCrypto.getRandomValues) {
+    // IE
+    Rand.prototype._rand = function _rand(n) {
+      var arr = new Uint8Array(n);
+      self.msCrypto.getRandomValues(arr);
+      return arr;
+    };
+
+  // Safari's WebWorkers do not have `crypto`
+  } else if (typeof window === 'object') {
+    // Old junk
+    Rand.prototype._rand = function() {
+      throw new Error('Not implemented yet');
+    };
+  }
+} else {
+  // Node.js or Web worker with no crypto support
+  try {
+    var crypto = require('crypto');
+    if (typeof crypto.randomBytes !== 'function')
+      throw new Error('Not supported');
+
+    Rand.prototype._rand = function _rand(n) {
+      return crypto.randomBytes(n);
+    };
+  } catch (e) {
+  }
+}
+
+},{"crypto":26}],26:[function(require,module,exports){
+arguments[4][8][0].apply(exports,arguments)
+},{"dup":8}],27:[function(require,module,exports){
+// based on the aes implimentation in triple sec
+// https://github.com/keybase/triplesec
+// which is in turn based on the one from crypto-js
+// https://code.google.com/p/crypto-js/
+
+var Buffer = require('safe-buffer').Buffer
+
+function asUInt32Array (buf) {
+  if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)
+
+  var len = (buf.length / 4) | 0
+  var out = new Array(len)
+
+  for (var i = 0; i < len; i++) {
+    out[i] = buf.readUInt32BE(i * 4)
+  }
+
+  return out
+}
+
+function scrubVec (v) {
+  for (var i = 0; i < v.length; v++) {
+    v[i] = 0
+  }
+}
+
+function cryptBlock (M, keySchedule, SUB_MIX, SBOX, nRounds) {
+  var SUB_MIX0 = SUB_MIX[0]
+  var SUB_MIX1 = SUB_MIX[1]
+  var SUB_MIX2 = SUB_MIX[2]
+  var SUB_MIX3 = SUB_MIX[3]
+
+  var s0 = M[0] ^ keySchedule[0]
+  var s1 = M[1] ^ keySchedule[1]
+  var s2 = M[2] ^ keySchedule[2]
+  var s3 = M[3] ^ keySchedule[3]
+  var t0, t1, t2, t3
+  var ksRow = 4
+
+  for (var round = 1; round < nRounds; round++) {
+    t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[(s1 >>> 16) & 0xff] ^ SUB_MIX2[(s2 >>> 8) & 0xff] ^ SUB_MIX3[s3 & 0xff] ^ keySchedule[ksRow++]
+    t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[(s2 >>> 16) & 0xff] ^ SUB_MIX2[(s3 >>> 8) & 0xff] ^ SUB_MIX3[s0 & 0xff] ^ keySchedule[ksRow++]
+    t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[(s3 >>> 16) & 0xff] ^ SUB_MIX2[(s0 >>> 8) & 0xff] ^ SUB_MIX3[s1 & 0xff] ^ keySchedule[ksRow++]
+    t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[(s0 >>> 16) & 0xff] ^ SUB_MIX2[(s1 >>> 8) & 0xff] ^ SUB_MIX3[s2 & 0xff] ^ keySchedule[ksRow++]
+    s0 = t0
+    s1 = t1
+    s2 = t2
+    s3 = t3
+  }
+
+  t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]
+  t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]
+  t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]
+  t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]
+  t0 = t0 >>> 0
+  t1 = t1 >>> 0
+  t2 = t2 >>> 0
+  t3 = t3 >>> 0
+
+  return [t0, t1, t2, t3]
+}
+
+// AES constants
+var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]
+var G = (function () {
+  // Compute double table
+  var d = new Array(256)
+  for (var j = 0; j < 256; j++) {
+    if (j < 128) {
+      d[j] = j << 1
+    } else {
+      d[j] = (j << 1) ^ 0x11b
+    }
+  }
+
+  var SBOX = []
+  var INV_SBOX = []
+  var SUB_MIX = [[], [], [], []]
+  var INV_SUB_MIX = [[], [], [], []]
+
+  // Walk GF(2^8)
+  var x = 0
+  var xi = 0
+  for (var i = 0; i < 256; ++i) {
+    // Compute sbox
+    var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4)
+    sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63
+    SBOX[x] = sx
+    INV_SBOX[sx] = x
+
+    // Compute multiplication
+    var x2 = d[x]
+    var x4 = d[x2]
+    var x8 = d[x4]
+
+    // Compute sub bytes, mix columns tables
+    var t = (d[sx] * 0x101) ^ (sx * 0x1010100)
+    SUB_MIX[0][x] = (t << 24) | (t >>> 8)
+    SUB_MIX[1][x] = (t << 16) | (t >>> 16)
+    SUB_MIX[2][x] = (t << 8) | (t >>> 24)
+    SUB_MIX[3][x] = t
+
+    // Compute inv sub bytes, inv mix columns tables
+    t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)
+    INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8)
+    INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16)
+    INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24)
+    INV_SUB_MIX[3][sx] = t
+
+    if (x === 0) {
+      x = xi = 1
+    } else {
+      x = x2 ^ d[d[d[x8 ^ x2]]]
+      xi ^= d[d[xi]]
+    }
+  }
+
+  return {
+    SBOX: SBOX,
+    INV_SBOX: INV_SBOX,
+    SUB_MIX: SUB_MIX,
+    INV_SUB_MIX: INV_SUB_MIX
+  }
+})()
+
+function AES (key) {
+  this._key = asUInt32Array(key)
+  this._reset()
+}
+
+AES.blockSize = 4 * 4
+AES.keySize = 256 / 8
+AES.prototype.blockSize = AES.blockSize
+AES.prototype.keySize = AES.keySize
+AES.prototype._reset = function () {
+  var keyWords = this._key
+  var keySize = keyWords.length
+  var nRounds = keySize + 6
+  var ksRows = (nRounds + 1) * 4
+
+  var keySchedule = []
+  for (var k = 0; k < keySize; k++) {
+    keySchedule[k] = keyWords[k]
+  }
+
+  for (k = keySize; k < ksRows; k++) {
+    var t = keySchedule[k - 1]
+
+    if (k % keySize === 0) {
+      t = (t << 8) | (t >>> 24)
+      t =
+        (G.SBOX[t >>> 24] << 24) |
+        (G.SBOX[(t >>> 16) & 0xff] << 16) |
+        (G.SBOX[(t >>> 8) & 0xff] << 8) |
+        (G.SBOX[t & 0xff])
+
+      t ^= RCON[(k / keySize) | 0] << 24
+    } else if (keySize > 6 && k % keySize === 4) {
+      t =
+        (G.SBOX[t >>> 24] << 24) |
+        (G.SBOX[(t >>> 16) & 0xff] << 16) |
+        (G.SBOX[(t >>> 8) & 0xff] << 8) |
+        (G.SBOX[t & 0xff])
+    }
+
+    keySchedule[k] = keySchedule[k - keySize] ^ t
+  }
+
+  var invKeySchedule = []
+  for (var ik = 0; ik < ksRows; ik++) {
+    var ksR = ksRows - ik
+    var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)]
+
+    if (ik < 4 || ksR <= 4) {
+      invKeySchedule[ik] = tt
+    } else {
+      invKeySchedule[ik] =
+        G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^
+        G.INV_SUB_MIX[1][G.SBOX[(tt >>> 16) & 0xff]] ^
+        G.INV_SUB_MIX[2][G.SBOX[(tt >>> 8) & 0xff]] ^
+        G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]]
+    }
+  }
+
+  this._nRounds = nRounds
+  this._keySchedule = keySchedule
+  this._invKeySchedule = invKeySchedule
+}
+
+AES.prototype.encryptBlockRaw = function (M) {
+  M = asUInt32Array(M)
+  return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds)
+}
+
+AES.prototype.encryptBlock = function (M) {
+  var out = this.encryptBlockRaw(M)
+  var buf = Buffer.allocUnsafe(16)
+  buf.writeUInt32BE(out[0], 0)
+  buf.writeUInt32BE(out[1], 4)
+  buf.writeUInt32BE(out[2], 8)
+  buf.writeUInt32BE(out[3], 12)
+  return buf
+}
+
+AES.prototype.decryptBlock = function (M) {
+  M = asUInt32Array(M)
+
+  // swap
+  var m1 = M[1]
+  M[1] = M[3]
+  M[3] = m1
+
+  var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds)
+  var buf = Buffer.allocUnsafe(16)
+  buf.writeUInt32BE(out[0], 0)
+  buf.writeUInt32BE(out[3], 4)
+  buf.writeUInt32BE(out[2], 8)
+  buf.writeUInt32BE(out[1], 12)
+  return buf
+}
+
+AES.prototype.scrub = function () {
+  scrubVec(this._keySchedule)
+  scrubVec(this._invKeySchedule)
+  scrubVec(this._key)
+}
+
+module.exports.AES = AES
+
+},{"safe-buffer":148}],28:[function(require,module,exports){
+var aes = require('./aes')
+var Buffer = require('safe-buffer').Buffer
+var Transform = require('cipher-base')
+var inherits = require('inherits')
+var GHASH = require('./ghash')
+var xor = require('buffer-xor')
+var incr32 = require('./incr32')
+
+function xorTest (a, b) {
+  var out = 0
+  if (a.length !== b.length) out++
+
+  var len = Math.min(a.length, b.length)
+  for (var i = 0; i < len; ++i) {
+    out += (a[i] ^ b[i])
+  }
+
+  return out
+}
+
+function calcIv (self, iv, ck) {
+  if (iv.length === 12) {
+    self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])])
+    return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])])
+  }
+  var ghash = new GHASH(ck)
+  var len = iv.length
+  var toPad = len % 16
+  ghash.update(iv)
+  if (toPad) {
+    toPad = 16 - toPad
+    ghash.update(Buffer.alloc(toPad, 0))
+  }
+  ghash.update(Buffer.alloc(8, 0))
+  var ivBits = len * 8
+  var tail = Buffer.alloc(8)
+  tail.writeUIntBE(ivBits, 0, 8)
+  ghash.update(tail)
+  self._finID = ghash.state
+  var out = Buffer.from(self._finID)
+  incr32(out)
+  return out
+}
+function StreamCipher (mode, key, iv, decrypt) {
+  Transform.call(this)
+
+  var h = Buffer.alloc(4, 0)
+
+  this._cipher = new aes.AES(key)
+  var ck = this._cipher.encryptBlock(h)
+  this._ghash = new GHASH(ck)
+  iv = calcIv(this, iv, ck)
+
+  this._prev = Buffer.from(iv)
+  this._cache = Buffer.allocUnsafe(0)
+  this._secCache = Buffer.allocUnsafe(0)
+  this._decrypt = decrypt
+  this._alen = 0
+  this._len = 0
+  this._mode = mode
+
+  this._authTag = null
+  this._called = false
+}
+
+inherits(StreamCipher, Transform)
+
+StreamCipher.prototype._update = function (chunk) {
+  if (!this._called && this._alen) {
+    var rump = 16 - (this._alen % 16)
+    if (rump < 16) {
+      rump = Buffer.alloc(rump, 0)
+      this._ghash.update(rump)
+    }
+  }
+
+  this._called = true
+  var out = this._mode.encrypt(this, chunk)
+  if (this._decrypt) {
+    this._ghash.update(chunk)
+  } else {
+    this._ghash.update(out)
+  }
+  this._len += chunk.length
+  return out
+}
+
+StreamCipher.prototype._final = function () {
+  if (this._decrypt && !this._authTag) throw new Error('Unsupported state or unable to authenticate data')
+
+  var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID))
+  if (this._decrypt && xorTest(tag, this._authTag)) throw new Error('Unsupported state or unable to authenticate data')
+
+  this._authTag = tag
+  this._cipher.scrub()
+}
+
+StreamCipher.prototype.getAuthTag = function getAuthTag () {
+  if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error('Attempting to get auth tag in unsupported state')
+
+  return this._authTag
+}
+
+StreamCipher.prototype.setAuthTag = function setAuthTag (tag) {
+  if (!this._decrypt) throw new Error('Attempting to set auth tag in unsupported state')
+
+  this._authTag = tag
+}
+
+StreamCipher.prototype.setAAD = function setAAD (buf) {
+  if (this._called) throw new Error('Attempting to set AAD in unsupported state')
+
+  this._ghash.update(buf)
+  this._alen += buf.length
+}
+
+module.exports = StreamCipher
+
+},{"./aes":27,"./ghash":32,"./incr32":33,"buffer-xor":54,"cipher-base":56,"inherits":107,"safe-buffer":148}],29:[function(require,module,exports){
+var ciphers = require('./encrypter')
+var deciphers = require('./decrypter')
+var modes = require('./modes/list.json')
+
+function getCiphers () {
+  return Object.keys(modes)
+}
+
+exports.createCipher = exports.Cipher = ciphers.createCipher
+exports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv
+exports.createDecipher = exports.Decipher = deciphers.createDecipher
+exports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv
+exports.listCiphers = exports.getCiphers = getCiphers
+
+},{"./decrypter":30,"./encrypter":31,"./modes/list.json":41}],30:[function(require,module,exports){
+var AuthCipher = require('./authCipher')
+var Buffer = require('safe-buffer').Buffer
+var MODES = require('./modes')
+var StreamCipher = require('./streamCipher')
+var Transform = require('cipher-base')
+var aes = require('./aes')
+var ebtk = require('evp_bytestokey')
+var inherits = require('inherits')
+
+function Decipher (mode, key, iv) {
+  Transform.call(this)
+
+  this._cache = new Splitter()
+  this._last = void 0
+  this._cipher = new aes.AES(key)
+  this._prev = Buffer.from(iv)
+  this._mode = mode
+  this._autopadding = true
+}
+
+inherits(Decipher, Transform)
+
+Decipher.prototype._update = function (data) {
+  this._cache.add(data)
+  var chunk
+  var thing
+  var out = []
+  while ((chunk = this._cache.get(this._autopadding))) {
+    thing = this._mode.decrypt(this, chunk)
+    out.push(thing)
+  }
+  return Buffer.concat(out)
+}
+
+Decipher.prototype._final = function () {
+  var chunk = this._cache.flush()
+  if (this._autopadding) {
+    return unpad(this._mode.decrypt(this, chunk))
+  } else if (chunk) {
+    throw new Error('data not multiple of block length')
+  }
+}
+
+Decipher.prototype.setAutoPadding = function (setTo) {
+  this._autopadding = !!setTo
+  return this
+}
+
+function Splitter () {
+  this.cache = Buffer.allocUnsafe(0)
+}
+
+Splitter.prototype.add = function (data) {
+  this.cache = Buffer.concat([this.cache, data])
+}
+
+Splitter.prototype.get = function (autoPadding) {
+  var out
+  if (autoPadding) {
+    if (this.cache.length > 16) {
+      out = this.cache.slice(0, 16)
+      this.cache = this.cache.slice(16)
+      return out
+    }
+  } else {
+    if (this.cache.length >= 16) {
+      out = this.cache.slice(0, 16)
+      this.cache = this.cache.slice(16)
+      return out
+    }
+  }
+
+  return null
+}
+
+Splitter.prototype.flush = function () {
+  if (this.cache.length) return this.cache
+}
+
+function unpad (last) {
+  var padded = last[15]
+  if (padded < 1 || padded > 16) {
+    throw new Error('unable to decrypt data')
+  }
+  var i = -1
+  while (++i < padded) {
+    if (last[(i + (16 - padded))] !== padded) {
+      throw new Error('unable to decrypt data')
+    }
+  }
+  if (padded === 16) return
+
+  return last.slice(0, 16 - padded)
+}
+
+function createDecipheriv (suite, password, iv) {
+  var config = MODES[suite.toLowerCase()]
+  if (!config) throw new TypeError('invalid suite type')
+
+  if (typeof iv === 'string') iv = Buffer.from(iv)
+  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)
+
+  if (typeof password === 'string') password = Buffer.from(password)
+  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)
+
+  if (config.type === 'stream') {
+    return new StreamCipher(config.module, password, iv, true)
+  } else if (config.type === 'auth') {
+    return new AuthCipher(config.module, password, iv, true)
+  }
+
+  return new Decipher(config.module, password, iv)
+}
+
+function createDecipher (suite, password) {
+  var config = MODES[suite.toLowerCase()]
+  if (!config) throw new TypeError('invalid suite type')
+
+  var keys = ebtk(password, false, config.key, config.iv)
+  return createDecipheriv(suite, keys.key, keys.iv)
+}
+
+exports.createDecipher = createDecipher
+exports.createDecipheriv = createDecipheriv
+
+},{"./aes":27,"./authCipher":28,"./modes":40,"./streamCipher":43,"cipher-base":56,"evp_bytestokey":91,"inherits":107,"safe-buffer":148}],31:[function(require,module,exports){
+var MODES = require('./modes')
+var AuthCipher = require('./authCipher')
+var Buffer = require('safe-buffer').Buffer
+var StreamCipher = require('./streamCipher')
+var Transform = require('cipher-base')
+var aes = require('./aes')
+var ebtk = require('evp_bytestokey')
+var inherits = require('inherits')
+
+function Cipher (mode, key, iv) {
+  Transform.call(this)
+
+  this._cache = new Splitter()
+  this._cipher = new aes.AES(key)
+  this._prev = Buffer.from(iv)
+  this._mode = mode
+  this._autopadding = true
+}
+
+inherits(Cipher, Transform)
+
+Cipher.prototype._update = function (data) {
+  this._cache.add(data)
+  var chunk
+  var thing
+  var out = []
+
+  while ((chunk = this._cache.get())) {
+    thing = this._mode.encrypt(this, chunk)
+    out.push(thing)
+  }
+
+  return Buffer.concat(out)
+}
+
+var PADDING = Buffer.alloc(16, 0x10)
+
+Cipher.prototype._final = function () {
+  var chunk = this._cache.flush()
+  if (this._autopadding) {
+    chunk = this._mode.encrypt(this, chunk)
+    this._cipher.scrub()
+    return chunk
+  }
+
+  if (!chunk.equals(PADDING)) {
+    this._cipher.scrub()
+    throw new Error('data not multiple of block length')
+  }
+}
+
+Cipher.prototype.setAutoPadding = function (setTo) {
+  this._autopadding = !!setTo
+  return this
+}
+
+function Splitter () {
+  this.cache = Buffer.allocUnsafe(0)
+}
+
+Splitter.prototype.add = function (data) {
+  this.cache = Buffer.concat([this.cache, data])
+}
+
+Splitter.prototype.get = function () {
+  if (this.cache.length > 15) {
+    var out = this.cache.slice(0, 16)
+    this.cache = this.cache.slice(16)
+    return out
+  }
+  return null
+}
+
+Splitter.prototype.flush = function () {
+  var len = 16 - this.cache.length
+  var padBuff = Buffer.allocUnsafe(len)
+
+  var i = -1
+  while (++i < len) {
+    padBuff.writeUInt8(len, i)
+  }
+
+  return Buffer.concat([this.cache, padBuff])
+}
+
+function createCipheriv (suite, password, iv) {
+  var config = MODES[suite.toLowerCase()]
+  if (!config) throw new TypeError('invalid suite type')
+
+  if (typeof password === 'string') password = Buffer.from(password)
+  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)
+
+  if (typeof iv === 'string') iv = Buffer.from(iv)
+  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)
+
+  if (config.type === 'stream') {
+    return new StreamCipher(config.module, password, iv)
+  } else if (config.type === 'auth') {
+    return new AuthCipher(config.module, password, iv)
+  }
+
+  return new Cipher(config.module, password, iv)
+}
+
+function createCipher (suite, password) {
+  var config = MODES[suite.toLowerCase()]
+  if (!config) throw new TypeError('invalid suite type')
+
+  var keys = ebtk(password, false, config.key, config.iv)
+  return createCipheriv(suite, keys.key, keys.iv)
+}
+
+exports.createCipheriv = createCipheriv
+exports.createCipher = createCipher
+
+},{"./aes":27,"./authCipher":28,"./modes":40,"./streamCipher":43,"cipher-base":56,"evp_bytestokey":91,"inherits":107,"safe-buffer":148}],32:[function(require,module,exports){
+var Buffer = require('safe-buffer').Buffer
+var ZEROES = Buffer.alloc(16, 0)
+
+function toArray (buf) {
+  return [
+    buf.readUInt32BE(0),
+    buf.readUInt32BE(4),
+    buf.readUInt32BE(8),
+    buf.readUInt32BE(12)
+  ]
+}
+
+function fromArray (out) {
+  var buf = Buffer.allocUnsafe(16)
+  buf.writeUInt32BE(out[0] >>> 0, 0)
+  buf.writeUInt32BE(out[1] >>> 0, 4)
+  buf.writeUInt32BE(out[2] >>> 0, 8)
+  buf.writeUInt32BE(out[3] >>> 0, 12)
+  return buf
+}
+
+function GHASH (key) {
+  this.h = key
+  this.state = Buffer.alloc(16, 0)
+  this.cache = Buffer.allocUnsafe(0)
+}
+
+// from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html
+// by Juho Vähä-Herttua
+GHASH.prototype.ghash = function (block) {
+  var i = -1
+  while (++i < block.length) {
+    this.state[i] ^= block[i]
+  }
+  this._multiply()
+}
+
+GHASH.prototype._multiply = function () {
+  var Vi = toArray(this.h)
+  var Zi = [0, 0, 0, 0]
+  var j, xi, lsbVi
+  var i = -1
+  while (++i < 128) {
+    xi = (this.state[~~(i / 8)] & (1 << (7 - (i % 8)))) !== 0
+    if (xi) {
+      // Z_i+1 = Z_i ^ V_i
+      Zi[0] ^= Vi[0]
+      Zi[1] ^= Vi[1]
+      Zi[2] ^= Vi[2]
+      Zi[3] ^= Vi[3]
+    }
+
+    // Store the value of LSB(V_i)
+    lsbVi = (Vi[3] & 1) !== 0
+
+    // V_i+1 = V_i >> 1
+    for (j = 3; j > 0; j--) {
+      Vi[j] = (Vi[j] >>> 1) | ((Vi[j - 1] & 1) << 31)
+    }
+    Vi[0] = Vi[0] >>> 1
+
+    // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R
+    if (lsbVi) {
+      Vi[0] = Vi[0] ^ (0xe1 << 24)
+    }
+  }
+  this.state = fromArray(Zi)
+}
+
+GHASH.prototype.update = function (buf) {
+  this.cache = Buffer.concat([this.cache, buf])
+  var chunk
+  while (this.cache.length >= 16) {
+    chunk = this.cache.slice(0, 16)
+    this.cache = this.cache.slice(16)
+    this.ghash(chunk)
+  }
+}
+
+GHASH.prototype.final = function (abl, bl) {
+  if (this.cache.length) {
+    this.ghash(Buffer.concat([this.cache, ZEROES], 16))
+  }
+
+  this.ghash(fromArray([0, abl, 0, bl]))
+  return this.state
+}
+
+module.exports = GHASH
+
+},{"safe-buffer":148}],33:[function(require,module,exports){
+function incr32 (iv) {
+  var len = iv.length
+  var item
+  while (len--) {
+    item = iv.readUInt8(len)
+    if (item === 255) {
+      iv.writeUInt8(0, len)
+    } else {
+      item++
+      iv.writeUInt8(item, len)
+      break
+    }
+  }
+}
+module.exports = incr32
+
+},{}],34:[function(require,module,exports){
+var xor = require('buffer-xor')
+
+exports.encrypt = function (self, block) {
+  var data = xor(block, self._prev)
+
+  self._prev = self._cipher.encryptBlock(data)
+  return self._prev
+}
+
+exports.decrypt = function (self, block) {
+  var pad = self._prev
+
+  self._prev = block
+  var out = self._cipher.decryptBlock(block)
+
+  return xor(out, pad)
+}
+
+},{"buffer-xor":54}],35:[function(require,module,exports){
+var Buffer = require('safe-buffer').Buffer
+var xor = require('buffer-xor')
+
+function encryptStart (self, data, decrypt) {
+  var len = data.length
+  var out = xor(data, self._cache)
+  self._cache = self._cache.slice(len)
+  self._prev = Buffer.concat([self._prev, decrypt ? data : out])
+  return out
+}
+
+exports.encrypt = function (self, data, decrypt) {
+  var out = Buffer.allocUnsafe(0)
+  var len
+
+  while (data.length) {
+    if (self._cache.length === 0) {
+      self._cache = self._cipher.encryptBlock(self._prev)
+      self._prev = Buffer.allocUnsafe(0)
+    }
+
+    if (self._cache.length <= data.length) {
+      len = self._cache.length
+      out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)])
+      data = data.slice(len)
+    } else {
+      out = Buffer.concat([out, encryptStart(self, data, decrypt)])
+      break
+    }
+  }
+
+  return out
+}
+
+},{"buffer-xor":54,"safe-buffer":148}],36:[function(require,module,exports){
+var Buffer = require('safe-buffer').Buffer
+
+function encryptByte (self, byteParam, decrypt) {
+  var pad
+  var i = -1
+  var len = 8
+  var out = 0
+  var bit, value
+  while (++i < len) {
+    pad = self._cipher.encryptBlock(self._prev)
+    bit = (byteParam & (1 << (7 - i))) ? 0x80 : 0
+    value = pad[0] ^ bit
+    out += ((value & 0x80) >> (i % 8))
+    self._prev = shiftIn(self._prev, decrypt ? bit : value)
+  }
+  return out
+}
+
+function shiftIn (buffer, value) {
+  var len = buffer.length
+  var i = -1
+  var out = Buffer.allocUnsafe(buffer.length)
+  buffer = Buffer.concat([buffer, Buffer.from([value])])
+
+  while (++i < len) {
+    out[i] = buffer[i] << 1 | buffer[i + 1] >> (7)
+  }
+
+  return out
+}
+
+exports.encrypt = function (self, chunk, decrypt) {
+  var len = chunk.length
+  var out = Buffer.allocUnsafe(len)
+  var i = -1
+
+  while (++i < len) {
+    out[i] = encryptByte(self, chunk[i], decrypt)
+  }
+
+  return out
+}
+
+},{"safe-buffer":148}],37:[function(require,module,exports){
+var Buffer = require('safe-buffer').Buffer
+
+function encryptByte (self, byteParam, decrypt) {
+  var pad = self._cipher.encryptBlock(self._prev)
+  var out = pad[0] ^ byteParam
+
+  self._prev = Buffer.concat([
+    self._prev.slice(1),
+    Buffer.from([decrypt ? byteParam : out])
+  ])
+
+  return out
+}
+
+exports.encrypt = function (self, chunk, decrypt) {
+  var len = chunk.length
+  var out = Buffer.allocUnsafe(len)
+  var i = -1
+
+  while (++i < len) {
+    out[i] = encryptByte(self, chunk[i], decrypt)
+  }
+
+  return out
+}
+
+},{"safe-buffer":148}],38:[function(require,module,exports){
+var xor = require('buffer-xor')
+var Buffer = require('safe-buffer').Buffer
+var incr32 = require('../incr32')
+
+function getBlock (self) {
+  var out = self._cipher.encryptBlockRaw(self._prev)
+  incr32(self._prev)
+  return out
+}
+
+var blockSize = 16
+exports.encrypt = function (self, chunk) {
+  var chunkNum = Math.ceil(chunk.length / blockSize)
+  var start = self._cache.length
+  self._cache = Buffer.concat([
+    self._cache,
+    Buffer.allocUnsafe(chunkNum * blockSize)
+  ])
+  for (var i = 0; i < chunkNum; i++) {
+    var out = getBlock(self)
+    var offset = start + i * blockSize
+    self._cache.writeUInt32BE(out[0], offset + 0)
+    self._cache.writeUInt32BE(out[1], offset + 4)
+    self._cache.writeUInt32BE(out[2], offset + 8)
+    self._cache.writeUInt32BE(out[3], offset + 12)
+  }
+  var pad = self._cache.slice(0, chunk.length)
+  self._cache = self._cache.slice(chunk.length)
+  return xor(chunk, pad)
+}
+
+},{"../incr32":33,"buffer-xor":54,"safe-buffer":148}],39:[function(require,module,exports){
+exports.encrypt = function (self, block) {
+  return self._cipher.encryptBlock(block)
+}
+
+exports.decrypt = function (self, block) {
+  return self._cipher.decryptBlock(block)
+}
+
+},{}],40:[function(require,module,exports){
+var modeModules = {
+  ECB: require('./ecb'),
+  CBC: require('./cbc'),
+  CFB: require('./cfb'),
+  CFB8: require('./cfb8'),
+  CFB1: require('./cfb1'),
+  OFB: require('./ofb'),
+  CTR: require('./ctr'),
+  GCM: require('./ctr')
+}
+
+var modes = require('./list.json')
+
+for (var key in modes) {
+  modes[key].module = modeModules[modes[key].mode]
+}
+
+module.exports = modes
+
+},{"./cbc":34,"./cfb":35,"./cfb1":36,"./cfb8":37,"./ctr":38,"./ecb":39,"./list.json":41,"./ofb":42}],41:[function(require,module,exports){
+module.exports={
+  "aes-128-ecb": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 0,
+    "mode": "ECB",
+    "type": "block"
+  },
+  "aes-192-ecb": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 0,
+    "mode": "ECB",
+    "type": "block"
+  },
+  "aes-256-ecb": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 0,
+    "mode": "ECB",
+    "type": "block"
+  },
+  "aes-128-cbc": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 16,
+    "mode": "CBC",
+    "type": "block"
+  },
+  "aes-192-cbc": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 16,
+    "mode": "CBC",
+    "type": "block"
+  },
+  "aes-256-cbc": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 16,
+    "mode": "CBC",
+    "type": "block"
+  },
+  "aes128": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 16,
+    "mode": "CBC",
+    "type": "block"
+  },
+  "aes192": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 16,
+    "mode": "CBC",
+    "type": "block"
+  },
+  "aes256": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 16,
+    "mode": "CBC",
+    "type": "block"
+  },
+  "aes-128-cfb": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 16,
+    "mode": "CFB",
+    "type": "stream"
+  },
+  "aes-192-cfb": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 16,
+    "mode": "CFB",
+    "type": "stream"
+  },
+  "aes-256-cfb": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 16,
+    "mode": "CFB",
+    "type": "stream"
+  },
+  "aes-128-cfb8": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 16,
+    "mode": "CFB8",
+    "type": "stream"
+  },
+  "aes-192-cfb8": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 16,
+    "mode": "CFB8",
+    "type": "stream"
+  },
+  "aes-256-cfb8": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 16,
+    "mode": "CFB8",
+    "type": "stream"
+  },
+  "aes-128-cfb1": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 16,
+    "mode": "CFB1",
+    "type": "stream"
+  },
+  "aes-192-cfb1": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 16,
+    "mode": "CFB1",
+    "type": "stream"
+  },
+  "aes-256-cfb1": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 16,
+    "mode": "CFB1",
+    "type": "stream"
+  },
+  "aes-128-ofb": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 16,
+    "mode": "OFB",
+    "type": "stream"
+  },
+  "aes-192-ofb": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 16,
+    "mode": "OFB",
+    "type": "stream"
+  },
+  "aes-256-ofb": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 16,
+    "mode": "OFB",
+    "type": "stream"
+  },
+  "aes-128-ctr": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 16,
+    "mode": "CTR",
+    "type": "stream"
+  },
+  "aes-192-ctr": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 16,
+    "mode": "CTR",
+    "type": "stream"
+  },
+  "aes-256-ctr": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 16,
+    "mode": "CTR",
+    "type": "stream"
+  },
+  "aes-128-gcm": {
+    "cipher": "AES",
+    "key": 128,
+    "iv": 12,
+    "mode": "GCM",
+    "type": "auth"
+  },
+  "aes-192-gcm": {
+    "cipher": "AES",
+    "key": 192,
+    "iv": 12,
+    "mode": "GCM",
+    "type": "auth"
+  },
+  "aes-256-gcm": {
+    "cipher": "AES",
+    "key": 256,
+    "iv": 12,
+    "mode": "GCM",
+    "type": "auth"
+  }
+}
+
+},{}],42:[function(require,module,exports){
+(function (Buffer){
+var xor = require('buffer-xor')
+
+function getBlock (self) {
+  self._prev = self._cipher.encryptBlock(self._prev)
+  return self._prev
+}
+
+exports.encrypt = function (self, chunk) {
+  while (self._cache.length < chunk.length) {
+    self._cache = Buffer.concat([self._cache, getBlock(self)])
+  }
+
+  var pad = self._cache.slice(0, chunk.length)
+  self._cache = self._cache.slice(chunk.length)
+  return xor(chunk, pad)
+}
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":55,"buffer-xor":54}],43:[function(require,module,exports){
+var aes = require('./aes')
+var Buffer = require('safe-buffer').Buffer
+var Transform = require('cipher-base')
+var inherits = require('inherits')
+
+function StreamCipher (mode, key, iv, decrypt) {
+  Transform.call(this)
+
+  this._cipher = new aes.AES(key)
+  this._prev = Buffer.from(iv)
+  this._cache = Buffer.allocUnsafe(0)
+  this._secCache = Buffer.allocUnsafe(0)
+  this._decrypt = decrypt
+  this._mode = mode
+}
+
+inherits(StreamCipher, Transform)
+
+StreamCipher.prototype._update = function (chunk) {
+  return this._mode.encrypt(this, chunk, this._decrypt)
+}
+
+StreamCipher.prototype._final = function () {
+  this._cipher.scrub()
+}
+
+module.exports = StreamCipher
+
+},{"./aes":27,"cipher-base":56,"inherits":107,"safe-buffer":148}],44:[function(require,module,exports){
+var DES = require('browserify-des')
+var aes = require('browserify-aes/browser')
+var aesModes = require('browserify-aes/modes')
+var desModes = require('browserify-des/modes')
+var ebtk = require('evp_bytestokey')
+
+function createCipher (suite, password) {
+  suite = suite.toLowerCase()
+
+  var keyLen, ivLen
+  if (aesModes[suite]) {
+    keyLen = aesModes[suite].key
+    ivLen = aesModes[suite].iv
+  } else if (desModes[suite]) {
+    keyLen = desModes[suite].key * 8
+    ivLen = desModes[suite].iv
+  } else {
+    throw new TypeError('invalid suite type')
+  }
+
+  var keys = ebtk(password, false, keyLen, ivLen)
+  return createCipheriv(suite, keys.key, keys.iv)
+}
+
+function createDecipher (suite, password) {
+  suite = suite.toLowerCase()
+
+  var keyLen, ivLen
+  if (aesModes[suite]) {
+    keyLen = aesModes[suite].key
+    ivLen = aesModes[suite].iv
+  } else if (desModes[suite]) {
+    keyLen = desModes[suite].key * 8
+    ivLen = desModes[suite].iv
+  } else {
+    throw new TypeError('invalid suite type')
+  }
+
+  var keys = ebtk(password, false, keyLen, ivLen)
+  return createDecipheriv(suite, keys.key, keys.iv)
+}
+
+function createCipheriv (suite, key, iv) {
+  suite = suite.toLowerCase()
+  if (aesModes[suite]) return aes.createCipheriv(suite, key, iv)
+  if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite })
+
+  throw new TypeError('invalid suite type')
+}
+
+function createDecipheriv (suite, key, iv) {
+  suite = suite.toLowerCase()
+  if (aesModes[suite]) return aes.createDecipheriv(suite, key, iv)
+  if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite, decrypt: true })
+
+  throw new TypeError('invalid suite type')
+}
+
+function getCiphers () {
+  return Object.keys(desModes).concat(aes.getCiphers())
+}
+
+exports.createCipher = exports.Cipher = createCipher
+exports.createCipheriv = exports.Cipheriv = createCipheriv
+exports.createDecipher = exports.Decipher = createDecipher
+exports.createDecipheriv = exports.Decipheriv = createDecipheriv
+exports.listCiphers = exports.getCiphers = getCiphers
+
+},{"browserify-aes/browser":29,"browserify-aes/modes":40,"browserify-des":45,"browserify-des/modes":46,"evp_bytestokey":91}],45:[function(require,module,exports){
+(function (Buffer){
+var CipherBase = require('cipher-base')
+var des = require('des.js')
+var inherits = require('inherits')
+
+var modes = {
+  'des-ede3-cbc': des.CBC.instantiate(des.EDE),
+  'des-ede3': des.EDE,
+  'des-ede-cbc': des.CBC.instantiate(des.EDE),
+  'des-ede': des.EDE,
+  'des-cbc': des.CBC.instantiate(des.DES),
+  'des-ecb': des.DES
+}
+modes.des = modes['des-cbc']
+modes.des3 = modes['des-ede3-cbc']
+module.exports = DES
+inherits(DES, CipherBase)
+function DES (opts) {
+  CipherBase.call(this)
+  var modeName = opts.mode.toLowerCase()
+  var mode = modes[modeName]
+  var type
+  if (opts.decrypt) {
+    type = 'decrypt'
+  } else {
+    type = 'encrypt'
+  }
+  var key = opts.key
+  if (modeName === 'des-ede' || modeName === 'des-ede-cbc') {
+    key = Buffer.concat([key, key.slice(0, 8)])
+  }
+  var iv = opts.iv
+  this._des = mode.create({
+    key: key,
+    iv: iv,
+    type: type
+  })
+}
+DES.prototype._update = function (data) {
+  return new Buffer(this._des.update(data))
+}
+DES.prototype._final = function () {
+  return new Buffer(this._des.final())
+}
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":55,"cipher-base":56,"des.js":64,"inherits":107}],46:[function(require,module,exports){
+exports['des-ecb'] = {
+  key: 8,
+  iv: 0
+}
+exports['des-cbc'] = exports.des = {
+  key: 8,
+  iv: 8
+}
+exports['des-ede3-cbc'] = exports.des3 = {
+  key: 24,
+  iv: 8
+}
+exports['des-ede3'] = {
+  key: 24,
+  iv: 0
+}
+exports['des-ede-cbc'] = {
+  key: 16,
+  iv: 8
+}
+exports['des-ede'] = {
+  key: 16,
+  iv: 0
+}
+
+},{}],47:[function(require,module,exports){
+(function (Buffer){
+var bn = require('bn.js');
+var randomBytes = require('randombytes');
+module.exports = crt;
+function blind(priv) {
+  var r = getr(priv);
+  var blinder = r.toRed(bn.mont(priv.modulus))
+  .redPow(new bn(priv.publicExponent)).fromRed();
+  return {
+    blinder: blinder,
+    unblinder:r.invm(priv.modulus)
+  };
+}
+function crt(msg, priv) {
+  var blinds = blind(priv);
+  var len = priv.modulus.byteLength();
+  var mod = bn.mont(priv.modulus);
+  var blinded = new bn(msg).mul(blinds.blinder).umod(priv.modulus);
+  var c1 = blinded.toRed(bn.mont(priv.prime1));
+  var c2 = blinded.toRed(bn.mont(priv.prime2));
+  var qinv = priv.coefficient;
+  var p = priv.prime1;
+  var q = priv.prime2;
+  var m1 = c1.redPow(priv.exponent1);
+  var m2 = c2.redPow(priv.exponent2);
+  m1 = m1.fromRed();
+  m2 = m2.fromRed();
+  var h = m1.isub(m2).imul(qinv).umod(p);
+  h.imul(q);
+  m2.iadd(h);
+  return new Buffer(m2.imul(blinds.unblinder).umod(priv.modulus).toArray(false, len));
+}
+crt.getr = getr;
+function getr(priv) {
+  var len = priv.modulus.byteLength();
+  var r = new bn(randomBytes(len));
+  while (r.cmp(priv.modulus) >=  0 || !r.umod(priv.prime1) || !r.umod(priv.prime2)) {
+    r = new bn(randomBytes(len));
+  }
+  return r;
+}
+
+}).call(this,require("buffer").Buffer)
+},{"bn.js":24,"buffer":55,"randombytes":132}],48:[function(require,module,exports){
+module.exports = require('./browser/algorithms.json')
+
+},{"./browser/algorithms.json":49}],49:[function(require,module,exports){
+module.exports={
+  "sha224WithRSAEncryption": {
+    "sign": "rsa",
+    "hash": "sha224",
+    "id": "302d300d06096086480165030402040500041c"
+  },
+  "RSA-SHA224": {
+    "sign": "ecdsa/rsa",
+    "hash": "sha224",
+    "id": "302d300d06096086480165030402040500041c"
+  },
+  "sha256WithRSAEncryption": {
+    "sign": "rsa",
+    "hash": "sha256",
+    "id": "3031300d060960864801650304020105000420"
+  },
+  "RSA-SHA256": {
+    "sign": "ecdsa/rsa",
+    "hash": "sha256",
+    "id": "3031300d060960864801650304020105000420"
+  },
+  "sha384WithRSAEncryption": {
+    "sign": "rsa",
+    "hash": "sha384",
+    "id": "3041300d060960864801650304020205000430"
+  },
+  "RSA-SHA384": {
+    "sign": "ecdsa/rsa",
+    "hash": "sha384",
+    "id": "3041300d060960864801650304020205000430"
+  },
+  "sha512WithRSAEncryption": {
+    "sign": "rsa",
+    "hash": "sha512",
+    "id": "3051300d060960864801650304020305000440"
+  },
+  "RSA-SHA512": {
+    "sign": "ecdsa/rsa",
+    "hash": "sha512",
+    "id": "3051300d060960864801650304020305000440"
+  },
+  "RSA-SHA1": {
+    "sign": "rsa",
+    "hash": "sha1",
+    "id": "3021300906052b0e03021a05000414"
+  },
+  "ecdsa-with-SHA1": {
+    "sign": "ecdsa",
+    "hash": "sha1",
+    "id": ""
+  },
+  "sha256": {
+    "sign": "ecdsa",
+    "hash": "sha256",
+    "id": ""
+  },
+  "sha224": {
+    "sign": "ecdsa",
+    "hash": "sha224",
+    "id": ""
+  },
+  "sha384": {
+    "sign": "ecdsa",
+    "hash": "sha384",
+    "id": ""
+  },
+  "sha512": {
+    "sign": "ecdsa",
+    "hash": "sha512",
+    "id": ""
+  },
+  "DSA-SHA": {
+    "sign": "dsa",
+    "hash": "sha1",
+    "id": ""
+  },
+  "DSA-SHA1": {
+    "sign": "dsa",
+    "hash": "sha1",
+    "id": ""
+  },
+  "DSA": {
+    "sign": "dsa",
+    "hash": "sha1",
+    "id": ""
+  },
+  "DSA-WITH-SHA224": {
+    "sign": "dsa",
+    "hash": "sha224",
+    "id": ""
+  },
+  "DSA-SHA224": {
+    "sign": "dsa",
+    "hash": "sha224",
+    "id": ""
+  },
+  "DSA-WITH-SHA256": {
+    "sign": "dsa",
+    "hash": "sha256",
+    "id": ""
+  },
+  "DSA-SHA256": {
+    "sign": "dsa",
+    "hash": "sha256",
+    "id": ""
+  },
+  "DSA-WITH-SHA384": {
+    "sign": "dsa",
+    "hash": "sha384",
+    "id": ""
+  },
+  "DSA-SHA384": {
+    "sign": "dsa",
+    "hash": "sha384",
+    "id": ""
+  },
+  "DSA-WITH-SHA512": {
+    "sign": "dsa",
+    "hash": "sha512",
+    "id": ""
+  },
+  "DSA-SHA512": {
+    "sign": "dsa",
+    "hash": "sha512",
+    "id": ""
+  },
+  "DSA-RIPEMD160": {
+    "sign": "dsa",
+    "hash": "rmd160",
+    "id": ""
+  },
+  "ripemd160WithRSA": {
+    "sign": "rsa",
+    "hash": "rmd160",
+    "id": "3021300906052b2403020105000414"
+  },
+  "RSA-RIPEMD160": {
+    "sign": "rsa",
+    "hash": "rmd160",
+    "id": "3021300906052b2403020105000414"
+  },
+  "md5WithRSAEncryption": {
+    "sign": "rsa",
+    "hash": "md5",
+    "id": "3020300c06082a864886f70d020505000410"
+  },
+  "RSA-MD5": {
+    "sign": "rsa",
+    "hash": "md5",
+    "id": "3020300c06082a864886f70d020505000410"
+  }
+}
+
+},{}],50:[function(require,module,exports){
+module.exports={
+  "1.3.132.0.10": "secp256k1",
+  "1.3.132.0.33": "p224",
+  "1.2.840.10045.3.1.1": "p192",
+  "1.2.840.10045.3.1.7": "p256",
+  "1.3.132.0.34": "p384",
+  "1.3.132.0.35": "p521"
+}
+
+},{}],51:[function(require,module,exports){
+(function (Buffer){
+var createHash = require('create-hash')
+var stream = require('stream')
+var inherits = require('inherits')
+var sign = require('./sign')
+var verify = require('./verify')
+
+var algorithms = require('./algorithms.json')
+Object.keys(algorithms).forEach(function (key) {
+  algorithms[key].id = new Buffer(algorithms[key].id, 'hex')
+  algorithms[key.toLowerCase()] = algorithms[key]
+})
+
+function Sign (algorithm) {
+  stream.Writable.call(this)
+
+  var data = algorithms[algorithm]
+  if (!data) throw new Error('Unknown message digest')
+
+  this._hashType = data.hash
+  this._hash = createHash(data.hash)
+  this._tag = data.id
+  this._signType = data.sign
+}
+inherits(Sign, stream.Writable)
+
+Sign.prototype._write = function _write (data, _, done) {
+  this._hash.update(data)
+  done()
+}
+
+Sign.prototype.update = function update (data, enc) {
+  if (typeof data === 'string') data = new Buffer(data, enc)
+
+  this._hash.update(data)
+  return this
+}
+
+Sign.prototype.sign = function signMethod (key, enc) {
+  this.end()
+  var hash = this._hash.digest()
+  var sig = sign(hash, key, this._hashType, this._signType, this._tag)
+
+  return enc ? sig.toString(enc) : sig
+}
+
+function Verify (algorithm) {
+  stream.Writable.call(this)
+
+  var data = algorithms[algorithm]
+  if (!data) throw new Error('Unknown message digest')
+
+  this._hash = createHash(data.hash)
+  this._tag = data.id
+  this._signType = data.sign
+}
+inherits(Verify, stream.Writable)
+
+Verify.prototype._write = function _write (data, _, done) {
+  this._hash.update(data)
+  done()
+}
+
+Verify.prototype.update = function update (data, enc) {
+  if (typeof data === 'string') data = new Buffer(data, enc)
+
+  this._hash.update(data)
+  return this
+}
+
+Verify.prototype.verify = function verifyMethod (key, sig, enc) {
+  if (typeof sig === 'string') sig = new Buffer(sig, enc)
+
+  this.end()
+  var hash = this._hash.digest()
+  return verify(sig, hash, key, this._signType, this._tag)
+}
+
+function createSign (algorithm) {
+  return new Sign(algorithm)
+}
+
+function createVerify (algorithm) {
+  return new Verify(algorithm)
+}
+
+module.exports = {
+  Sign: createSign,
+  Verify: createVerify,
+  createSign: createSign,
+  createVerify: createVerify
+}
+
+}).call(this,require("buffer").Buffer)
+},{"./algorithms.json":49,"./sign":52,"./verify":53,"buffer":55,"create-hash":59,"inherits":107,"stream":157}],52:[function(require,module,exports){
+(function (Buffer){
+// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
+var createHmac = require('create-hmac')
+var crt = require('browserify-rsa')
+var EC = require('elliptic').ec
+var BN = require('bn.js')
+var parseKeys = require('parse-asn1')
+var curves = require('./curves.json')
+
+function sign (hash, key, hashType, signType, tag) {
+  var priv = parseKeys(key)
+  if (priv.curve) {
+    // rsa keys can be interpreted as ecdsa ones in openssl
+    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')
+    return ecSign(hash, priv)
+  } else if (priv.type === 'dsa') {
+    if (signType !== 'dsa') throw new Error('wrong private key type')
+    return dsaSign(hash, priv, hashType)
+  } else {
+    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')
+  }
+  hash = Buffer.concat([tag, hash])
+  var len = priv.modulus.byteLength()
+  var pad = [ 0, 1 ]
+  while (hash.length + pad.length + 1 < len) pad.push(0xff)
+  pad.push(0x00)
+  var i = -1
+  while (++i < hash.length) pad.push(hash[i])
+
+  var out = crt(pad, priv)
+  return out
+}
+
+function ecSign (hash, priv) {
+  var curveId = curves[priv.curve.join('.')]
+  if (!curveId) throw new Error('unknown curve ' + priv.curve.join('.'))
+
+  var curve = new EC(curveId)
+  var key = curve.keyFromPrivate(priv.privateKey)
+  var out = key.sign(hash)
+
+  return new Buffer(out.toDER())
+}
+
+function dsaSign (hash, priv, algo) {
+  var x = priv.params.priv_key
+  var p = priv.params.p
+  var q = priv.params.q
+  var g = priv.params.g
+  var r = new BN(0)
+  var k
+  var H = bits2int(hash, q).mod(q)
+  var s = false
+  var kv = getKey(x, q, hash, algo)
+  while (s === false) {
+    k = makeKey(q, kv, algo)
+    r = makeR(g, k, p, q)
+    s = k.invm(q).imul(H.add(x.mul(r))).mod(q)
+    if (s.cmpn(0) === 0) {
+      s = false
+      r = new BN(0)
+    }
+  }
+  return toDER(r, s)
+}
+
+function toDER (r, s) {
+  r = r.toArray()
+  s = s.toArray()
+
+  // Pad values
+  if (r[0] & 0x80) r = [ 0 ].concat(r)
+  if (s[0] & 0x80) s = [ 0 ].concat(s)
+
+  var total = r.length + s.length + 4
+  var res = [ 0x30, total, 0x02, r.length ]
+  res = res.concat(r, [ 0x02, s.length ], s)
+  return new Buffer(res)
+}
+
+function getKey (x, q, hash, algo) {
+  x = new Buffer(x.toArray())
+  if (x.length < q.byteLength()) {
+    var zeros = new Buffer(q.byteLength() - x.length)
+    zeros.fill(0)
+    x = Buffer.concat([ zeros, x ])
+  }
+  var hlen = hash.length
+  var hbits = bits2octets(hash, q)
+  var v = new Buffer(hlen)
+  v.fill(1)
+  var k = new Buffer(hlen)
+  k.fill(0)
+  k = createHmac(algo, k).update(v).update(new Buffer([ 0 ])).update(x).update(hbits).digest()
+  v = createHmac(algo, k).update(v).digest()
+  k = createHmac(algo, k).update(v).update(new Buffer([ 1 ])).update(x).update(hbits).digest()
+  v = createHmac(algo, k).update(v).digest()
+  return { k: k, v: v }
+}
+
+function bits2int (obits, q) {
+  var bits = new BN(obits)
+  var shift = (obits.length << 3) - q.bitLength()
+  if (shift > 0) bits.ishrn(shift)
+  return bits
+}
+
+function bits2octets (bits, q) {
+  bits = bits2int(bits, q)
+  bits = bits.mod(q)
+  var out = new Buffer(bits.toArray())
+  if (out.length < q.byteLength()) {
+    var zeros = new Buffer(q.byteLength() - out.length)
+    zeros.fill(0)
+    out = Buffer.concat([ zeros, out ])
+  }
+  return out
+}
+
+function makeKey (q, kv, algo) {
+  var t
+  var k
+
+  do {
+    t = new Buffer(0)
+
+    while (t.length * 8 < q.bitLength()) {
+      kv.v = createHmac(algo, kv.k).update(kv.v).digest()
+      t = Buffer.concat([ t, kv.v ])
+    }
+
+    k = bits2int(t, q)
+    kv.k = createHmac(algo, kv.k).update(kv.v).update(new Buffer([ 0 ])).digest()
+    kv.v = createHmac(algo, kv.k).update(kv.v).digest()
+  } while (k.cmp(q) !== -1)
+
+  return k
+}
+
+function makeR (g, k, p, q) {
+  return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q)
+}
+
+module.exports = sign
+module.exports.getKey = getKey
+module.exports.makeKey = makeKey
+
+}).call(this,require("buffer").Buffer)
+},{"./curves.json":50,"bn.js":24,"browserify-rsa":47,"buffer":55,"create-hmac":61,"elliptic":74,"parse-asn1":118}],53:[function(require,module,exports){
+(function (Buffer){
+// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
+var BN = require('bn.js')
+var EC = require('elliptic').ec
+var parseKeys = require('parse-asn1')
+var curves = require('./curves.json')
+
+function verify (sig, hash, key, signType, tag) {
+  var pub = parseKeys(key)
+  if (pub.type === 'ec') {
+    // rsa keys can be interpreted as ecdsa ones in openssl
+    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type')
+    return ecVerify(sig, hash, pub)
+  } else if (pub.type === 'dsa') {
+    if (signType !== 'dsa') throw new Error('wrong public key type')
+    return dsaVerify(sig, hash, pub)
+  } else {
+    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type')
+  }
+  hash = Buffer.concat([tag, hash])
+  var len = pub.modulus.byteLength()
+  var pad = [ 1 ]
+  var padNum = 0
+  while (hash.length + pad.length + 2 < len) {
+    pad.push(0xff)
+    padNum++
+  }
+  pad.push(0x00)
+  var i = -1
+  while (++i < hash.length) {
+    pad.push(hash[i])
+  }
+  pad = new Buffer(pad)
+  var red = BN.mont(pub.modulus)
+  sig = new BN(sig).toRed(red)
+
+  sig = sig.redPow(new BN(pub.publicExponent))
+  sig = new Buffer(sig.fromRed().toArray())
+  var out = padNum < 8 ? 1 : 0
+  len = Math.min(sig.length, pad.length)
+  if (sig.length !== pad.length) out = 1
+
+  i = -1
+  while (++i < len) out |= sig[i] ^ pad[i]
+  return out === 0
+}
+
+function ecVerify (sig, hash, pub) {
+  var curveId = curves[pub.data.algorithm.curve.join('.')]
+  if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.'))
+
+  var curve = new EC(curveId)
+  var pubkey = pub.data.subjectPrivateKey.data
+
+  return curve.verify(hash, sig, pubkey)
+}
+
+function dsaVerify (sig, hash, pub) {
+  var p = pub.data.p
+  var q = pub.data.q
+  var g = pub.data.g
+  var y = pub.data.pub_key
+  var unpacked = parseKeys.signature.decode(sig, 'der')
+  var s = unpacked.s
+  var r = unpacked.r
+  checkValue(s, q)
+  checkValue(r, q)
+  var montp = BN.mont(p)
+  var w = s.invm(q)
+  var v = g.toRed(montp)
+    .redPow(new BN(hash).mul(w).mod(q))
+    .fromRed()
+    .mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed())
+    .mod(p)
+    .mod(q)
+  return v.cmp(r) === 0
+}
+
+function checkValue (b, q) {
+  if (b.cmpn(0) <= 0) throw new Error('invalid sig')
+  if (b.cmp(q) >= q) throw new Error('invalid sig')
+}
+
+module.exports = verify
+
+}).call(this,require("buffer").Buffer)
+},{"./curves.json":50,"bn.js":24,"buffer":55,"elliptic":74,"parse-asn1":118}],54:[function(require,module,exports){
+(function (Buffer){
+module.exports = function xor (a, b) {
+  var length = Math.min(a.length, b.length)
+  var buffer = new Buffer(length)
+
+  for (var i = 0; i < length; ++i) {
+    buffer[i] = a[i] ^ b[i]
+  }
+
+  return buffer
+}
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":55}],55:[function(require,module,exports){
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+/* eslint-disable no-proto */
+
+'use strict'
+
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+var K_MAX_LENGTH = 0x7fffffff
+exports.kMaxLength = K_MAX_LENGTH
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ *   === true    Use Uint8Array implementation (fastest)
+ *   === false   Print warning and recommend using `buffer` v4.x which has an 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+.
+ *
+ * We report that the browser does not support typed arrays if the are not subclassable
+ * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
+ * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
+ * for __proto__ and has a buggy typed array implementation.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
+
+if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
+    typeof console.error === 'function') {
+  console.error(
+    'This browser lacks typed array (Uint8Array) support which is required by ' +
+    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
+  )
+}
+
+function typedArraySupport () {
+  // Can typed array instances can be augmented?
+  try {
+    var arr = new Uint8Array(1)
+    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
+    return arr.foo() === 42
+  } catch (e) {
+    return false
+  }
+}
+
+Object.defineProperty(Buffer.prototype, 'parent', {
+  get: function () {
+    if (!(this instanceof Buffer)) {
+      return undefined
+    }
+    return this.buffer
+  }
+})
+
+Object.defineProperty(Buffer.prototype, 'offset', {
+  get: function () {
+    if (!(this instanceof Buffer)) {
+      return undefined
+    }
+    return this.byteOffset
+  }
+})
+
+function createBuffer (length) {
+  if (length > K_MAX_LENGTH) {
+    throw new RangeError('Invalid typed array length')
+  }
+  // Return an augmented `Uint8Array` instance
+  var buf = new Uint8Array(length)
+  buf.__proto__ = Buffer.prototype
+  return buf
+}
+
+/**
+ * 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, encodingOrOffset, length) {
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new Error(
+        'If encoding is specified then the first argument must be a string'
+      )
+    }
+    return allocUnsafe(arg)
+  }
+  return from(arg, encodingOrOffset, length)
+}
+
+// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+if (typeof Symbol !== 'undefined' && Symbol.species &&
+    Buffer[Symbol.species] === Buffer) {
+  Object.defineProperty(Buffer, Symbol.species, {
+    value: null,
+    configurable: true,
+    enumerable: false,
+    writable: false
+  })
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+function from (value, encodingOrOffset, length) {
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number')
+  }
+
+  if (isArrayBuffer(value) || (value && isArrayBuffer(value.buffer))) {
+    return fromArrayBuffer(value, encodingOrOffset, length)
+  }
+
+  if (typeof value === 'string') {
+    return fromString(value, encodingOrOffset)
+  }
+
+  return fromObject(value)
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+  return from(value, encodingOrOffset, length)
+}
+
+// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
+// https://github.com/feross/buffer/pull/148
+Buffer.prototype.__proto__ = Uint8Array.prototype
+Buffer.__proto__ = Uint8Array
+
+function assertSize (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('"size" argument must be of type number')
+  } else if (size < 0) {
+    throw new RangeError('"size" argument must not be negative')
+  }
+}
+
+function alloc (size, fill, encoding) {
+  assertSize(size)
+  if (size <= 0) {
+    return createBuffer(size)
+  }
+  if (fill !== undefined) {
+    // Only pay attention to encoding if it's a string. This
+    // prevents accidentally sending in a number that would
+    // be interpretted as a start offset.
+    return typeof encoding === 'string'
+      ? createBuffer(size).fill(fill, encoding)
+      : createBuffer(size).fill(fill)
+  }
+  return createBuffer(size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+  return alloc(size, fill, encoding)
+}
+
+function allocUnsafe (size) {
+  assertSize(size)
+  return createBuffer(size < 0 ? 0 : checked(size) | 0)
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+  return allocUnsafe(size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+  return allocUnsafe(size)
+}
+
+function fromString (string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8'
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('Unknown encoding: ' + encoding)
+  }
+
+  var length = byteLength(string, encoding) | 0
+  var buf = createBuffer(length)
+
+  var actual = buf.write(string, encoding)
+
+  if (actual !== length) {
+    // Writing a hex string, for example, that contains invalid characters will
+    // cause everything after the first invalid character to be ignored. (e.g.
+    // 'abxxcd' will be treated as 'ab')
+    buf = buf.slice(0, actual)
+  }
+
+  return buf
+}
+
+function fromArrayLike (array) {
+  var length = array.length < 0 ? 0 : checked(array.length) | 0
+  var buf = createBuffer(length)
+  for (var i = 0; i < length; i += 1) {
+    buf[i] = array[i] & 255
+  }
+  return buf
+}
+
+function fromArrayBuffer (array, byteOffset, length) {
+  if (byteOffset < 0 || array.byteLength < byteOffset) {
+    throw new RangeError('"offset" is outside of buffer bounds')
+  }
+
+  if (array.byteLength < byteOffset + (length || 0)) {
+    throw new RangeError('"length" is outside of buffer bounds')
+  }
+
+  var buf
+  if (byteOffset === undefined && length === undefined) {
+    buf = new Uint8Array(array)
+  } else if (length === undefined) {
+    buf = new Uint8Array(array, byteOffset)
+  } else {
+    buf = new Uint8Array(array, byteOffset, length)
+  }
+
+  // Return an augmented `Uint8Array` instance
+  buf.__proto__ = Buffer.prototype
+  return buf
+}
+
+function fromObject (obj) {
+  if (Buffer.isBuffer(obj)) {
+    var len = checked(obj.length) | 0
+    var buf = createBuffer(len)
+
+    if (buf.length === 0) {
+      return buf
+    }
+
+    obj.copy(buf, 0, 0, len)
+    return buf
+  }
+
+  if (obj) {
+    if (ArrayBuffer.isView(obj) || 'length' in obj) {
+      if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
+        return createBuffer(0)
+      }
+      return fromArrayLike(obj)
+    }
+
+    if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+      return fromArrayLike(obj.data)
+    }
+  }
+
+  throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object.')
+}
+
+function checked (length) {
+  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
+  // length is NaN (which is otherwise coerced to zero.)
+  if (length >= K_MAX_LENGTH) {
+    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
+  }
+  return length | 0
+}
+
+function SlowBuffer (length) {
+  if (+length != length) { // eslint-disable-line eqeqeq
+    length = 0
+  }
+  return Buffer.alloc(+length)
+}
+
+Buffer.isBuffer = function isBuffer (b) {
+  return b != null && b._isBuffer === true
+}
+
+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
+
+  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+    if (a[i] !== b[i]) {
+      x = a[i]
+      y = b[i]
+      break
+    }
+  }
+
+  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 'latin1':
+    case 'binary':
+    case 'base64':
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      return true
+    default:
+      return false
+  }
+}
+
+Buffer.concat = function concat (list, length) {
+  if (!Array.isArray(list)) {
+    throw new TypeError('"list" argument must be an Array of Buffers')
+  }
+
+  if (list.length === 0) {
+    return Buffer.alloc(0)
+  }
+
+  var i
+  if (length === undefined) {
+    length = 0
+    for (i = 0; i < list.length; ++i) {
+      length += list[i].length
+    }
+  }
+
+  var buffer = Buffer.allocUnsafe(length)
+  var pos = 0
+  for (i = 0; i < list.length; ++i) {
+    var buf = list[i]
+    if (ArrayBuffer.isView(buf)) {
+      buf = Buffer.from(buf)
+    }
+    if (!Buffer.isBuffer(buf)) {
+      throw new TypeError('"list" argument must be an Array of Buffers')
+    }
+    buf.copy(buffer, pos)
+    pos += buf.length
+  }
+  return buffer
+}
+
+function byteLength (string, encoding) {
+  if (Buffer.isBuffer(string)) {
+    return string.length
+  }
+  if (ArrayBuffer.isView(string) || isArrayBuffer(string)) {
+    return string.byteLength
+  }
+  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 'latin1':
+      case 'binary':
+        return len
+      case 'utf8':
+      case 'utf-8':
+      case undefined:
+        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
+
+  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+  // property of a typed array.
+
+  // This behaves neither like String nor Uint8Array in that we set start/end
+  // to their upper/lower bounds if the value passed is out of range.
+  // undefined is handled specially as per ECMA-262 6th Edition,
+  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+  if (start === undefined || start < 0) {
+    start = 0
+  }
+  // Return early if start > this.length. Done here to prevent potential uint32
+  // coercion fail below.
+  if (start > this.length) {
+    return ''
+  }
+
+  if (end === undefined || end > this.length) {
+    end = this.length
+  }
+
+  if (end <= 0) {
+    return ''
+  }
+
+  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+  end >>>= 0
+  start >>>= 0
+
+  if (end <= start) {
+    return ''
+  }
+
+  if (!encoding) encoding = 'utf8'
+
+  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 'latin1':
+      case 'binary':
+        return latin1Slice(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
+    }
+  }
+}
+
+// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+// reliably in a browserify context because there could be multiple different
+// copies of the 'buffer' package in use. This method works even for Buffer
+// instances that were created from another copy of the `buffer` package.
+// See: https://github.com/feross/buffer/issues/154
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+  var i = b[n]
+  b[n] = b[m]
+  b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+  var len = this.length
+  if (len % 2 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 16-bits')
+  }
+  for (var i = 0; i < len; i += 2) {
+    swap(this, i, i + 1)
+  }
+  return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+  var len = this.length
+  if (len % 4 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 32-bits')
+  }
+  for (var i = 0; i < len; i += 4) {
+    swap(this, i, i + 3)
+    swap(this, i + 1, i + 2)
+  }
+  return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+  var len = this.length
+  if (len % 8 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 64-bits')
+  }
+  for (var i = 0; i < len; i += 8) {
+    swap(this, i, i + 7)
+    swap(this, i + 1, i + 6)
+    swap(this, i + 2, i + 5)
+    swap(this, i + 3, i + 4)
+  }
+  return this
+}
+
+Buffer.prototype.toString = function toString () {
+  var length = this.length
+  if (length === 0) return ''
+  if (arguments.length === 0) return utf8Slice(this, 0, length)
+  return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString
+
+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 (target, start, end, thisStart, thisEnd) {
+  if (!Buffer.isBuffer(target)) {
+    throw new TypeError('Argument must be a Buffer')
+  }
+
+  if (start === undefined) {
+    start = 0
+  }
+  if (end === undefined) {
+    end = target ? target.length : 0
+  }
+  if (thisStart === undefined) {
+    thisStart = 0
+  }
+  if (thisEnd === undefined) {
+    thisEnd = this.length
+  }
+
+  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+    throw new RangeError('out of range index')
+  }
+
+  if (thisStart >= thisEnd && start >= end) {
+    return 0
+  }
+  if (thisStart >= thisEnd) {
+    return -1
+  }
+  if (start >= end) {
+    return 1
+  }
+
+  start >>>= 0
+  end >>>= 0
+  thisStart >>>= 0
+  thisEnd >>>= 0
+
+  if (this === target) return 0
+
+  var x = thisEnd - thisStart
+  var y = end - start
+  var len = Math.min(x, y)
+
+  var thisCopy = this.slice(thisStart, thisEnd)
+  var targetCopy = target.slice(start, end)
+
+  for (var i = 0; i < len; ++i) {
+    if (thisCopy[i] !== targetCopy[i]) {
+      x = thisCopy[i]
+      y = targetCopy[i]
+      break
+    }
+  }
+
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+  // Empty buffer means no match
+  if (buffer.length === 0) return -1
+
+  // Normalize byteOffset
+  if (typeof byteOffset === 'string') {
+    encoding = byteOffset
+    byteOffset = 0
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000
+  }
+  byteOffset = +byteOffset  // Coerce to Number.
+  if (numberIsNaN(byteOffset)) {
+    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+    byteOffset = dir ? 0 : (buffer.length - 1)
+  }
+
+  // Normalize byteOffset: negative offsets start from the end of the buffer
+  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+  if (byteOffset >= buffer.length) {
+    if (dir) return -1
+    else byteOffset = buffer.length - 1
+  } else if (byteOffset < 0) {
+    if (dir) byteOffset = 0
+    else return -1
+  }
+
+  // Normalize val
+  if (typeof val === 'string') {
+    val = Buffer.from(val, encoding)
+  }
+
+  // Finally, search either indexOf (if dir is true) or lastIndexOf
+  if (Buffer.isBuffer(val)) {
+    // Special case: looking for empty string/buffer always fails
+    if (val.length === 0) {
+      return -1
+    }
+    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+  } else if (typeof val === 'number') {
+    val = val & 0xFF // Search for a byte value [0-255]
+    if (typeof Uint8Array.prototype.indexOf === 'function') {
+      if (dir) {
+        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+      } else {
+        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+      }
+    }
+    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+  }
+
+  throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+  var indexSize = 1
+  var arrLength = arr.length
+  var valLength = val.length
+
+  if (encoding !== undefined) {
+    encoding = String(encoding).toLowerCase()
+    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+        encoding === 'utf16le' || encoding === 'utf-16le') {
+      if (arr.length < 2 || val.length < 2) {
+        return -1
+      }
+      indexSize = 2
+      arrLength /= 2
+      valLength /= 2
+      byteOffset /= 2
+    }
+  }
+
+  function read (buf, i) {
+    if (indexSize === 1) {
+      return buf[i]
+    } else {
+      return buf.readUInt16BE(i * indexSize)
+    }
+  }
+
+  var i
+  if (dir) {
+    var foundIndex = -1
+    for (i = byteOffset; i < arrLength; i++) {
+      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+        if (foundIndex === -1) foundIndex = i
+        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+      } else {
+        if (foundIndex !== -1) i -= i - foundIndex
+        foundIndex = -1
+      }
+    }
+  } else {
+    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+    for (i = byteOffset; i >= 0; i--) {
+      var found = true
+      for (var j = 0; j < valLength; j++) {
+        if (read(arr, i + j) !== read(val, j)) {
+          found = false
+          break
+        }
+      }
+      if (found) return i
+    }
+  }
+
+  return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+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
+    }
+  }
+
+  var strLen = string.length
+
+  if (length > strLen / 2) {
+    length = strLen / 2
+  }
+  for (var i = 0; i < length; ++i) {
+    var parsed = parseInt(string.substr(i * 2, 2), 16)
+    if (numberIsNaN(parsed)) return i
+    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 latin1Write (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
+    }
+  } else {
+    throw new Error(
+      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+    )
+  }
+
+  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 'latin1':
+      case 'binary':
+        return latin1Write(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 latin1Slice (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 = this.subarray(start, end)
+  // Return an augmented `Uint8Array` instance
+  newBuf.__proto__ = Buffer.prototype
+  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) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 1, this.length)
+  return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  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) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+  offset = offset >>> 0
+  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" argument must be a Buffer instance')
+  if (value > max || value < min) throw new RangeError('"value" argument 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) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 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) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 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)
+  this[offset] = (value & 0xff)
+  return offset + 1
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  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)
+  this[offset] = (value >>> 8)
+  this[offset + 1] = (value & 0xff)
+  return offset + 2
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+  this[offset + 3] = (value >>> 24)
+  this[offset + 2] = (value >>> 16)
+  this[offset + 1] = (value >>> 8)
+  this[offset] = (value & 0xff)
+  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)
+  this[offset] = (value >>> 24)
+  this[offset + 1] = (value >>> 16)
+  this[offset + 2] = (value >>> 8)
+  this[offset + 3] = (value & 0xff)
+  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 = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+      sub = 1
+    }
+    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 = 0
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+      sub = 1
+    }
+    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 (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)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  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)
+  this[offset] = (value >>> 8)
+  this[offset + 1] = (value & 0xff)
+  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)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  this[offset + 2] = (value >>> 16)
+  this[offset + 3] = (value >>> 24)
+  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
+  this[offset] = (value >>> 24)
+  this[offset + 1] = (value >>> 16)
+  this[offset + 2] = (value >>> 8)
+  this[offset + 3] = (value & 0xff)
+  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) {
+  value = +value
+  offset = offset >>> 0
+  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) {
+  value = +value
+  offset = offset >>> 0
+  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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
+  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('Index out of range')
+  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
+
+  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
+    // Use built-in when available, missing from IE11
+    this.copyWithin(targetStart, start, end)
+  } else if (this === target && start < targetStart && targetStart < end) {
+    // descending copy from end
+    for (var i = len - 1; i >= 0; --i) {
+      target[i + targetStart] = this[i + start]
+    }
+  } else {
+    Uint8Array.prototype.set.call(
+      target,
+      this.subarray(start, end),
+      targetStart
+    )
+  }
+
+  return len
+}
+
+// Usage:
+//    buffer.fill(number[, offset[, end]])
+//    buffer.fill(buffer[, offset[, end]])
+//    buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+  // Handle string cases:
+  if (typeof val === 'string') {
+    if (typeof start === 'string') {
+      encoding = start
+      start = 0
+      end = this.length
+    } else if (typeof end === 'string') {
+      encoding = end
+      end = this.length
+    }
+    if (encoding !== undefined && typeof encoding !== 'string') {
+      throw new TypeError('encoding must be a string')
+    }
+    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+      throw new TypeError('Unknown encoding: ' + encoding)
+    }
+    if (val.length === 1) {
+      var code = val.charCodeAt(0)
+      if ((encoding === 'utf8' && code < 128) ||
+          encoding === 'latin1') {
+        // Fast path: If `val` fits into a single byte, use that numeric value.
+        val = code
+      }
+    }
+  } else if (typeof val === 'number') {
+    val = val & 255
+  }
+
+  // Invalid ranges are not set to a default, so can range check early.
+  if (start < 0 || this.length < start || this.length < end) {
+    throw new RangeError('Out of range index')
+  }
+
+  if (end <= start) {
+    return this
+  }
+
+  start = start >>> 0
+  end = end === undefined ? this.length : end >>> 0
+
+  if (!val) val = 0
+
+  var i
+  if (typeof val === 'number') {
+    for (i = start; i < end; ++i) {
+      this[i] = val
+    }
+  } else {
+    var bytes = Buffer.isBuffer(val)
+      ? val
+      : new Buffer(val, encoding)
+    var len = bytes.length
+    if (len === 0) {
+      throw new TypeError('The value "' + val +
+        '" is invalid for argument "value"')
+    }
+    for (i = 0; i < end - start; ++i) {
+      this[i + start] = bytes[i % len]
+    }
+  }
+
+  return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
+
+function base64clean (str) {
+  // Node takes equal signs as end of the Base64 encoding
+  str = str.split('=')[0]
+  // Node strips out invalid characters like \n and \t from the string, base64-js does not
+  str = str.trim().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 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
+}
+
+// ArrayBuffers from another context (i.e. an iframe) do not pass the `instanceof` check
+// but they should be treated as valid. See: https://github.com/feross/buffer/issues/166
+function isArrayBuffer (obj) {
+  return obj instanceof ArrayBuffer ||
+    (obj != null && obj.constructor != null && obj.constructor.name === 'ArrayBuffer' &&
+      typeof obj.byteLength === 'number')
+}
+
+function numberIsNaN (obj) {
+  return obj !== obj // eslint-disable-line no-self-compare
+}
+
+},{"base64-js":23,"ieee754":106}],56:[function(require,module,exports){
+var Buffer = require('safe-buffer').Buffer
+var Transform = require('stream').Transform
+var StringDecoder = require('string_decoder').StringDecoder
+var inherits = require('inherits')
+
+function CipherBase (hashMode) {
+  Transform.call(this)
+  this.hashMode = typeof hashMode === 'string'
+  if (this.hashMode) {
+    this[hashMode] = this._finalOrDigest
+  } else {
+    this.final = this._finalOrDigest
+  }
+  if (this._final) {
+    this.__final = this._final
+    this._final = null
+  }
+  this._decoder = null
+  this._encoding = null
+}
+inherits(CipherBase, Transform)
+
+CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
+  if (typeof data === 'string') {
+    data = Buffer.from(data, inputEnc)
+  }
+
+  var outData = this._update(data)
+  if (this.hashMode) return this
+
+  if (outputEnc) {
+    outData = this._toString(outData, outputEnc)
+  }
+
+  return outData
+}
+
+CipherBase.prototype.setAutoPadding = function () {}
+CipherBase.prototype.getAuthTag = function () {
+  throw new Error('trying to get auth tag in unsupported state')
+}
+
+CipherBase.prototype.setAuthTag = function () {
+  throw new Error('trying to set auth tag in unsupported state')
+}
+
+CipherBase.prototype.setAAD = function () {
+  throw new Error('trying to set aad in unsupported state')
+}
+
+CipherBase.prototype._transform = function (data, _, next) {
+  var err
+  try {
+    if (this.hashMode) {
+      this._update(data)
+    } else {
+      this.push(this._update(data))
+    }
+  } catch (e) {
+    err = e
+  } finally {
+    next(err)
+  }
+}
+CipherBase.prototype._flush = function (done) {
+  var err
+  try {
+    this.push(this.__final())
+  } catch (e) {
+    err = e
+  }
+
+  done(err)
+}
+CipherBase.prototype._finalOrDigest = function (outputEnc) {
+  var outData = this.__final() || Buffer.alloc(0)
+  if (outputEnc) {
+    outData = this._toString(outData, outputEnc, true)
+  }
+  return outData
+}
+
+CipherBase.prototype._toString = function (value, enc, fin) {
+  if (!this._decoder) {
+    this._decoder = new StringDecoder(enc)
+    this._encoding = enc
+  }
+
+  if (this._encoding !== enc) throw new Error('can\'t switch encodings')
+
+  var out = this._decoder.write(value)
+  if (fin) {
+    out += this._decoder.end()
+  }
+
+  return out
+}
+
+module.exports = CipherBase
+
+},{"inherits":107,"safe-buffer":148,"stream":157,"string_decoder":158}],57:[function(require,module,exports){
+(function (Buffer){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+
+function isArray(arg) {
+  if (Array.isArray) {
+    return Array.isArray(arg);
+  }
+  return objectToString(arg) === '[object Array]';
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = Buffer.isBuffer;
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
+},{"../../is-buffer/index.js":108}],58:[function(require,module,exports){
+(function (Buffer){
+var elliptic = require('elliptic')
+var BN = require('bn.js')
+
+module.exports = function createECDH (curve) {
+  return new ECDH(curve)
+}
+
+var aliases = {
+  secp256k1: {
+    name: 'secp256k1',
+    byteLength: 32
+  },
+  secp224r1: {
+    name: 'p224',
+    byteLength: 28
+  },
+  prime256v1: {
+    name: 'p256',
+    byteLength: 32
+  },
+  prime192v1: {
+    name: 'p192',
+    byteLength: 24
+  },
+  ed25519: {
+    name: 'ed25519',
+    byteLength: 32
+  },
+  secp384r1: {
+    name: 'p384',
+    byteLength: 48
+  },
+  secp521r1: {
+    name: 'p521',
+    byteLength: 66
+  }
+}
+
+aliases.p224 = aliases.secp224r1
+aliases.p256 = aliases.secp256r1 = aliases.prime256v1
+aliases.p192 = aliases.secp192r1 = aliases.prime192v1
+aliases.p384 = aliases.secp384r1
+aliases.p521 = aliases.secp521r1
+
+function ECDH (curve) {
+  this.curveType = aliases[curve]
+  if (!this.curveType) {
+    this.curveType = {
+      name: curve
+    }
+  }
+  this.curve = new elliptic.ec(this.curveType.name) // eslint-disable-line new-cap
+  this.keys = void 0
+}
+
+ECDH.prototype.generateKeys = function (enc, format) {
+  this.keys = this.curve.genKeyPair()
+  return this.getPublicKey(enc, format)
+}
+
+ECDH.prototype.computeSecret = function (other, inenc, enc) {
+  inenc = inenc || 'utf8'
+  if (!Buffer.isBuffer(other)) {
+    other = new Buffer(other, inenc)
+  }
+  var otherPub = this.curve.keyFromPublic(other).getPublic()
+  var out = otherPub.mul(this.keys.getPrivate()).getX()
+  return formatReturnValue(out, enc, this.curveType.byteLength)
+}
+
+ECDH.prototype.getPublicKey = function (enc, format) {
+  var key = this.keys.getPublic(format === 'compressed', true)
+  if (format === 'hybrid') {
+    if (key[key.length - 1] % 2) {
+      key[0] = 7
+    } else {
+      key[0] = 6
+    }
+  }
+  return formatReturnValue(key, enc)
+}
+
+ECDH.prototype.getPrivateKey = function (enc) {
+  return formatReturnValue(this.keys.getPrivate(), enc)
+}
+
+ECDH.prototype.setPublicKey = function (pub, enc) {
+  enc = enc || 'utf8'
+  if (!Buffer.isBuffer(pub)) {
+    pub = new Buffer(pub, enc)
+  }
+  this.keys._importPublic(pub)
+  return this
+}
+
+ECDH.prototype.setPrivateKey = function (priv, enc) {
+  enc = enc || 'utf8'
+  if (!Buffer.isBuffer(priv)) {
+    priv = new Buffer(priv, enc)
+  }
+
+  var _priv = new BN(priv)
+  _priv = _priv.toString(16)
+  this.keys = this.curve.genKeyPair()
+  this.keys._importPrivate(_priv)
+  return this
+}
+
+function formatReturnValue (bn, enc, len) {
+  if (!Array.isArray(bn)) {
+    bn = bn.toArray()
+  }
+  var buf = new Buffer(bn)
+  if (len && buf.length < len) {
+    var zeros = new Buffer(len - buf.length)
+    zeros.fill(0)
+    buf = Buffer.concat([zeros, buf])
+  }
+  if (!enc) {
+    return buf
+  } else {
+    return buf.toString(enc)
+  }
+}
+
+}).call(this,require("buffer").Buffer)
+},{"bn.js":24,"buffer":55,"elliptic":74}],59:[function(require,module,exports){
+'use strict'
+var inherits = require('inherits')
+var MD5 = require('md5.js')
+var RIPEMD160 = require('ripemd160')
+var sha = require('sha.js')
+var Base = require('cipher-base')
+
+function Hash (hash) {
+  Base.call(this, 'digest')
+
+  this._hash = hash
+}
+
+inherits(Hash, Base)
+
+Hash.prototype._update = function (data) {
+  this._hash.update(data)
+}
+
+Hash.prototype._final = function () {
+  return this._hash.digest()
+}
+
+module.exports = function createHash (alg) {
+  alg = alg.toLowerCase()
+  if (alg === 'md5') return new MD5()
+  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()
+
+  return new Hash(sha(alg))
+}
+
+},{"cipher-base":56,"inherits":107,"md5.js":110,"ripemd160":147,"sha.js":150}],60:[function(require,module,exports){
+var MD5 = require('md5.js')
+
+module.exports = function (buffer) {
+  return new MD5().update(buffer).digest()
+}
+
+},{"md5.js":110}],61:[function(require,module,exports){
+'use strict'
+var inherits = require('inherits')
+var Legacy = require('./legacy')
+var Base = require('cipher-base')
+var Buffer = require('safe-buffer').Buffer
+var md5 = require('create-hash/md5')
+var RIPEMD160 = require('ripemd160')
+
+var sha = require('sha.js')
+
+var ZEROS = Buffer.alloc(128)
+
+function Hmac (alg, key) {
+  Base.call(this, 'digest')
+  if (typeof key === 'string') {
+    key = Buffer.from(key)
+  }
+
+  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64
+
+  this._alg = alg
+  this._key = key
+  if (key.length > blocksize) {
+    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
+    key = hash.update(key).digest()
+  } else if (key.length < blocksize) {
+    key = Buffer.concat([key, ZEROS], blocksize)
+  }
+
+  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)
+  var opad = this._opad = Buffer.allocUnsafe(blocksize)
+
+  for (var i = 0; i < blocksize; i++) {
+    ipad[i] = key[i] ^ 0x36
+    opad[i] = key[i] ^ 0x5C
+  }
+  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
+  this._hash.update(ipad)
+}
+
+inherits(Hmac, Base)
+
+Hmac.prototype._update = function (data) {
+  this._hash.update(data)
+}
+
+Hmac.prototype._final = function () {
+  var h = this._hash.digest()
+  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)
+  return hash.update(this._opad).update(h).digest()
+}
+
+module.exports = function createHmac (alg, key) {
+  alg = alg.toLowerCase()
+  if (alg === 'rmd160' || alg === 'ripemd160') {
+    return new Hmac('rmd160', key)
+  }
+  if (alg === 'md5') {
+    return new Legacy(md5, key)
+  }
+  return new Hmac(alg, key)
+}
+
+},{"./legacy":62,"cipher-base":56,"create-hash/md5":60,"inherits":107,"ripemd160":147,"safe-buffer":148,"sha.js":150}],62:[function(require,module,exports){
+'use strict'
+var inherits = require('inherits')
+var Buffer = require('safe-buffer').Buffer
+
+var Base = require('cipher-base')
+
+var ZEROS = Buffer.alloc(128)
+var blocksize = 64
+
+function Hmac (alg, key) {
+  Base.call(this, 'digest')
+  if (typeof key === 'string') {
+    key = Buffer.from(key)
+  }
+
+  this._alg = alg
+  this._key = key
+
+  if (key.length > blocksize) {
+    key = alg(key)
+  } else if (key.length < blocksize) {
+    key = Buffer.concat([key, ZEROS], blocksize)
+  }
+
+  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)
+  var opad = this._opad = Buffer.allocUnsafe(blocksize)
+
+  for (var i = 0; i < blocksize; i++) {
+    ipad[i] = key[i] ^ 0x36
+    opad[i] = key[i] ^ 0x5C
+  }
+
+  this._hash = [ipad]
+}
+
+inherits(Hmac, Base)
+
+Hmac.prototype._update = function (data) {
+  this._hash.push(data)
+}
+
+Hmac.prototype._final = function () {
+  var h = this._alg(Buffer.concat(this._hash))
+  return this._alg(Buffer.concat([this._opad, h]))
+}
+module.exports = Hmac
+
+},{"cipher-base":56,"inherits":107,"safe-buffer":148}],63:[function(require,module,exports){
+'use strict'
+
+exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes')
+exports.createHash = exports.Hash = require('create-hash')
+exports.createHmac = exports.Hmac = require('create-hmac')
+
+var algos = require('browserify-sign/algos')
+var algoKeys = Object.keys(algos)
+var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys)
+exports.getHashes = function () {
+  return hashes
+}
+
+var p = require('pbkdf2')
+exports.pbkdf2 = p.pbkdf2
+exports.pbkdf2Sync = p.pbkdf2Sync
+
+var aes = require('browserify-cipher')
+
+exports.Cipher = aes.Cipher
+exports.createCipher = aes.createCipher
+exports.Cipheriv = aes.Cipheriv
+exports.createCipheriv = aes.createCipheriv
+exports.Decipher = aes.Decipher
+exports.createDecipher = aes.createDecipher
+exports.Decipheriv = aes.Decipheriv
+exports.createDecipheriv = aes.createDecipheriv
+exports.getCiphers = aes.getCiphers
+exports.listCiphers = aes.listCiphers
+
+var dh = require('diffie-hellman')
+
+exports.DiffieHellmanGroup = dh.DiffieHellmanGroup
+exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup
+exports.getDiffieHellman = dh.getDiffieHellman
+exports.createDiffieHellman = dh.createDiffieHellman
+exports.DiffieHellman = dh.DiffieHellman
+
+var sign = require('browserify-sign')
+
+exports.createSign = sign.createSign
+exports.Sign = sign.Sign
+exports.createVerify = sign.createVerify
+exports.Verify = sign.Verify
+
+exports.createECDH = require('create-ecdh')
+
+var publicEncrypt = require('public-encrypt')
+
+exports.publicEncrypt = publicEncrypt.publicEncrypt
+exports.privateEncrypt = publicEncrypt.privateEncrypt
+exports.publicDecrypt = publicEncrypt.publicDecrypt
+exports.privateDecrypt = publicEncrypt.privateDecrypt
+
+// the least I can do is make error messages for the rest of the node.js/crypto api.
+// ;[
+//   'createCredentials'
+// ].forEach(function (name) {
+//   exports[name] = function () {
+//     throw new Error([
+//       'sorry, ' + name + ' is not implemented yet',
+//       'we accept pull requests',
+//       'https://github.com/crypto-browserify/crypto-browserify'
+//     ].join('\n'))
+//   }
+// })
+
+var rf = require('randomfill')
+
+exports.randomFill = rf.randomFill
+exports.randomFillSync = rf.randomFillSync
+
+exports.createCredentials = function () {
+  throw new Error([
+    'sorry, createCredentials is not implemented yet',
+    'we accept pull requests',
+    'https://github.com/crypto-browserify/crypto-browserify'
+  ].join('\n'))
+}
+
+exports.constants = {
+  'DH_CHECK_P_NOT_SAFE_PRIME': 2,
+  'DH_CHECK_P_NOT_PRIME': 1,
+  'DH_UNABLE_TO_CHECK_GENERATOR': 4,
+  'DH_NOT_SUITABLE_GENERATOR': 8,
+  'NPN_ENABLED': 1,
+  'ALPN_ENABLED': 1,
+  'RSA_PKCS1_PADDING': 1,
+  'RSA_SSLV23_PADDING': 2,
+  'RSA_NO_PADDING': 3,
+  'RSA_PKCS1_OAEP_PADDING': 4,
+  'RSA_X931_PADDING': 5,
+  'RSA_PKCS1_PSS_PADDING': 6,
+  'POINT_CONVERSION_COMPRESSED': 2,
+  'POINT_CONVERSION_UNCOMPRESSED': 4,
+  'POINT_CONVERSION_HYBRID': 6
+}
+
+},{"browserify-cipher":44,"browserify-sign":51,"browserify-sign/algos":48,"create-ecdh":58,"create-hash":59,"create-hmac":61,"diffie-hellman":70,"pbkdf2":119,"public-encrypt":126,"randombytes":132,"randomfill":133}],64:[function(require,module,exports){
+'use strict';
+
+exports.utils = require('./des/utils');
+exports.Cipher = require('./des/cipher');
+exports.DES = require('./des/des');
+exports.CBC = require('./des/cbc');
+exports.EDE = require('./des/ede');
+
+},{"./des/cbc":65,"./des/cipher":66,"./des/des":67,"./des/ede":68,"./des/utils":69}],65:[function(require,module,exports){
+'use strict';
+
+var assert = require('minimalistic-assert');
+var inherits = require('inherits');
+
+var proto = {};
+
+function CBCState(iv) {
+  assert.equal(iv.length, 8, 'Invalid IV length');
+
+  this.iv = new Array(8);
+  for (var i = 0; i < this.iv.length; i++)
+    this.iv[i] = iv[i];
+}
+
+function instantiate(Base) {
+  function CBC(options) {
+    Base.call(this, options);
+    this._cbcInit();
+  }
+  inherits(CBC, Base);
+
+  var keys = Object.keys(proto);
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    CBC.prototype[key] = proto[key];
+  }
+
+  CBC.create = function create(options) {
+    return new CBC(options);
+  };
+
+  return CBC;
+}
+
+exports.instantiate = instantiate;
+
+proto._cbcInit = function _cbcInit() {
+  var state = new CBCState(this.options.iv);
+  this._cbcState = state;
+};
+
+proto._update = function _update(inp, inOff, out, outOff) {
+  var state = this._cbcState;
+  var superProto = this.constructor.super_.prototype;
+
+  var iv = state.iv;
+  if (this.type === 'encrypt') {
+    for (var i = 0; i < this.blockSize; i++)
+      iv[i] ^= inp[inOff + i];
+
+    superProto._update.call(this, iv, 0, out, outOff);
+
+    for (var i = 0; i < this.blockSize; i++)
+      iv[i] = out[outOff + i];
+  } else {
+    superProto._update.call(this, inp, inOff, out, outOff);
+
+    for (var i = 0; i < this.blockSize; i++)
+      out[outOff + i] ^= iv[i];
+
+    for (var i = 0; i < this.blockSize; i++)
+      iv[i] = inp[inOff + i];
+  }
+};
+
+},{"inherits":107,"minimalistic-assert":112}],66:[function(require,module,exports){
+'use strict';
+
+var assert = require('minimalistic-assert');
+
+function Cipher(options) {
+  this.options = options;
+
+  this.type = this.options.type;
+  this.blockSize = 8;
+  this._init();
+
+  this.buffer = new Array(this.blockSize);
+  this.bufferOff = 0;
+}
+module.exports = Cipher;
+
+Cipher.prototype._init = function _init() {
+  // Might be overrided
+};
+
+Cipher.prototype.update = function update(data) {
+  if (data.length === 0)
+    return [];
+
+  if (this.type === 'decrypt')
+    return this._updateDecrypt(data);
+  else
+    return this._updateEncrypt(data);
+};
+
+Cipher.prototype._buffer = function _buffer(data, off) {
+  // Append data to buffer
+  var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);
+  for (var i = 0; i < min; i++)
+    this.buffer[this.bufferOff + i] = data[off + i];
+  this.bufferOff += min;
+
+  // Shift next
+  return min;
+};
+
+Cipher.prototype._flushBuffer = function _flushBuffer(out, off) {
+  this._update(this.buffer, 0, out, off);
+  this.bufferOff = 0;
+  return this.blockSize;
+};
+
+Cipher.prototype._updateEncrypt = function _updateEncrypt(data) {
+  var inputOff = 0;
+  var outputOff = 0;
+
+  var count = ((this.bufferOff + data.length) / this.blockSize) | 0;
+  var out = new Array(count * this.blockSize);
+
+  if (this.bufferOff !== 0) {
+    inputOff += this._buffer(data, inputOff);
+
+    if (this.bufferOff === this.buffer.length)
+      outputOff += this._flushBuffer(out, outputOff);
+  }
+
+  // Write blocks
+  var max = data.length - ((data.length - inputOff) % this.blockSize);
+  for (; inputOff < max; inputOff += this.blockSize) {
+    this._update(data, inputOff, out, outputOff);
+    outputOff += this.blockSize;
+  }
+
+  // Queue rest
+  for (; inputOff < data.length; inputOff++, this.bufferOff++)
+    this.buffer[this.bufferOff] = data[inputOff];
+
+  return out;
+};
+
+Cipher.prototype._updateDecrypt = function _updateDecrypt(data) {
+  var inputOff = 0;
+  var outputOff = 0;
+
+  var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1;
+  var out = new Array(count * this.blockSize);
+
+  // TODO(indutny): optimize it, this is far from optimal
+  for (; count > 0; count--) {
+    inputOff += this._buffer(data, inputOff);
+    outputOff += this._flushBuffer(out, outputOff);
+  }
+
+  // Buffer rest of the input
+  inputOff += this._buffer(data, inputOff);
+
+  return out;
+};
+
+Cipher.prototype.final = function final(buffer) {
+  var first;
+  if (buffer)
+    first = this.update(buffer);
+
+  var last;
+  if (this.type === 'encrypt')
+    last = this._finalEncrypt();
+  else
+    last = this._finalDecrypt();
+
+  if (first)
+    return first.concat(last);
+  else
+    return last;
+};
+
+Cipher.prototype._pad = function _pad(buffer, off) {
+  if (off === 0)
+    return false;
+
+  while (off < buffer.length)
+    buffer[off++] = 0;
+
+  return true;
+};
+
+Cipher.prototype._finalEncrypt = function _finalEncrypt() {
+  if (!this._pad(this.buffer, this.bufferOff))
+    return [];
+
+  var out = new Array(this.blockSize);
+  this._update(this.buffer, 0, out, 0);
+  return out;
+};
+
+Cipher.prototype._unpad = function _unpad(buffer) {
+  return buffer;
+};
+
+Cipher.prototype._finalDecrypt = function _finalDecrypt() {
+  assert.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt');
+  var out = new Array(this.blockSize);
+  this._flushBuffer(out, 0);
+
+  return this._unpad(out);
+};
+
+},{"minimalistic-assert":112}],67:[function(require,module,exports){
+'use strict';
+
+var assert = require('minimalistic-assert');
+var inherits = require('inherits');
+
+var des = require('../des');
+var utils = des.utils;
+var Cipher = des.Cipher;
+
+function DESState() {
+  this.tmp = new Array(2);
+  this.keys = null;
+}
+
+function DES(options) {
+  Cipher.call(this, options);
+
+  var state = new DESState();
+  this._desState = state;
+
+  this.deriveKeys(state, options.key);
+}
+inherits(DES, Cipher);
+module.exports = DES;
+
+DES.create = function create(options) {
+  return new DES(options);
+};
+
+var shiftTable = [
+  1, 1, 2, 2, 2, 2, 2, 2,
+  1, 2, 2, 2, 2, 2, 2, 1
+];
+
+DES.prototype.deriveKeys = function deriveKeys(state, key) {
+  state.keys = new Array(16 * 2);
+
+  assert.equal(key.length, this.blockSize, 'Invalid key length');
+
+  var kL = utils.readUInt32BE(key, 0);
+  var kR = utils.readUInt32BE(key, 4);
+
+  utils.pc1(kL, kR, state.tmp, 0);
+  kL = state.tmp[0];
+  kR = state.tmp[1];
+  for (var i = 0; i < state.keys.length; i += 2) {
+    var shift = shiftTable[i >>> 1];
+    kL = utils.r28shl(kL, shift);
+    kR = utils.r28shl(kR, shift);
+    utils.pc2(kL, kR, state.keys, i);
+  }
+};
+
+DES.prototype._update = function _update(inp, inOff, out, outOff) {
+  var state = this._desState;
+
+  var l = utils.readUInt32BE(inp, inOff);
+  var r = utils.readUInt32BE(inp, inOff + 4);
+
+  // Initial Permutation
+  utils.ip(l, r, state.tmp, 0);
+  l = state.tmp[0];
+  r = state.tmp[1];
+
+  if (this.type === 'encrypt')
+    this._encrypt(state, l, r, state.tmp, 0);
+  else
+    this._decrypt(state, l, r, state.tmp, 0);
+
+  l = state.tmp[0];
+  r = state.tmp[1];
+
+  utils.writeUInt32BE(out, l, outOff);
+  utils.writeUInt32BE(out, r, outOff + 4);
+};
+
+DES.prototype._pad = function _pad(buffer, off) {
+  var value = buffer.length - off;
+  for (var i = off; i < buffer.length; i++)
+    buffer[i] = value;
+
+  return true;
+};
+
+DES.prototype._unpad = function _unpad(buffer) {
+  var pad = buffer[buffer.length - 1];
+  for (var i = buffer.length - pad; i < buffer.length; i++)
+    assert.equal(buffer[i], pad);
+
+  return buffer.slice(0, buffer.length - pad);
+};
+
+DES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) {
+  var l = lStart;
+  var r = rStart;
+
+  // Apply f() x16 times
+  for (var i = 0; i < state.keys.length; i += 2) {
+    var keyL = state.keys[i];
+    var keyR = state.keys[i + 1];
+
+    // f(r, k)
+    utils.expand(r, state.tmp, 0);
+
+    keyL ^= state.tmp[0];
+    keyR ^= state.tmp[1];
+    var s = utils.substitute(keyL, keyR);
+    var f = utils.permute(s);
+
+    var t = r;
+    r = (l ^ f) >>> 0;
+    l = t;
+  }
+
+  // Reverse Initial Permutation
+  utils.rip(r, l, out, off);
+};
+
+DES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) {
+  var l = rStart;
+  var r = lStart;
+
+  // Apply f() x16 times
+  for (var i = state.keys.length - 2; i >= 0; i -= 2) {
+    var keyL = state.keys[i];
+    var keyR = state.keys[i + 1];
+
+    // f(r, k)
+    utils.expand(l, state.tmp, 0);
+
+    keyL ^= state.tmp[0];
+    keyR ^= state.tmp[1];
+    var s = utils.substitute(keyL, keyR);
+    var f = utils.permute(s);
+
+    var t = l;
+    l = (r ^ f) >>> 0;
+    r = t;
+  }
+
+  // Reverse Initial Permutation
+  utils.rip(l, r, out, off);
+};
+
+},{"../des":64,"inherits":107,"minimalistic-assert":112}],68:[function(require,module,exports){
+'use strict';
+
+var assert = require('minimalistic-assert');
+var inherits = require('inherits');
+
+var des = require('../des');
+var Cipher = des.Cipher;
+var DES = des.DES;
+
+function EDEState(type, key) {
+  assert.equal(key.length, 24, 'Invalid key length');
+
+  var k1 = key.slice(0, 8);
+  var k2 = key.slice(8, 16);
+  var k3 = key.slice(16, 24);
+
+  if (type === 'encrypt') {
+    this.ciphers = [
+      DES.create({ type: 'encrypt', key: k1 }),
+      DES.create({ type: 'decrypt', key: k2 }),
+      DES.create({ type: 'encrypt', key: k3 })
+    ];
+  } else {
+    this.ciphers = [
+      DES.create({ type: 'decrypt', key: k3 }),
+      DES.create({ type: 'encrypt', key: k2 }),
+      DES.create({ type: 'decrypt', key: k1 })
+    ];
+  }
+}
+
+function EDE(options) {
+  Cipher.call(this, options);
+
+  var state = new EDEState(this.type, this.options.key);
+  this._edeState = state;
+}
+inherits(EDE, Cipher);
+
+module.exports = EDE;
+
+EDE.create = function create(options) {
+  return new EDE(options);
+};
+
+EDE.prototype._update = function _update(inp, inOff, out, outOff) {
+  var state = this._edeState;
+
+  state.ciphers[0]._update(inp, inOff, out, outOff);
+  state.ciphers[1]._update(out, outOff, out, outOff);
+  state.ciphers[2]._update(out, outOff, out, outOff);
+};
+
+EDE.prototype._pad = DES.prototype._pad;
+EDE.prototype._unpad = DES.prototype._unpad;
+
+},{"../des":64,"inherits":107,"minimalistic-assert":112}],69:[function(require,module,exports){
+'use strict';
+
+exports.readUInt32BE = function readUInt32BE(bytes, off) {
+  var res =  (bytes[0 + off] << 24) |
+             (bytes[1 + off] << 16) |
+             (bytes[2 + off] << 8) |
+             bytes[3 + off];
+  return res >>> 0;
+};
+
+exports.writeUInt32BE = function writeUInt32BE(bytes, value, off) {
+  bytes[0 + off] = value >>> 24;
+  bytes[1 + off] = (value >>> 16) & 0xff;
+  bytes[2 + off] = (value >>> 8) & 0xff;
+  bytes[3 + off] = value & 0xff;
+};
+
+exports.ip = function ip(inL, inR, out, off) {
+  var outL = 0;
+  var outR = 0;
+
+  for (var i = 6; i >= 0; i -= 2) {
+    for (var j = 0; j <= 24; j += 8) {
+      outL <<= 1;
+      outL |= (inR >>> (j + i)) & 1;
+    }
+    for (var j = 0; j <= 24; j += 8) {
+      outL <<= 1;
+      outL |= (inL >>> (j + i)) & 1;
+    }
+  }
+
+  for (var i = 6; i >= 0; i -= 2) {
+    for (var j = 1; j <= 25; j += 8) {
+      outR <<= 1;
+      outR |= (inR >>> (j + i)) & 1;
+    }
+    for (var j = 1; j <= 25; j += 8) {
+      outR <<= 1;
+      outR |= (inL >>> (j + i)) & 1;
+    }
+  }
+
+  out[off + 0] = outL >>> 0;
+  out[off + 1] = outR >>> 0;
+};
+
+exports.rip = function rip(inL, inR, out, off) {
+  var outL = 0;
+  var outR = 0;
+
+  for (var i = 0; i < 4; i++) {
+    for (var j = 24; j >= 0; j -= 8) {
+      outL <<= 1;
+      outL |= (inR >>> (j + i)) & 1;
+      outL <<= 1;
+      outL |= (inL >>> (j + i)) & 1;
+    }
+  }
+  for (var i = 4; i < 8; i++) {
+    for (var j = 24; j >= 0; j -= 8) {
+      outR <<= 1;
+      outR |= (inR >>> (j + i)) & 1;
+      outR <<= 1;
+      outR |= (inL >>> (j + i)) & 1;
+    }
+  }
+
+  out[off + 0] = outL >>> 0;
+  out[off + 1] = outR >>> 0;
+};
+
+exports.pc1 = function pc1(inL, inR, out, off) {
+  var outL = 0;
+  var outR = 0;
+
+  // 7, 15, 23, 31, 39, 47, 55, 63
+  // 6, 14, 22, 30, 39, 47, 55, 63
+  // 5, 13, 21, 29, 39, 47, 55, 63
+  // 4, 12, 20, 28
+  for (var i = 7; i >= 5; i--) {
+    for (var j = 0; j <= 24; j += 8) {
+      outL <<= 1;
+      outL |= (inR >> (j + i)) & 1;
+    }
+    for (var j = 0; j <= 24; j += 8) {
+      outL <<= 1;
+      outL |= (inL >> (j + i)) & 1;
+    }
+  }
+  for (var j = 0; j <= 24; j += 8) {
+    outL <<= 1;
+    outL |= (inR >> (j + i)) & 1;
+  }
+
+  // 1, 9, 17, 25, 33, 41, 49, 57
+  // 2, 10, 18, 26, 34, 42, 50, 58
+  // 3, 11, 19, 27, 35, 43, 51, 59
+  // 36, 44, 52, 60
+  for (var i = 1; i <= 3; i++) {
+    for (var j = 0; j <= 24; j += 8) {
+      outR <<= 1;
+      outR |= (inR >> (j + i)) & 1;
+    }
+    for (var j = 0; j <= 24; j += 8) {
+      outR <<= 1;
+      outR |= (inL >> (j + i)) & 1;
+    }
+  }
+  for (var j = 0; j <= 24; j += 8) {
+    outR <<= 1;
+    outR |= (inL >> (j + i)) & 1;
+  }
+
+  out[off + 0] = outL >>> 0;
+  out[off + 1] = outR >>> 0;
+};
+
+exports.r28shl = function r28shl(num, shift) {
+  return ((num << shift) & 0xfffffff) | (num >>> (28 - shift));
+};
+
+var pc2table = [
+  // inL => outL
+  14, 11, 17, 4, 27, 23, 25, 0,
+  13, 22, 7, 18, 5, 9, 16, 24,
+  2, 20, 12, 21, 1, 8, 15, 26,
+
+  // inR => outR
+  15, 4, 25, 19, 9, 1, 26, 16,
+  5, 11, 23, 8, 12, 7, 17, 0,
+  22, 3, 10, 14, 6, 20, 27, 24
+];
+
+exports.pc2 = function pc2(inL, inR, out, off) {
+  var outL = 0;
+  var outR = 0;
+
+  var len = pc2table.length >>> 1;
+  for (var i = 0; i < len; i++) {
+    outL <<= 1;
+    outL |= (inL >>> pc2table[i]) & 0x1;
+  }
+  for (var i = len; i < pc2table.length; i++) {
+    outR <<= 1;
+    outR |= (inR >>> pc2table[i]) & 0x1;
+  }
+
+  out[off + 0] = outL >>> 0;
+  out[off + 1] = outR >>> 0;
+};
+
+exports.expand = function expand(r, out, off) {
+  var outL = 0;
+  var outR = 0;
+
+  outL = ((r & 1) << 5) | (r >>> 27);
+  for (var i = 23; i >= 15; i -= 4) {
+    outL <<= 6;
+    outL |= (r >>> i) & 0x3f;
+  }
+  for (var i = 11; i >= 3; i -= 4) {
+    outR |= (r >>> i) & 0x3f;
+    outR <<= 6;
+  }
+  outR |= ((r & 0x1f) << 1) | (r >>> 31);
+
+  out[off + 0] = outL >>> 0;
+  out[off + 1] = outR >>> 0;
+};
+
+var sTable = [
+  14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1,
+  3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8,
+  4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7,
+  15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13,
+
+  15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14,
+  9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5,
+  0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2,
+  5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9,
+
+  10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10,
+  1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1,
+  13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7,
+  11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12,
+
+  7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3,
+  1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9,
+  10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8,
+  15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14,
+
+  2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1,
+  8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6,
+  4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13,
+  15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3,
+
+  12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5,
+  0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8,
+  9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10,
+  7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13,
+
+  4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10,
+  3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6,
+  1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7,
+  10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12,
+
+  13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4,
+  10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2,
+  7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13,
+  0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11
+];
+
+exports.substitute = function substitute(inL, inR) {
+  var out = 0;
+  for (var i = 0; i < 4; i++) {
+    var b = (inL >>> (18 - i * 6)) & 0x3f;
+    var sb = sTable[i * 0x40 + b];
+
+    out <<= 4;
+    out |= sb;
+  }
+  for (var i = 0; i < 4; i++) {
+    var b = (inR >>> (18 - i * 6)) & 0x3f;
+    var sb = sTable[4 * 0x40 + i * 0x40 + b];
+
+    out <<= 4;
+    out |= sb;
+  }
+  return out >>> 0;
+};
+
+var permuteTable = [
+  16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22,
+  30, 24, 8, 18, 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7
+];
+
+exports.permute = function permute(num) {
+  var out = 0;
+  for (var i = 0; i < permuteTable.length; i++) {
+    out <<= 1;
+    out |= (num >>> permuteTable[i]) & 0x1;
+  }
+  return out >>> 0;
+};
+
+exports.padSplit = function padSplit(num, size, group) {
+  var str = num.toString(2);
+  while (str.length < size)
+    str = '0' + str;
+
+  var out = [];
+  for (var i = 0; i < size; i += group)
+    out.push(str.slice(i, i + group));
+  return out.join(' ');
+};
+
+},{}],70:[function(require,module,exports){
+(function (Buffer){
+var generatePrime = require('./lib/generatePrime')
+var primes = require('./lib/primes.json')
+
+var DH = require('./lib/dh')
+
+function getDiffieHellman (mod) {
+  var prime = new Buffer(primes[mod].prime, 'hex')
+  var gen = new Buffer(primes[mod].gen, 'hex')
+
+  return new DH(prime, gen)
+}
+
+var ENCODINGS = {
+  'binary': true, 'hex': true, 'base64': true
+}
+
+function createDiffieHellman (prime, enc, generator, genc) {
+  if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) {
+    return createDiffieHellman(prime, 'binary', enc, generator)
+  }
+
+  enc = enc || 'binary'
+  genc = genc || 'binary'
+  generator = generator || new Buffer([2])
+
+  if (!Buffer.isBuffer(generator)) {
+    generator = new Buffer(generator, genc)
+  }
+
+  if (typeof prime === 'number') {
+    return new DH(generatePrime(prime, generator), generator, true)
+  }
+
+  if (!Buffer.isBuffer(prime)) {
+    prime = new Buffer(prime, enc)
+  }
+
+  return new DH(prime, generator, true)
+}
+
+exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman
+exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman
+
+}).call(this,require("buffer").Buffer)
+},{"./lib/dh":71,"./lib/generatePrime":72,"./lib/primes.json":73,"buffer":55}],71:[function(require,module,exports){
+(function (Buffer){
+var BN = require('bn.js');
+var MillerRabin = require('miller-rabin');
+var millerRabin = new MillerRabin();
+var TWENTYFOUR = new BN(24);
+var ELEVEN = new BN(11);
+var TEN = new BN(10);
+var THREE = new BN(3);
+var SEVEN = new BN(7);
+var primes = require('./generatePrime');
+var randomBytes = require('randombytes');
+module.exports = DH;
+
+function setPublicKey(pub, enc) {
+  enc = enc || 'utf8';
+  if (!Buffer.isBuffer(pub)) {
+    pub = new Buffer(pub, enc);
+  }
+  this._pub = new BN(pub);
+  return this;
+}
+
+function setPrivateKey(priv, enc) {
+  enc = enc || 'utf8';
+  if (!Buffer.isBuffer(priv)) {
+    priv = new Buffer(priv, enc);
+  }
+  this._priv = new BN(priv);
+  return this;
+}
+
+var primeCache = {};
+function checkPrime(prime, generator) {
+  var gen = generator.toString('hex');
+  var hex = [gen, prime.toString(16)].join('_');
+  if (hex in primeCache) {
+    return primeCache[hex];
+  }
+  var error = 0;
+
+  if (prime.isEven() ||
+    !primes.simpleSieve ||
+    !primes.fermatTest(prime) ||
+    !millerRabin.test(prime)) {
+    //not a prime so +1
+    error += 1;
+
+    if (gen === '02' || gen === '05') {
+      // we'd be able to check the generator
+      // it would fail so +8
+      error += 8;
+    } else {
+      //we wouldn't be able to test the generator
+      // so +4
+      error += 4;
+    }
+    primeCache[hex] = error;
+    return error;
+  }
+  if (!millerRabin.test(prime.shrn(1))) {
+    //not a safe prime
+    error += 2;
+  }
+  var rem;
+  switch (gen) {
+    case '02':
+      if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) {
+        // unsuidable generator
+        error += 8;
+      }
+      break;
+    case '05':
+      rem = prime.mod(TEN);
+      if (rem.cmp(THREE) && rem.cmp(SEVEN)) {
+        // prime mod 10 needs to equal 3 or 7
+        error += 8;
+      }
+      break;
+    default:
+      error += 4;
+  }
+  primeCache[hex] = error;
+  return error;
+}
+
+function DH(prime, generator, malleable) {
+  this.setGenerator(generator);
+  this.__prime = new BN(prime);
+  this._prime = BN.mont(this.__prime);
+  this._primeLen = prime.length;
+  this._pub = undefined;
+  this._priv = undefined;
+  this._primeCode = undefined;
+  if (malleable) {
+    this.setPublicKey = setPublicKey;
+    this.setPrivateKey = setPrivateKey;
+  } else {
+    this._primeCode = 8;
+  }
+}
+Object.defineProperty(DH.prototype, 'verifyError', {
+  enumerable: true,
+  get: function () {
+    if (typeof this._primeCode !== 'number') {
+      this._primeCode = checkPrime(this.__prime, this.__gen);
+    }
+    return this._primeCode;
+  }
+});
+DH.prototype.generateKeys = function () {
+  if (!this._priv) {
+    this._priv = new BN(randomBytes(this._primeLen));
+  }
+  this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed();
+  return this.getPublicKey();
+};
+
+DH.prototype.computeSecret = function (other) {
+  other = new BN(other);
+  other = other.toRed(this._prime);
+  var secret = other.redPow(this._priv).fromRed();
+  var out = new Buffer(secret.toArray());
+  var prime = this.getPrime();
+  if (out.length < prime.length) {
+    var front = new Buffer(prime.length - out.length);
+    front.fill(0);
+    out = Buffer.concat([front, out]);
+  }
+  return out;
+};
+
+DH.prototype.getPublicKey = function getPublicKey(enc) {
+  return formatReturnValue(this._pub, enc);
+};
+
+DH.prototype.getPrivateKey = function getPrivateKey(enc) {
+  return formatReturnValue(this._priv, enc);
+};
+
+DH.prototype.getPrime = function (enc) {
+  return formatReturnValue(this.__prime, enc);
+};
+
+DH.prototype.getGenerator = function (enc) {
+  return formatReturnValue(this._gen, enc);
+};
+
+DH.prototype.setGenerator = function (gen, enc) {
+  enc = enc || 'utf8';
+  if (!Buffer.isBuffer(gen)) {
+    gen = new Buffer(gen, enc);
+  }
+  this.__gen = gen;
+  this._gen = new BN(gen);
+  return this;
+};
+
+function formatReturnValue(bn, enc) {
+  var buf = new Buffer(bn.toArray());
+  if (!enc) {
+    return buf;
+  } else {
+    return buf.toString(enc);
+  }
+}
+
+}).call(this,require("buffer").Buffer)
+},{"./generatePrime":72,"bn.js":24,"buffer":55,"miller-rabin":111,"randombytes":132}],72:[function(require,module,exports){
+var randomBytes = require('randombytes');
+module.exports = findPrime;
+findPrime.simpleSieve = simpleSieve;
+findPrime.fermatTest = fermatTest;
+var BN = require('bn.js');
+var TWENTYFOUR = new BN(24);
+var MillerRabin = require('miller-rabin');
+var millerRabin = new MillerRabin();
+var ONE = new BN(1);
+var TWO = new BN(2);
+var FIVE = new BN(5);
+var SIXTEEN = new BN(16);
+var EIGHT = new BN(8);
+var TEN = new BN(10);
+var THREE = new BN(3);
+var SEVEN = new BN(7);
+var ELEVEN = new BN(11);
+var FOUR = new BN(4);
+var TWELVE = new BN(12);
+var primes = null;
+
+function _getPrimes() {
+  if (primes !== null)
+    return primes;
+
+  var limit = 0x100000;
+  var res = [];
+  res[0] = 2;
+  for (var i = 1, k = 3; k < limit; k += 2) {
+    var sqrt = Math.ceil(Math.sqrt(k));
+    for (var j = 0; j < i && res[j] <= sqrt; j++)
+      if (k % res[j] === 0)
+        break;
+
+    if (i !== j && res[j] <= sqrt)
+      continue;
+
+    res[i++] = k;
+  }
+  primes = res;
+  return res;
+}
+
+function simpleSieve(p) {
+  var primes = _getPrimes();
+
+  for (var i = 0; i < primes.length; i++)
+    if (p.modn(primes[i]) === 0) {
+      if (p.cmpn(primes[i]) === 0) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+  return true;
+}
+
+function fermatTest(p) {
+  var red = BN.mont(p);
+  return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0;
+}
+
+function findPrime(bits, gen) {
+  if (bits < 16) {
+    // this is what openssl does
+    if (gen === 2 || gen === 5) {
+      return new BN([0x8c, 0x7b]);
+    } else {
+      return new BN([0x8c, 0x27]);
+    }
+  }
+  gen = new BN(gen);
+
+  var num, n2;
+
+  while (true) {
+    num = new BN(randomBytes(Math.ceil(bits / 8)));
+    while (num.bitLength() > bits) {
+      num.ishrn(1);
+    }
+    if (num.isEven()) {
+      num.iadd(ONE);
+    }
+    if (!num.testn(1)) {
+      num.iadd(TWO);
+    }
+    if (!gen.cmp(TWO)) {
+      while (num.mod(TWENTYFOUR).cmp(ELEVEN)) {
+        num.iadd(FOUR);
+      }
+    } else if (!gen.cmp(FIVE)) {
+      while (num.mod(TEN).cmp(THREE)) {
+        num.iadd(FOUR);
+      }
+    }
+    n2 = num.shrn(1);
+    if (simpleSieve(n2) && simpleSieve(num) &&
+      fermatTest(n2) && fermatTest(num) &&
+      millerRabin.test(n2) && millerRabin.test(num)) {
+      return num;
+    }
+  }
+
+}
+
+},{"bn.js":24,"miller-rabin":111,"randombytes":132}],73:[function(require,module,exports){
+module.exports={
+    "modp1": {
+        "gen": "02",
+        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff"
+    },
+    "modp2": {
+        "gen": "02",
+        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff"
+    },
+    "modp5": {
+        "gen": "02",
+        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff"
+    },
+    "modp14": {
+        "gen": "02",
+        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff"
+    },
+    "modp15": {
+        "gen": "02",
+        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff"
+    },
+    "modp16": {
+        "gen": "02",
+        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff"
+    },
+    "modp17": {
+        "gen": "02",
+        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff"
+    },
+    "modp18": {
+        "gen": "02",
+        "prime": "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"
+    }
+}
+},{}],74:[function(require,module,exports){
+'use strict';
+
+var elliptic = exports;
+
+elliptic.version = require('../package.json').version;
+elliptic.utils = require('./elliptic/utils');
+elliptic.rand = require('brorand');
+elliptic.curve = require('./elliptic/curve');
+elliptic.curves = require('./elliptic/curves');
+
+// Protocols
+elliptic.ec = require('./elliptic/ec');
+elliptic.eddsa = require('./elliptic/eddsa');
+
+},{"../package.json":89,"./elliptic/curve":77,"./elliptic/curves":80,"./elliptic/ec":81,"./elliptic/eddsa":84,"./elliptic/utils":88,"brorand":25}],75:[function(require,module,exports){
+'use strict';
+
+var BN = require('bn.js');
+var elliptic = require('../../elliptic');
+var utils = elliptic.utils;
+var getNAF = utils.getNAF;
+var getJSF = utils.getJSF;
+var assert = utils.assert;
+
+function BaseCurve(type, conf) {
+  this.type = type;
+  this.p = new BN(conf.p, 16);
+
+  // Use Montgomery, when there is no fast reduction for the prime
+  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);
+
+  // Useful for many curves
+  this.zero = new BN(0).toRed(this.red);
+  this.one = new BN(1).toRed(this.red);
+  this.two = new BN(2).toRed(this.red);
+
+  // Curve configuration, optional
+  this.n = conf.n && new BN(conf.n, 16);
+  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);
+
+  // Temporary arrays
+  this._wnafT1 = new Array(4);
+  this._wnafT2 = new Array(4);
+  this._wnafT3 = new Array(4);
+  this._wnafT4 = new Array(4);
+
+  // Generalized Greg Maxwell's trick
+  var adjustCount = this.n && this.p.div(this.n);
+  if (!adjustCount || adjustCount.cmpn(100) > 0) {
+    this.redN = null;
+  } else {
+    this._maxwellTrick = true;
+    this.redN = this.n.toRed(this.red);
+  }
+}
+module.exports = BaseCurve;
+
+BaseCurve.prototype.point = function point() {
+  throw new Error('Not implemented');
+};
+
+BaseCurve.prototype.validate = function validate() {
+  throw new Error('Not implemented');
+};
+
+BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
+  assert(p.precomputed);
+  var doubles = p._getDoubles();
+
+  var naf = getNAF(k, 1);
+  var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);
+  I /= 3;
+
+  // Translate into more windowed form
+  var repr = [];
+  for (var j = 0; j < naf.length; j += doubles.step) {
+    var nafW = 0;
+    for (var k = j + doubles.step - 1; k >= j; k--)
+      nafW = (nafW << 1) + naf[k];
+    repr.push(nafW);
+  }
+
+  var a = this.jpoint(null, null, null);
+  var b = this.jpoint(null, null, null);
+  for (var i = I; i > 0; i--) {
+    for (var j = 0; j < repr.length; j++) {
+      var nafW = repr[j];
+      if (nafW === i)
+        b = b.mixedAdd(doubles.points[j]);
+      else if (nafW === -i)
+        b = b.mixedAdd(doubles.points[j].neg());
+    }
+    a = a.add(b);
+  }
+  return a.toP();
+};
+
+BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
+  var w = 4;
+
+  // Precompute window
+  var nafPoints = p._getNAFPoints(w);
+  w = nafPoints.wnd;
+  var wnd = nafPoints.points;
+
+  // Get NAF form
+  var naf = getNAF(k, w);
+
+  // Add `this`*(N+1) for every w-NAF index
+  var acc = this.jpoint(null, null, null);
+  for (var i = naf.length - 1; i >= 0; i--) {
+    // Count zeroes
+    for (var k = 0; i >= 0 && naf[i] === 0; i--)
+      k++;
+    if (i >= 0)
+      k++;
+    acc = acc.dblp(k);
+
+    if (i < 0)
+      break;
+    var z = naf[i];
+    assert(z !== 0);
+    if (p.type === 'affine') {
+      // J +- P
+      if (z > 0)
+        acc = acc.mixedAdd(wnd[(z - 1) >> 1]);
+      else
+        acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());
+    } else {
+      // J +- J
+      if (z > 0)
+        acc = acc.add(wnd[(z - 1) >> 1]);
+      else
+        acc = acc.add(wnd[(-z - 1) >> 1].neg());
+    }
+  }
+  return p.type === 'affine' ? acc.toP() : acc;
+};
+
+BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,
+                                                       points,
+                                                       coeffs,
+                                                       len,
+                                                       jacobianResult) {
+  var wndWidth = this._wnafT1;
+  var wnd = this._wnafT2;
+  var naf = this._wnafT3;
+
+  // Fill all arrays
+  var max = 0;
+  for (var i = 0; i < len; i++) {
+    var p = points[i];
+    var nafPoints = p._getNAFPoints(defW);
+    wndWidth[i] = nafPoints.wnd;
+    wnd[i] = nafPoints.points;
+  }
+
+  // Comb small window NAFs
+  for (var i = len - 1; i >= 1; i -= 2) {
+    var a = i - 1;
+    var b = i;
+    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
+      naf[a] = getNAF(coeffs[a], wndWidth[a]);
+      naf[b] = getNAF(coeffs[b], wndWidth[b]);
+      max = Math.max(naf[a].length, max);
+      max = Math.max(naf[b].length, max);
+      continue;
+    }
+
+    var comb = [
+      points[a], /* 1 */
+      null, /* 3 */
+      null, /* 5 */
+      points[b] /* 7 */
+    ];
+
+    // Try to avoid Projective points, if possible
+    if (points[a].y.cmp(points[b].y) === 0) {
+      comb[1] = points[a].add(points[b]);
+      comb[2] = points[a].toJ().mixedAdd(points[b].neg());
+    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
+      comb[1] = points[a].toJ().mixedAdd(points[b]);
+      comb[2] = points[a].add(points[b].neg());
+    } else {
+      comb[1] = points[a].toJ().mixedAdd(points[b]);
+      comb[2] = points[a].toJ().mixedAdd(points[b].neg());
+    }
+
+    var index = [
+      -3, /* -1 -1 */
+      -1, /* -1 0 */
+      -5, /* -1 1 */
+      -7, /* 0 -1 */
+      0, /* 0 0 */
+      7, /* 0 1 */
+      5, /* 1 -1 */
+      1, /* 1 0 */
+      3  /* 1 1 */
+    ];
+
+    var jsf = getJSF(coeffs[a], coeffs[b]);
+    max = Math.max(jsf[0].length, max);
+    naf[a] = new Array(max);
+    naf[b] = new Array(max);
+    for (var j = 0; j < max; j++) {
+      var ja = jsf[0][j] | 0;
+      var jb = jsf[1][j] | 0;
+
+      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
+      naf[b][j] = 0;
+      wnd[a] = comb;
+    }
+  }
+
+  var acc = this.jpoint(null, null, null);
+  var tmp = this._wnafT4;
+  for (var i = max; i >= 0; i--) {
+    var k = 0;
+
+    while (i >= 0) {
+      var zero = true;
+      for (var j = 0; j < len; j++) {
+        tmp[j] = naf[j][i] | 0;
+        if (tmp[j] !== 0)
+          zero = false;
+      }
+      if (!zero)
+        break;
+      k++;
+      i--;
+    }
+    if (i >= 0)
+      k++;
+    acc = acc.dblp(k);
+    if (i < 0)
+      break;
+
+    for (var j = 0; j < len; j++) {
+      var z = tmp[j];
+      var p;
+      if (z === 0)
+        continue;
+      else if (z > 0)
+        p = wnd[j][(z - 1) >> 1];
+      else if (z < 0)
+        p = wnd[j][(-z - 1) >> 1].neg();
+
+      if (p.type === 'affine')
+        acc = acc.mixedAdd(p);
+      else
+        acc = acc.add(p);
+    }
+  }
+  // Zeroify references
+  for (var i = 0; i < len; i++)
+    wnd[i] = null;
+
+  if (jacobianResult)
+    return acc;
+  else
+    return acc.toP();
+};
+
+function BasePoint(curve, type) {
+  this.curve = curve;
+  this.type = type;
+  this.precomputed = null;
+}
+BaseCurve.BasePoint = BasePoint;
+
+BasePoint.prototype.eq = function eq(/*other*/) {
+  throw new Error('Not implemented');
+};
+
+BasePoint.prototype.validate = function validate() {
+  return this.curve.validate(this);
+};
+
+BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
+  bytes = utils.toArray(bytes, enc);
+
+  var len = this.p.byteLength();
+
+  // uncompressed, hybrid-odd, hybrid-even
+  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&
+      bytes.length - 1 === 2 * len) {
+    if (bytes[0] === 0x06)
+      assert(bytes[bytes.length - 1] % 2 === 0);
+    else if (bytes[0] === 0x07)
+      assert(bytes[bytes.length - 1] % 2 === 1);
+
+    var res =  this.point(bytes.slice(1, 1 + len),
+                          bytes.slice(1 + len, 1 + 2 * len));
+
+    return res;
+  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&
+              bytes.length - 1 === len) {
+    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);
+  }
+  throw new Error('Unknown point format');
+};
+
+BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
+  return this.encode(enc, true);
+};
+
+BasePoint.prototype._encode = function _encode(compact) {
+  var len = this.curve.p.byteLength();
+  var x = this.getX().toArray('be', len);
+
+  if (compact)
+    return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x);
+
+  return [ 0x04 ].concat(x, this.getY().toArray('be', len)) ;
+};
+
+BasePoint.prototype.encode = function encode(enc, compact) {
+  return utils.encode(this._encode(compact), enc);
+};
+
+BasePoint.prototype.precompute = function precompute(power) {
+  if (this.precomputed)
+    return this;
+
+  var precomputed = {
+    doubles: null,
+    naf: null,
+    beta: null
+  };
+  precomputed.naf = this._getNAFPoints(8);
+  precomputed.doubles = this._getDoubles(4, power);
+  precomputed.beta = this._getBeta();
+  this.precomputed = precomputed;
+
+  return this;
+};
+
+BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
+  if (!this.precomputed)
+    return false;
+
+  var doubles = this.precomputed.doubles;
+  if (!doubles)
+    return false;
+
+  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
+};
+
+BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
+  if (this.precomputed && this.precomputed.doubles)
+    return this.precomputed.doubles;
+
+  var doubles = [ this ];
+  var acc = this;
+  for (var i = 0; i < power; i += step) {
+    for (var j = 0; j < step; j++)
+      acc = acc.dbl();
+    doubles.push(acc);
+  }
+  return {
+    step: step,
+    points: doubles
+  };
+};
+
+BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
+  if (this.precomputed && this.precomputed.naf)
+    return this.precomputed.naf;
+
+  var res = [ this ];
+  var max = (1 << wnd) - 1;
+  var dbl = max === 1 ? null : this.dbl();
+  for (var i = 1; i < max; i++)
+    res[i] = res[i - 1].add(dbl);
+  return {
+    wnd: wnd,
+    points: res
+  };
+};
+
+BasePoint.prototype._getBeta = function _getBeta() {
+  return null;
+};
+
+BasePoint.prototype.dblp = function dblp(k) {
+  var r = this;
+  for (var i = 0; i < k; i++)
+    r = r.dbl();
+  return r;
+};
+
+},{"../../elliptic":74,"bn.js":24}],76:[function(require,module,exports){
+'use strict';
+
+var curve = require('../curve');
+var elliptic = require('../../elliptic');
+var BN = require('bn.js');
+var inherits = require('inherits');
+var Base = curve.base;
+
+var assert = elliptic.utils.assert;
+
+function EdwardsCurve(conf) {
+  // NOTE: Important as we are creating point in Base.call()
+  this.twisted = (conf.a | 0) !== 1;
+  this.mOneA = this.twisted && (conf.a | 0) === -1;
+  this.extended = this.mOneA;
+
+  Base.call(this, 'edwards', conf);
+
+  this.a = new BN(conf.a, 16).umod(this.red.m);
+  this.a = this.a.toRed(this.red);
+  this.c = new BN(conf.c, 16).toRed(this.red);
+  this.c2 = this.c.redSqr();
+  this.d = new BN(conf.d, 16).toRed(this.red);
+  this.dd = this.d.redAdd(this.d);
+
+  assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
+  this.oneC = (conf.c | 0) === 1;
+}
+inherits(EdwardsCurve, Base);
+module.exports = EdwardsCurve;
+
+EdwardsCurve.prototype._mulA = function _mulA(num) {
+  if (this.mOneA)
+    return num.redNeg();
+  else
+    return this.a.redMul(num);
+};
+
+EdwardsCurve.prototype._mulC = function _mulC(num) {
+  if (this.oneC)
+    return num;
+  else
+    return this.c.redMul(num);
+};
+
+// Just for compatibility with Short curve
+EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
+  return this.point(x, y, z, t);
+};
+
+EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
+  x = new BN(x, 16);
+  if (!x.red)
+    x = x.toRed(this.red);
+
+  var x2 = x.redSqr();
+  var rhs = this.c2.redSub(this.a.redMul(x2));
+  var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
+
+  var y2 = rhs.redMul(lhs.redInvm());
+  var y = y2.redSqrt();
+  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
+    throw new Error('invalid point');
+
+  var isOdd = y.fromRed().isOdd();
+  if (odd && !isOdd || !odd && isOdd)
+    y = y.redNeg();
+
+  return this.point(x, y);
+};
+
+EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
+  y = new BN(y, 16);
+  if (!y.red)
+    y = y.toRed(this.red);
+
+  // x^2 = (y^2 - 1) / (d y^2 + 1)
+  var y2 = y.redSqr();
+  var lhs = y2.redSub(this.one);
+  var rhs = y2.redMul(this.d).redAdd(this.one);
+  var x2 = lhs.redMul(rhs.redInvm());
+
+  if (x2.cmp(this.zero) === 0) {
+    if (odd)
+      throw new Error('invalid point');
+    else
+      return this.point(this.zero, y);
+  }
+
+  var x = x2.redSqrt();
+  if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)
+    throw new Error('invalid point');
+
+  if (x.isOdd() !== odd)
+    x = x.redNeg();
+
+  return this.point(x, y);
+};
+
+EdwardsCurve.prototype.validate = function validate(point) {
+  if (point.isInfinity())
+    return true;
+
+  // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)
+  point.normalize();
+
+  var x2 = point.x.redSqr();
+  var y2 = point.y.redSqr();
+  var lhs = x2.redMul(this.a).redAdd(y2);
+  var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
+
+  return lhs.cmp(rhs) === 0;
+};
+
+function Point(curve, x, y, z, t) {
+  Base.BasePoint.call(this, curve, 'projective');
+  if (x === null && y === null && z === null) {
+    this.x = this.curve.zero;
+    this.y = this.curve.one;
+    this.z = this.curve.one;
+    this.t = this.curve.zero;
+    this.zOne = true;
+  } else {
+    this.x = new BN(x, 16);
+    this.y = new BN(y, 16);
+    this.z = z ? new BN(z, 16) : this.curve.one;
+    this.t = t && new BN(t, 16);
+    if (!this.x.red)
+      this.x = this.x.toRed(this.curve.red);
+    if (!this.y.red)
+      this.y = this.y.toRed(this.curve.red);
+    if (!this.z.red)
+      this.z = this.z.toRed(this.curve.red);
+    if (this.t && !this.t.red)
+      this.t = this.t.toRed(this.curve.red);
+    this.zOne = this.z === this.curve.one;
+
+    // Use extended coordinates
+    if (this.curve.extended && !this.t) {
+      this.t = this.x.redMul(this.y);
+      if (!this.zOne)
+        this.t = this.t.redMul(this.z.redInvm());
+    }
+  }
+}
+inherits(Point, Base.BasePoint);
+
+EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
+  return Point.fromJSON(this, obj);
+};
+
+EdwardsCurve.prototype.point = function point(x, y, z, t) {
+  return new Point(this, x, y, z, t);
+};
+
+Point.fromJSON = function fromJSON(curve, obj) {
+  return new Point(curve, obj[0], obj[1], obj[2]);
+};
+
+Point.prototype.inspect = function inspect() {
+  if (this.isInfinity())
+    return '<EC Point Infinity>';
+  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
+      ' y: ' + this.y.fromRed().toString(16, 2) +
+      ' z: ' + this.z.fromRed().toString(16, 2) + '>';
+};
+
+Point.prototype.isInfinity = function isInfinity() {
+  // XXX This code assumes that zero is always zero in red
+  return this.x.cmpn(0) === 0 &&
+         this.y.cmp(this.z) === 0;
+};
+
+Point.prototype._extDbl = function _extDbl() {
+  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
+  //     #doubling-dbl-2008-hwcd
+  // 4M + 4S
+
+  // A = X1^2
+  var a = this.x.redSqr();
+  // B = Y1^2
+  var b = this.y.redSqr();
+  // C = 2 * Z1^2
+  var c = this.z.redSqr();
+  c = c.redIAdd(c);
+  // D = a * A
+  var d = this.curve._mulA(a);
+  // E = (X1 + Y1)^2 - A - B
+  var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);
+  // G = D + B
+  var g = d.redAdd(b);
+  // F = G - C
+  var f = g.redSub(c);
+  // H = D - B
+  var h = d.redSub(b);
+  // X3 = E * F
+  var nx = e.redMul(f);
+  // Y3 = G * H
+  var ny = g.redMul(h);
+  // T3 = E * H
+  var nt = e.redMul(h);
+  // Z3 = F * G
+  var nz = f.redMul(g);
+  return this.curve.point(nx, ny, nz, nt);
+};
+
+Point.prototype._projDbl = function _projDbl() {
+  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
+  //     #doubling-dbl-2008-bbjlp
+  //     #doubling-dbl-2007-bl
+  // and others
+  // Generally 3M + 4S or 2M + 4S
+
+  // B = (X1 + Y1)^2
+  var b = this.x.redAdd(this.y).redSqr();
+  // C = X1^2
+  var c = this.x.redSqr();
+  // D = Y1^2
+  var d = this.y.redSqr();
+
+  var nx;
+  var ny;
+  var nz;
+  if (this.curve.twisted) {
+    // E = a * C
+    var e = this.curve._mulA(c);
+    // F = E + D
+    var f = e.redAdd(d);
+    if (this.zOne) {
+      // X3 = (B - C - D) * (F - 2)
+      nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));
+      // Y3 = F * (E - D)
+      ny = f.redMul(e.redSub(d));
+      // Z3 = F^2 - 2 * F
+      nz = f.redSqr().redSub(f).redSub(f);
+    } else {
+      // H = Z1^2
+      var h = this.z.redSqr();
+      // J = F - 2 * H
+      var j = f.redSub(h).redISub(h);
+      // X3 = (B-C-D)*J
+      nx = b.redSub(c).redISub(d).redMul(j);
+      // Y3 = F * (E - D)
+      ny = f.redMul(e.redSub(d));
+      // Z3 = F * J
+      nz = f.redMul(j);
+    }
+  } else {
+    // E = C + D
+    var e = c.redAdd(d);
+    // H = (c * Z1)^2
+    var h = this.curve._mulC(this.c.redMul(this.z)).redSqr();
+    // J = E - 2 * H
+    var j = e.redSub(h).redSub(h);
+    // X3 = c * (B - E) * J
+    nx = this.curve._mulC(b.redISub(e)).redMul(j);
+    // Y3 = c * E * (C - D)
+    ny = this.curve._mulC(e).redMul(c.redISub(d));
+    // Z3 = E * J
+    nz = e.redMul(j);
+  }
+  return this.curve.point(nx, ny, nz);
+};
+
+Point.prototype.dbl = function dbl() {
+  if (this.isInfinity())
+    return this;
+
+  // Double in extended coordinates
+  if (this.curve.extended)
+    return this._extDbl();
+  else
+    return this._projDbl();
+};
+
+Point.prototype._extAdd = function _extAdd(p) {
+  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
+  //     #addition-add-2008-hwcd-3
+  // 8M
+
+  // A = (Y1 - X1) * (Y2 - X2)
+  var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));
+  // B = (Y1 + X1) * (Y2 + X2)
+  var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));
+  // C = T1 * k * T2
+  var c = this.t.redMul(this.curve.dd).redMul(p.t);
+  // D = Z1 * 2 * Z2
+  var d = this.z.redMul(p.z.redAdd(p.z));
+  // E = B - A
+  var e = b.redSub(a);
+  // F = D - C
+  var f = d.redSub(c);
+  // G = D + C
+  var g = d.redAdd(c);
+  // H = B + A
+  var h = b.redAdd(a);
+  // X3 = E * F
+  var nx = e.redMul(f);
+  // Y3 = G * H
+  var ny = g.redMul(h);
+  // T3 = E * H
+  var nt = e.redMul(h);
+  // Z3 = F * G
+  var nz = f.redMul(g);
+  return this.curve.point(nx, ny, nz, nt);
+};
+
+Point.prototype._projAdd = function _projAdd(p) {
+  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
+  //     #addition-add-2008-bbjlp
+  //     #addition-add-2007-bl
+  // 10M + 1S
+
+  // A = Z1 * Z2
+  var a = this.z.redMul(p.z);
+  // B = A^2
+  var b = a.redSqr();
+  // C = X1 * X2
+  var c = this.x.redMul(p.x);
+  // D = Y1 * Y2
+  var d = this.y.redMul(p.y);
+  // E = d * C * D
+  var e = this.curve.d.redMul(c).redMul(d);
+  // F = B - E
+  var f = b.redSub(e);
+  // G = B + E
+  var g = b.redAdd(e);
+  // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)
+  var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
+  var nx = a.redMul(f).redMul(tmp);
+  var ny;
+  var nz;
+  if (this.curve.twisted) {
+    // Y3 = A * G * (D - a * C)
+    ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));
+    // Z3 = F * G
+    nz = f.redMul(g);
+  } else {
+    // Y3 = A * G * (D - C)
+    ny = a.redMul(g).redMul(d.redSub(c));
+    // Z3 = c * F * G
+    nz = this.curve._mulC(f).redMul(g);
+  }
+  return this.curve.point(nx, ny, nz);
+};
+
+Point.prototype.add = function add(p) {
+  if (this.isInfinity())
+    return p;
+  if (p.isInfinity())
+    return this;
+
+  if (this.curve.extended)
+    return this._extAdd(p);
+  else
+    return this._projAdd(p);
+};
+
+Point.prototype.mul = function mul(k) {
+  if (this._hasDoubles(k))
+    return this.curve._fixedNafMul(this, k);
+  else
+    return this.curve._wnafMul(this, k);
+};
+
+Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
+  return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, false);
+};
+
+Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
+  return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, true);
+};
+
+Point.prototype.normalize = function normalize() {
+  if (this.zOne)
+    return this;
+
+  // Normalize coordinates
+  var zi = this.z.redInvm();
+  this.x = this.x.redMul(zi);
+  this.y = this.y.redMul(zi);
+  if (this.t)
+    this.t = this.t.redMul(zi);
+  this.z = this.curve.one;
+  this.zOne = true;
+  return this;
+};
+
+Point.prototype.neg = function neg() {
+  return this.curve.point(this.x.redNeg(),
+                          this.y,
+                          this.z,
+                          this.t && this.t.redNeg());
+};
+
+Point.prototype.getX = function getX() {
+  this.normalize();
+  return this.x.fromRed();
+};
+
+Point.prototype.getY = function getY() {
+  this.normalize();
+  return this.y.fromRed();
+};
+
+Point.prototype.eq = function eq(other) {
+  return this === other ||
+         this.getX().cmp(other.getX()) === 0 &&
+         this.getY().cmp(other.getY()) === 0;
+};
+
+Point.prototype.eqXToP = function eqXToP(x) {
+  var rx = x.toRed(this.curve.red).redMul(this.z);
+  if (this.x.cmp(rx) === 0)
+    return true;
+
+  var xc = x.clone();
+  var t = this.curve.redN.redMul(this.z);
+  for (;;) {
+    xc.iadd(this.curve.n);
+    if (xc.cmp(this.curve.p) >= 0)
+      return false;
+
+    rx.redIAdd(t);
+    if (this.x.cmp(rx) === 0)
+      return true;
+  }
+  return false;
+};
+
+// Compatibility with BaseCurve
+Point.prototype.toP = Point.prototype.normalize;
+Point.prototype.mixedAdd = Point.prototype.add;
+
+},{"../../elliptic":74,"../curve":77,"bn.js":24,"inherits":107}],77:[function(require,module,exports){
+'use strict';
+
+var curve = exports;
+
+curve.base = require('./base');
+curve.short = require('./short');
+curve.mont = require('./mont');
+curve.edwards = require('./edwards');
+
+},{"./base":75,"./edwards":76,"./mont":78,"./short":79}],78:[function(require,module,exports){
+'use strict';
+
+var curve = require('../curve');
+var BN = require('bn.js');
+var inherits = require('inherits');
+var Base = curve.base;
+
+var elliptic = require('../../elliptic');
+var utils = elliptic.utils;
+
+function MontCurve(conf) {
+  Base.call(this, 'mont', conf);
+
+  this.a = new BN(conf.a, 16).toRed(this.red);
+  this.b = new BN(conf.b, 16).toRed(this.red);
+  this.i4 = new BN(4).toRed(this.red).redInvm();
+  this.two = new BN(2).toRed(this.red);
+  this.a24 = this.i4.redMul(this.a.redAdd(this.two));
+}
+inherits(MontCurve, Base);
+module.exports = MontCurve;
+
+MontCurve.prototype.validate = function validate(point) {
+  var x = point.normalize().x;
+  var x2 = x.redSqr();
+  var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
+  var y = rhs.redSqrt();
+
+  return y.redSqr().cmp(rhs) === 0;
+};
+
+function Point(curve, x, z) {
+  Base.BasePoint.call(this, curve, 'projective');
+  if (x === null && z === null) {
+    this.x = this.curve.one;
+    this.z = this.curve.zero;
+  } else {
+    this.x = new BN(x, 16);
+    this.z = new BN(z, 16);
+    if (!this.x.red)
+      this.x = this.x.toRed(this.curve.red);
+    if (!this.z.red)
+      this.z = this.z.toRed(this.curve.red);
+  }
+}
+inherits(Point, Base.BasePoint);
+
+MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
+  return this.point(utils.toArray(bytes, enc), 1);
+};
+
+MontCurve.prototype.point = function point(x, z) {
+  return new Point(this, x, z);
+};
+
+MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
+  return Point.fromJSON(this, obj);
+};
+
+Point.prototype.precompute = function precompute() {
+  // No-op
+};
+
+Point.prototype._encode = function _encode() {
+  return this.getX().toArray('be', this.curve.p.byteLength());
+};
+
+Point.fromJSON = function fromJSON(curve, obj) {
+  return new Point(curve, obj[0], obj[1] || curve.one);
+};
+
+Point.prototype.inspect = function inspect() {
+  if (this.isInfinity())
+    return '<EC Point Infinity>';
+  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
+      ' z: ' + this.z.fromRed().toString(16, 2) + '>';
+};
+
+Point.prototype.isInfinity = function isInfinity() {
+  // XXX This code assumes that zero is always zero in red
+  return this.z.cmpn(0) === 0;
+};
+
+Point.prototype.dbl = function dbl() {
+  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3
+  // 2M + 2S + 4A
+
+  // A = X1 + Z1
+  var a = this.x.redAdd(this.z);
+  // AA = A^2
+  var aa = a.redSqr();
+  // B = X1 - Z1
+  var b = this.x.redSub(this.z);
+  // BB = B^2
+  var bb = b.redSqr();
+  // C = AA - BB
+  var c = aa.redSub(bb);
+  // X3 = AA * BB
+  var nx = aa.redMul(bb);
+  // Z3 = C * (BB + A24 * C)
+  var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
+  return this.curve.point(nx, nz);
+};
+
+Point.prototype.add = function add() {
+  throw new Error('Not supported on Montgomery curve');
+};
+
+Point.prototype.diffAdd = function diffAdd(p, diff) {
+  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3
+  // 4M + 2S + 6A
+
+  // A = X2 + Z2
+  var a = this.x.redAdd(this.z);
+  // B = X2 - Z2
+  var b = this.x.redSub(this.z);
+  // C = X3 + Z3
+  var c = p.x.redAdd(p.z);
+  // D = X3 - Z3
+  var d = p.x.redSub(p.z);
+  // DA = D * A
+  var da = d.redMul(a);
+  // CB = C * B
+  var cb = c.redMul(b);
+  // X5 = Z1 * (DA + CB)^2
+  var nx = diff.z.redMul(da.redAdd(cb).redSqr());
+  // Z5 = X1 * (DA - CB)^2
+  var nz = diff.x.redMul(da.redISub(cb).redSqr());
+  return this.curve.point(nx, nz);
+};
+
+Point.prototype.mul = function mul(k) {
+  var t = k.clone();
+  var a = this; // (N / 2) * Q + Q
+  var b = this.curve.point(null, null); // (N / 2) * Q
+  var c = this; // Q
+
+  for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))
+    bits.push(t.andln(1));
+
+  for (var i = bits.length - 1; i >= 0; i--) {
+    if (bits[i] === 0) {
+      // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q
+      a = a.diffAdd(b, c);
+      // N * Q = 2 * ((N / 2) * Q + Q))
+      b = b.dbl();
+    } else {
+      // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)
+      b = a.diffAdd(b, c);
+      // N * Q + Q = 2 * ((N / 2) * Q + Q)
+      a = a.dbl();
+    }
+  }
+  return b;
+};
+
+Point.prototype.mulAdd = function mulAdd() {
+  throw new Error('Not supported on Montgomery curve');
+};
+
+Point.prototype.jumlAdd = function jumlAdd() {
+  throw new Error('Not supported on Montgomery curve');
+};
+
+Point.prototype.eq = function eq(other) {
+  return this.getX().cmp(other.getX()) === 0;
+};
+
+Point.prototype.normalize = function normalize() {
+  this.x = this.x.redMul(this.z.redInvm());
+  this.z = this.curve.one;
+  return this;
+};
+
+Point.prototype.getX = function getX() {
+  // Normalize coordinates
+  this.normalize();
+
+  return this.x.fromRed();
+};
+
+},{"../../elliptic":74,"../curve":77,"bn.js":24,"inherits":107}],79:[function(require,module,exports){
+'use strict';
+
+var curve = require('../curve');
+var elliptic = require('../../elliptic');
+var BN = require('bn.js');
+var inherits = require('inherits');
+var Base = curve.base;
+
+var assert = elliptic.utils.assert;
+
+function ShortCurve(conf) {
+  Base.call(this, 'short', conf);
+
+  this.a = new BN(conf.a, 16).toRed(this.red);
+  this.b = new BN(conf.b, 16).toRed(this.red);
+  this.tinv = this.two.redInvm();
+
+  this.zeroA = this.a.fromRed().cmpn(0) === 0;
+  this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;
+
+  // If the curve is endomorphic, precalculate beta and lambda
+  this.endo = this._getEndomorphism(conf);
+  this._endoWnafT1 = new Array(4);
+  this._endoWnafT2 = new Array(4);
+}
+inherits(ShortCurve, Base);
+module.exports = ShortCurve;
+
+ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
+  // No efficient endomorphism
+  if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)
+    return;
+
+  // Compute beta and lambda, that lambda * P = (beta * Px; Py)
+  var beta;
+  var lambda;
+  if (conf.beta) {
+    beta = new BN(conf.beta, 16).toRed(this.red);
+  } else {
+    var betas = this._getEndoRoots(this.p);
+    // Choose the smallest beta
+    beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
+    beta = beta.toRed(this.red);
+  }
+  if (conf.lambda) {
+    lambda = new BN(conf.lambda, 16);
+  } else {
+    // Choose the lambda that is matching selected beta
+    var lambdas = this._getEndoRoots(this.n);
+    if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
+      lambda = lambdas[0];
+    } else {
+      lambda = lambdas[1];
+      assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
+    }
+  }
+
+  // Get basis vectors, used for balanced length-two representation
+  var basis;
+  if (conf.basis) {
+    basis = conf.basis.map(function(vec) {
+      return {
+        a: new BN(vec.a, 16),
+        b: new BN(vec.b, 16)
+      };
+    });
+  } else {
+    basis = this._getEndoBasis(lambda);
+  }
+
+  return {
+    beta: beta,
+    lambda: lambda,
+    basis: basis
+  };
+};
+
+ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
+  // Find roots of for x^2 + x + 1 in F
+  // Root = (-1 +- Sqrt(-3)) / 2
+  //
+  var red = num === this.p ? this.red : BN.mont(num);
+  var tinv = new BN(2).toRed(red).redInvm();
+  var ntinv = tinv.redNeg();
+
+  var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
+
+  var l1 = ntinv.redAdd(s).fromRed();
+  var l2 = ntinv.redSub(s).fromRed();
+  return [ l1, l2 ];
+};
+
+ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
+  // aprxSqrt >= sqrt(this.n)
+  var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
+
+  // 3.74
+  // Run EGCD, until r(L + 1) < aprxSqrt
+  var u = lambda;
+  var v = this.n.clone();
+  var x1 = new BN(1);
+  var y1 = new BN(0);
+  var x2 = new BN(0);
+  var y2 = new BN(1);
+
+  // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)
+  var a0;
+  var b0;
+  // First vector
+  var a1;
+  var b1;
+  // Second vector
+  var a2;
+  var b2;
+
+  var prevR;
+  var i = 0;
+  var r;
+  var x;
+  while (u.cmpn(0) !== 0) {
+    var q = v.div(u);
+    r = v.sub(q.mul(u));
+    x = x2.sub(q.mul(x1));
+    var y = y2.sub(q.mul(y1));
+
+    if (!a1 && r.cmp(aprxSqrt) < 0) {
+      a0 = prevR.neg();
+      b0 = x1;
+      a1 = r.neg();
+      b1 = x;
+    } else if (a1 && ++i === 2) {
+      break;
+    }
+    prevR = r;
+
+    v = u;
+    u = r;
+    x2 = x1;
+    x1 = x;
+    y2 = y1;
+    y1 = y;
+  }
+  a2 = r.neg();
+  b2 = x;
+
+  var len1 = a1.sqr().add(b1.sqr());
+  var len2 = a2.sqr().add(b2.sqr());
+  if (len2.cmp(len1) >= 0) {
+    a2 = a0;
+    b2 = b0;
+  }
+
+  // Normalize signs
+  if (a1.negative) {
+    a1 = a1.neg();
+    b1 = b1.neg();
+  }
+  if (a2.negative) {
+    a2 = a2.neg();
+    b2 = b2.neg();
+  }
+
+  return [
+    { a: a1, b: b1 },
+    { a: a2, b: b2 }
+  ];
+};
+
+ShortCurve.prototype._endoSplit = function _endoSplit(k) {
+  var basis = this.endo.basis;
+  var v1 = basis[0];
+  var v2 = basis[1];
+
+  var c1 = v2.b.mul(k).divRound(this.n);
+  var c2 = v1.b.neg().mul(k).divRound(this.n);
+
+  var p1 = c1.mul(v1.a);
+  var p2 = c2.mul(v2.a);
+  var q1 = c1.mul(v1.b);
+  var q2 = c2.mul(v2.b);
+
+  // Calculate answer
+  var k1 = k.sub(p1).sub(p2);
+  var k2 = q1.add(q2).neg();
+  return { k1: k1, k2: k2 };
+};
+
+ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
+  x = new BN(x, 16);
+  if (!x.red)
+    x = x.toRed(this.red);
+
+  var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
+  var y = y2.redSqrt();
+  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
+    throw new Error('invalid point');
+
+  // XXX Is there any way to tell if the number is odd without converting it
+  // to non-red form?
+  var isOdd = y.fromRed().isOdd();
+  if (odd && !isOdd || !odd && isOdd)
+    y = y.redNeg();
+
+  return this.point(x, y);
+};
+
+ShortCurve.prototype.validate = function validate(point) {
+  if (point.inf)
+    return true;
+
+  var x = point.x;
+  var y = point.y;
+
+  var ax = this.a.redMul(x);
+  var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
+  return y.redSqr().redISub(rhs).cmpn(0) === 0;
+};
+
+ShortCurve.prototype._endoWnafMulAdd =
+    function _endoWnafMulAdd(points, coeffs, jacobianResult) {
+  var npoints = this._endoWnafT1;
+  var ncoeffs = this._endoWnafT2;
+  for (var i = 0; i < points.length; i++) {
+    var split = this._endoSplit(coeffs[i]);
+    var p = points[i];
+    var beta = p._getBeta();
+
+    if (split.k1.negative) {
+      split.k1.ineg();
+      p = p.neg(true);
+    }
+    if (split.k2.negative) {
+      split.k2.ineg();
+      beta = beta.neg(true);
+    }
+
+    npoints[i * 2] = p;
+    npoints[i * 2 + 1] = beta;
+    ncoeffs[i * 2] = split.k1;
+    ncoeffs[i * 2 + 1] = split.k2;
+  }
+  var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);
+
+  // Clean-up references to points and coefficients
+  for (var j = 0; j < i * 2; j++) {
+    npoints[j] = null;
+    ncoeffs[j] = null;
+  }
+  return res;
+};
+
+function Point(curve, x, y, isRed) {
+  Base.BasePoint.call(this, curve, 'affine');
+  if (x === null && y === null) {
+    this.x = null;
+    this.y = null;
+    this.inf = true;
+  } else {
+    this.x = new BN(x, 16);
+    this.y = new BN(y, 16);
+    // Force redgomery representation when loading from JSON
+    if (isRed) {
+      this.x.forceRed(this.curve.red);
+      this.y.forceRed(this.curve.red);
+    }
+    if (!this.x.red)
+      this.x = this.x.toRed(this.curve.red);
+    if (!this.y.red)
+      this.y = this.y.toRed(this.curve.red);
+    this.inf = false;
+  }
+}
+inherits(Point, Base.BasePoint);
+
+ShortCurve.prototype.point = function point(x, y, isRed) {
+  return new Point(this, x, y, isRed);
+};
+
+ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
+  return Point.fromJSON(this, obj, red);
+};
+
+Point.prototype._getBeta = function _getBeta() {
+  if (!this.curve.endo)
+    return;
+
+  var pre = this.precomputed;
+  if (pre && pre.beta)
+    return pre.beta;
+
+  var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
+  if (pre) {
+    var curve = this.curve;
+    var endoMul = function(p) {
+      return curve.point(p.x.redMul(curve.endo.beta), p.y);
+    };
+    pre.beta = beta;
+    beta.precomputed = {
+      beta: null,
+      naf: pre.naf && {
+        wnd: pre.naf.wnd,
+        points: pre.naf.points.map(endoMul)
+      },
+      doubles: pre.doubles && {
+        step: pre.doubles.step,
+        points: pre.doubles.points.map(endoMul)
+      }
+    };
+  }
+  return beta;
+};
+
+Point.prototype.toJSON = function toJSON() {
+  if (!this.precomputed)
+    return [ this.x, this.y ];
+
+  return [ this.x, this.y, this.precomputed && {
+    doubles: this.precomputed.doubles && {
+      step: this.precomputed.doubles.step,
+      points: this.precomputed.doubles.points.slice(1)
+    },
+    naf: this.precomputed.naf && {
+      wnd: this.precomputed.naf.wnd,
+      points: this.precomputed.naf.points.slice(1)
+    }
+  } ];
+};
+
+Point.fromJSON = function fromJSON(curve, obj, red) {
+  if (typeof obj === 'string')
+    obj = JSON.parse(obj);
+  var res = curve.point(obj[0], obj[1], red);
+  if (!obj[2])
+    return res;
+
+  function obj2point(obj) {
+    return curve.point(obj[0], obj[1], red);
+  }
+
+  var pre = obj[2];
+  res.precomputed = {
+    beta: null,
+    doubles: pre.doubles && {
+      step: pre.doubles.step,
+      points: [ res ].concat(pre.doubles.points.map(obj2point))
+    },
+    naf: pre.naf && {
+      wnd: pre.naf.wnd,
+      points: [ res ].concat(pre.naf.points.map(obj2point))
+    }
+  };
+  return res;
+};
+
+Point.prototype.inspect = function inspect() {
+  if (this.isInfinity())
+    return '<EC Point Infinity>';
+  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
+      ' y: ' + this.y.fromRed().toString(16, 2) + '>';
+};
+
+Point.prototype.isInfinity = function isInfinity() {
+  return this.inf;
+};
+
+Point.prototype.add = function add(p) {
+  // O + P = P
+  if (this.inf)
+    return p;
+
+  // P + O = P
+  if (p.inf)
+    return this;
+
+  // P + P = 2P
+  if (this.eq(p))
+    return this.dbl();
+
+  // P + (-P) = O
+  if (this.neg().eq(p))
+    return this.curve.point(null, null);
+
+  // P + Q = O
+  if (this.x.cmp(p.x) === 0)
+    return this.curve.point(null, null);
+
+  var c = this.y.redSub(p.y);
+  if (c.cmpn(0) !== 0)
+    c = c.redMul(this.x.redSub(p.x).redInvm());
+  var nx = c.redSqr().redISub(this.x).redISub(p.x);
+  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
+  return this.curve.point(nx, ny);
+};
+
+Point.prototype.dbl = function dbl() {
+  if (this.inf)
+    return this;
+
+  // 2P = O
+  var ys1 = this.y.redAdd(this.y);
+  if (ys1.cmpn(0) === 0)
+    return this.curve.point(null, null);
+
+  var a = this.curve.a;
+
+  var x2 = this.x.redSqr();
+  var dyinv = ys1.redInvm();
+  var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
+
+  var nx = c.redSqr().redISub(this.x.redAdd(this.x));
+  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
+  return this.curve.point(nx, ny);
+};
+
+Point.prototype.getX = function getX() {
+  return this.x.fromRed();
+};
+
+Point.prototype.getY = function getY() {
+  return this.y.fromRed();
+};
+
+Point.prototype.mul = function mul(k) {
+  k = new BN(k, 16);
+
+  if (this._hasDoubles(k))
+    return this.curve._fixedNafMul(this, k);
+  else if (this.curve.endo)
+    return this.curve._endoWnafMulAdd([ this ], [ k ]);
+  else
+    return this.curve._wnafMul(this, k);
+};
+
+Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
+  var points = [ this, p2 ];
+  var coeffs = [ k1, k2 ];
+  if (this.curve.endo)
+    return this.curve._endoWnafMulAdd(points, coeffs);
+  else
+    return this.curve._wnafMulAdd(1, points, coeffs, 2);
+};
+
+Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
+  var points = [ this, p2 ];
+  var coeffs = [ k1, k2 ];
+  if (this.curve.endo)
+    return this.curve._endoWnafMulAdd(points, coeffs, true);
+  else
+    return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
+};
+
+Point.prototype.eq = function eq(p) {
+  return this === p ||
+         this.inf === p.inf &&
+             (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
+};
+
+Point.prototype.neg = function neg(_precompute) {
+  if (this.inf)
+    return this;
+
+  var res = this.curve.point(this.x, this.y.redNeg());
+  if (_precompute && this.precomputed) {
+    var pre = this.precomputed;
+    var negate = function(p) {
+      return p.neg();
+    };
+    res.precomputed = {
+      naf: pre.naf && {
+        wnd: pre.naf.wnd,
+        points: pre.naf.points.map(negate)
+      },
+      doubles: pre.doubles && {
+        step: pre.doubles.step,
+        points: pre.doubles.points.map(negate)
+      }
+    };
+  }
+  return res;
+};
+
+Point.prototype.toJ = function toJ() {
+  if (this.inf)
+    return this.curve.jpoint(null, null, null);
+
+  var res = this.curve.jpoint(this.x, this.y, this.curve.one);
+  return res;
+};
+
+function JPoint(curve, x, y, z) {
+  Base.BasePoint.call(this, curve, 'jacobian');
+  if (x === null && y === null && z === null) {
+    this.x = this.curve.one;
+    this.y = this.curve.one;
+    this.z = new BN(0);
+  } else {
+    this.x = new BN(x, 16);
+    this.y = new BN(y, 16);
+    this.z = new BN(z, 16);
+  }
+  if (!this.x.red)
+    this.x = this.x.toRed(this.curve.red);
+  if (!this.y.red)
+    this.y = this.y.toRed(this.curve.red);
+  if (!this.z.red)
+    this.z = this.z.toRed(this.curve.red);
+
+  this.zOne = this.z === this.curve.one;
+}
+inherits(JPoint, Base.BasePoint);
+
+ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
+  return new JPoint(this, x, y, z);
+};
+
+JPoint.prototype.toP = function toP() {
+  if (this.isInfinity())
+    return this.curve.point(null, null);
+
+  var zinv = this.z.redInvm();
+  var zinv2 = zinv.redSqr();
+  var ax = this.x.redMul(zinv2);
+  var ay = this.y.redMul(zinv2).redMul(zinv);
+
+  return this.curve.point(ax, ay);
+};
+
+JPoint.prototype.neg = function neg() {
+  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
+};
+
+JPoint.prototype.add = function add(p) {
+  // O + P = P
+  if (this.isInfinity())
+    return p;
+
+  // P + O = P
+  if (p.isInfinity())
+    return this;
+
+  // 12M + 4S + 7A
+  var pz2 = p.z.redSqr();
+  var z2 = this.z.redSqr();
+  var u1 = this.x.redMul(pz2);
+  var u2 = p.x.redMul(z2);
+  var s1 = this.y.redMul(pz2.redMul(p.z));
+  var s2 = p.y.redMul(z2.redMul(this.z));
+
+  var h = u1.redSub(u2);
+  var r = s1.redSub(s2);
+  if (h.cmpn(0) === 0) {
+    if (r.cmpn(0) !== 0)
+      return this.curve.jpoint(null, null, null);
+    else
+      return this.dbl();
+  }
+
+  var h2 = h.redSqr();
+  var h3 = h2.redMul(h);
+  var v = u1.redMul(h2);
+
+  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
+  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
+  var nz = this.z.redMul(p.z).redMul(h);
+
+  return this.curve.jpoint(nx, ny, nz);
+};
+
+JPoint.prototype.mixedAdd = function mixedAdd(p) {
+  // O + P = P
+  if (this.isInfinity())
+    return p.toJ();
+
+  // P + O = P
+  if (p.isInfinity())
+    return this;
+
+  // 8M + 3S + 7A
+  var z2 = this.z.redSqr();
+  var u1 = this.x;
+  var u2 = p.x.redMul(z2);
+  var s1 = this.y;
+  var s2 = p.y.redMul(z2).redMul(this.z);
+
+  var h = u1.redSub(u2);
+  var r = s1.redSub(s2);
+  if (h.cmpn(0) === 0) {
+    if (r.cmpn(0) !== 0)
+      return this.curve.jpoint(null, null, null);
+    else
+      return this.dbl();
+  }
+
+  var h2 = h.redSqr();
+  var h3 = h2.redMul(h);
+  var v = u1.redMul(h2);
+
+  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
+  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
+  var nz = this.z.redMul(h);
+
+  return this.curve.jpoint(nx, ny, nz);
+};
+
+JPoint.prototype.dblp = function dblp(pow) {
+  if (pow === 0)
+    return this;
+  if (this.isInfinity())
+    return this;
+  if (!pow)
+    return this.dbl();
+
+  if (this.curve.zeroA || this.curve.threeA) {
+    var r = this;
+    for (var i = 0; i < pow; i++)
+      r = r.dbl();
+    return r;
+  }
+
+  // 1M + 2S + 1A + N * (4S + 5M + 8A)
+  // N = 1 => 6M + 6S + 9A
+  var a = this.curve.a;
+  var tinv = this.curve.tinv;
+
+  var jx = this.x;
+  var jy = this.y;
+  var jz = this.z;
+  var jz4 = jz.redSqr().redSqr();
+
+  // Reuse results
+  var jyd = jy.redAdd(jy);
+  for (var i = 0; i < pow; i++) {
+    var jx2 = jx.redSqr();
+    var jyd2 = jyd.redSqr();
+    var jyd4 = jyd2.redSqr();
+    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
+
+    var t1 = jx.redMul(jyd2);
+    var nx = c.redSqr().redISub(t1.redAdd(t1));
+    var t2 = t1.redISub(nx);
+    var dny = c.redMul(t2);
+    dny = dny.redIAdd(dny).redISub(jyd4);
+    var nz = jyd.redMul(jz);
+    if (i + 1 < pow)
+      jz4 = jz4.redMul(jyd4);
+
+    jx = nx;
+    jz = nz;
+    jyd = dny;
+  }
+
+  return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
+};
+
+JPoint.prototype.dbl = function dbl() {
+  if (this.isInfinity())
+    return this;
+
+  if (this.curve.zeroA)
+    return this._zeroDbl();
+  else if (this.curve.threeA)
+    return this._threeDbl();
+  else
+    return this._dbl();
+};
+
+JPoint.prototype._zeroDbl = function _zeroDbl() {
+  var nx;
+  var ny;
+  var nz;
+  // Z = 1
+  if (this.zOne) {
+    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
+    //     #doubling-mdbl-2007-bl
+    // 1M + 5S + 14A
+
+    // XX = X1^2
+    var xx = this.x.redSqr();
+    // YY = Y1^2
+    var yy = this.y.redSqr();
+    // YYYY = YY^2
+    var yyyy = yy.redSqr();
+    // S = 2 * ((X1 + YY)^2 - XX - YYYY)
+    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
+    s = s.redIAdd(s);
+    // M = 3 * XX + a; a = 0
+    var m = xx.redAdd(xx).redIAdd(xx);
+    // T = M ^ 2 - 2*S
+    var t = m.redSqr().redISub(s).redISub(s);
+
+    // 8 * YYYY
+    var yyyy8 = yyyy.redIAdd(yyyy);
+    yyyy8 = yyyy8.redIAdd(yyyy8);
+    yyyy8 = yyyy8.redIAdd(yyyy8);
+
+    // X3 = T
+    nx = t;
+    // Y3 = M * (S - T) - 8 * YYYY
+    ny = m.redMul(s.redISub(t)).redISub(yyyy8);
+    // Z3 = 2*Y1
+    nz = this.y.redAdd(this.y);
+  } else {
+    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
+    //     #doubling-dbl-2009-l
+    // 2M + 5S + 13A
+
+    // A = X1^2
+    var a = this.x.redSqr();
+    // B = Y1^2
+    var b = this.y.redSqr();
+    // C = B^2
+    var c = b.redSqr();
+    // D = 2 * ((X1 + B)^2 - A - C)
+    var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
+    d = d.redIAdd(d);
+    // E = 3 * A
+    var e = a.redAdd(a).redIAdd(a);
+    // F = E^2
+    var f = e.redSqr();
+
+    // 8 * C
+    var c8 = c.redIAdd(c);
+    c8 = c8.redIAdd(c8);
+    c8 = c8.redIAdd(c8);
+
+    // X3 = F - 2 * D
+    nx = f.redISub(d).redISub(d);
+    // Y3 = E * (D - X3) - 8 * C
+    ny = e.redMul(d.redISub(nx)).redISub(c8);
+    // Z3 = 2 * Y1 * Z1
+    nz = this.y.redMul(this.z);
+    nz = nz.redIAdd(nz);
+  }
+
+  return this.curve.jpoint(nx, ny, nz);
+};
+
+JPoint.prototype._threeDbl = function _threeDbl() {
+  var nx;
+  var ny;
+  var nz;
+  // Z = 1
+  if (this.zOne) {
+    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html
+    //     #doubling-mdbl-2007-bl
+    // 1M + 5S + 15A
+
+    // XX = X1^2
+    var xx = this.x.redSqr();
+    // YY = Y1^2
+    var yy = this.y.redSqr();
+    // YYYY = YY^2
+    var yyyy = yy.redSqr();
+    // S = 2 * ((X1 + YY)^2 - XX - YYYY)
+    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
+    s = s.redIAdd(s);
+    // M = 3 * XX + a
+    var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
+    // T = M^2 - 2 * S
+    var t = m.redSqr().redISub(s).redISub(s);
+    // X3 = T
+    nx = t;
+    // Y3 = M * (S - T) - 8 * YYYY
+    var yyyy8 = yyyy.redIAdd(yyyy);
+    yyyy8 = yyyy8.redIAdd(yyyy8);
+    yyyy8 = yyyy8.redIAdd(yyyy8);
+    ny = m.redMul(s.redISub(t)).redISub(yyyy8);
+    // Z3 = 2 * Y1
+    nz = this.y.redAdd(this.y);
+  } else {
+    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b
+    // 3M + 5S
+
+    // delta = Z1^2
+    var delta = this.z.redSqr();
+    // gamma = Y1^2
+    var gamma = this.y.redSqr();
+    // beta = X1 * gamma
+    var beta = this.x.redMul(gamma);
+    // alpha = 3 * (X1 - delta) * (X1 + delta)
+    var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
+    alpha = alpha.redAdd(alpha).redIAdd(alpha);
+    // X3 = alpha^2 - 8 * beta
+    var beta4 = beta.redIAdd(beta);
+    beta4 = beta4.redIAdd(beta4);
+    var beta8 = beta4.redAdd(beta4);
+    nx = alpha.redSqr().redISub(beta8);
+    // Z3 = (Y1 + Z1)^2 - gamma - delta
+    nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
+    // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2
+    var ggamma8 = gamma.redSqr();
+    ggamma8 = ggamma8.redIAdd(ggamma8);
+    ggamma8 = ggamma8.redIAdd(ggamma8);
+    ggamma8 = ggamma8.redIAdd(ggamma8);
+    ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
+  }
+
+  return this.curve.jpoint(nx, ny, nz);
+};
+
+JPoint.prototype._dbl = function _dbl() {
+  var a = this.curve.a;
+
+  // 4M + 6S + 10A
+  var jx = this.x;
+  var jy = this.y;
+  var jz = this.z;
+  var jz4 = jz.redSqr().redSqr();
+
+  var jx2 = jx.redSqr();
+  var jy2 = jy.redSqr();
+
+  var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
+
+  var jxd4 = jx.redAdd(jx);
+  jxd4 = jxd4.redIAdd(jxd4);
+  var t1 = jxd4.redMul(jy2);
+  var nx = c.redSqr().redISub(t1.redAdd(t1));
+  var t2 = t1.redISub(nx);
+
+  var jyd8 = jy2.redSqr();
+  jyd8 = jyd8.redIAdd(jyd8);
+  jyd8 = jyd8.redIAdd(jyd8);
+  jyd8 = jyd8.redIAdd(jyd8);
+  var ny = c.redMul(t2).redISub(jyd8);
+  var nz = jy.redAdd(jy).redMul(jz);
+
+  return this.curve.jpoint(nx, ny, nz);
+};
+
+JPoint.prototype.trpl = function trpl() {
+  if (!this.curve.zeroA)
+    return this.dbl().add(this);
+
+  // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl
+  // 5M + 10S + ...
+
+  // XX = X1^2
+  var xx = this.x.redSqr();
+  // YY = Y1^2
+  var yy = this.y.redSqr();
+  // ZZ = Z1^2
+  var zz = this.z.redSqr();
+  // YYYY = YY^2
+  var yyyy = yy.redSqr();
+  // M = 3 * XX + a * ZZ2; a = 0
+  var m = xx.redAdd(xx).redIAdd(xx);
+  // MM = M^2
+  var mm = m.redSqr();
+  // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM
+  var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
+  e = e.redIAdd(e);
+  e = e.redAdd(e).redIAdd(e);
+  e = e.redISub(mm);
+  // EE = E^2
+  var ee = e.redSqr();
+  // T = 16*YYYY
+  var t = yyyy.redIAdd(yyyy);
+  t = t.redIAdd(t);
+  t = t.redIAdd(t);
+  t = t.redIAdd(t);
+  // U = (M + E)^2 - MM - EE - T
+  var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
+  // X3 = 4 * (X1 * EE - 4 * YY * U)
+  var yyu4 = yy.redMul(u);
+  yyu4 = yyu4.redIAdd(yyu4);
+  yyu4 = yyu4.redIAdd(yyu4);
+  var nx = this.x.redMul(ee).redISub(yyu4);
+  nx = nx.redIAdd(nx);
+  nx = nx.redIAdd(nx);
+  // Y3 = 8 * Y1 * (U * (T - U) - E * EE)
+  var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
+  ny = ny.redIAdd(ny);
+  ny = ny.redIAdd(ny);
+  ny = ny.redIAdd(ny);
+  // Z3 = (Z1 + E)^2 - ZZ - EE
+  var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
+
+  return this.curve.jpoint(nx, ny, nz);
+};
+
+JPoint.prototype.mul = function mul(k, kbase) {
+  k = new BN(k, kbase);
+
+  return this.curve._wnafMul(this, k);
+};
+
+JPoint.prototype.eq = function eq(p) {
+  if (p.type === 'affine')
+    return this.eq(p.toJ());
+
+  if (this === p)
+    return true;
+
+  // x1 * z2^2 == x2 * z1^2
+  var z2 = this.z.redSqr();
+  var pz2 = p.z.redSqr();
+  if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)
+    return false;
+
+  // y1 * z2^3 == y2 * z1^3
+  var z3 = z2.redMul(this.z);
+  var pz3 = pz2.redMul(p.z);
+  return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
+};
+
+JPoint.prototype.eqXToP = function eqXToP(x) {
+  var zs = this.z.redSqr();
+  var rx = x.toRed(this.curve.red).redMul(zs);
+  if (this.x.cmp(rx) === 0)
+    return true;
+
+  var xc = x.clone();
+  var t = this.curve.redN.redMul(zs);
+  for (;;) {
+    xc.iadd(this.curve.n);
+    if (xc.cmp(this.curve.p) >= 0)
+      return false;
+
+    rx.redIAdd(t);
+    if (this.x.cmp(rx) === 0)
+      return true;
+  }
+  return false;
+};
+
+JPoint.prototype.inspect = function inspect() {
+  if (this.isInfinity())
+    return '<EC JPoint Infinity>';
+  return '<EC JPoint x: ' + this.x.toString(16, 2) +
+      ' y: ' + this.y.toString(16, 2) +
+      ' z: ' + this.z.toString(16, 2) + '>';
+};
+
+JPoint.prototype.isInfinity = function isInfinity() {
+  // XXX This code assumes that zero is always zero in red
+  return this.z.cmpn(0) === 0;
+};
+
+},{"../../elliptic":74,"../curve":77,"bn.js":24,"inherits":107}],80:[function(require,module,exports){
+'use strict';
+
+var curves = exports;
+
+var hash = require('hash.js');
+var elliptic = require('../elliptic');
+
+var assert = elliptic.utils.assert;
+
+function PresetCurve(options) {
+  if (options.type === 'short')
+    this.curve = new elliptic.curve.short(options);
+  else if (options.type === 'edwards')
+    this.curve = new elliptic.curve.edwards(options);
+  else
+    this.curve = new elliptic.curve.mont(options);
+  this.g = this.curve.g;
+  this.n = this.curve.n;
+  this.hash = options.hash;
+
+  assert(this.g.validate(), 'Invalid curve');
+  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');
+}
+curves.PresetCurve = PresetCurve;
+
+function defineCurve(name, options) {
+  Object.defineProperty(curves, name, {
+    configurable: true,
+    enumerable: true,
+    get: function() {
+      var curve = new PresetCurve(options);
+      Object.defineProperty(curves, name, {
+        configurable: true,
+        enumerable: true,
+        value: curve
+      });
+      return curve;
+    }
+  });
+}
+
+defineCurve('p192', {
+  type: 'short',
+  prime: 'p192',
+  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',
+  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',
+  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',
+  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',
+  hash: hash.sha256,
+  gRed: false,
+  g: [
+    '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',
+    '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811'
+  ]
+});
+
+defineCurve('p224', {
+  type: 'short',
+  prime: 'p224',
+  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',
+  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',
+  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',
+  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',
+  hash: hash.sha256,
+  gRed: false,
+  g: [
+    'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',
+    'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34'
+  ]
+});
+
+defineCurve('p256', {
+  type: 'short',
+  prime: null,
+  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',
+  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',
+  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',
+  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',
+  hash: hash.sha256,
+  gRed: false,
+  g: [
+    '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',
+    '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5'
+  ]
+});
+
+defineCurve('p384', {
+  type: 'short',
+  prime: null,
+  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+     'fffffffe ffffffff 00000000 00000000 ffffffff',
+  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+     'fffffffe ffffffff 00000000 00000000 fffffffc',
+  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +
+     '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',
+  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +
+     'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',
+  hash: hash.sha384,
+  gRed: false,
+  g: [
+    'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +
+    '5502f25d bf55296c 3a545e38 72760ab7',
+    '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +
+    '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f'
+  ]
+});
+
+defineCurve('p521', {
+  type: 'short',
+  prime: null,
+  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+     'ffffffff ffffffff ffffffff ffffffff ffffffff',
+  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+     'ffffffff ffffffff ffffffff ffffffff fffffffc',
+  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +
+     '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +
+     '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',
+  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+     'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +
+     'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',
+  hash: hash.sha512,
+  gRed: false,
+  g: [
+    '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +
+    '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +
+    'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',
+    '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +
+    '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +
+    '3fad0761 353c7086 a272c240 88be9476 9fd16650'
+  ]
+});
+
+defineCurve('curve25519', {
+  type: 'mont',
+  prime: 'p25519',
+  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
+  a: '76d06',
+  b: '1',
+  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
+  hash: hash.sha256,
+  gRed: false,
+  g: [
+    '9'
+  ]
+});
+
+defineCurve('ed25519', {
+  type: 'edwards',
+  prime: 'p25519',
+  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
+  a: '-1',
+  c: '1',
+  // -121665 * (121666^(-1)) (mod P)
+  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',
+  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
+  hash: hash.sha256,
+  gRed: false,
+  g: [
+    '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',
+
+    // 4/5
+    '6666666666666666666666666666666666666666666666666666666666666658'
+  ]
+});
+
+var pre;
+try {
+  pre = require('./precomputed/secp256k1');
+} catch (e) {
+  pre = undefined;
+}
+
+defineCurve('secp256k1', {
+  type: 'short',
+  prime: 'k256',
+  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',
+  a: '0',
+  b: '7',
+  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',
+  h: '1',
+  hash: hash.sha256,
+
+  // Precomputed endomorphism
+  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',
+  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
+  basis: [
+    {
+      a: '3086d221a7d46bcde86c90e49284eb15',
+      b: '-e4437ed6010e88286f547fa90abfe4c3'
+    },
+    {
+      a: '114ca50f7a8e2f3f657c1108d9d44cfd8',
+      b: '3086d221a7d46bcde86c90e49284eb15'
+    }
+  ],
+
+  gRed: false,
+  g: [
+    '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+    '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+    pre
+  ]
+});
+
+},{"../elliptic":74,"./precomputed/secp256k1":87,"hash.js":93}],81:[function(require,module,exports){
+'use strict';
+
+var BN = require('bn.js');
+var HmacDRBG = require('hmac-drbg');
+var elliptic = require('../../elliptic');
+var utils = elliptic.utils;
+var assert = utils.assert;
+
+var KeyPair = require('./key');
+var Signature = require('./signature');
+
+function EC(options) {
+  if (!(this instanceof EC))
+    return new EC(options);
+
+  // Shortcut `elliptic.ec(curve-name)`
+  if (typeof options === 'string') {
+    assert(elliptic.curves.hasOwnProperty(options), 'Unknown curve ' + options);
+
+    options = elliptic.curves[options];
+  }
+
+  // Shortcut for `elliptic.ec(elliptic.curves.curveName)`
+  if (options instanceof elliptic.curves.PresetCurve)
+    options = { curve: options };
+
+  this.curve = options.curve.curve;
+  this.n = this.curve.n;
+  this.nh = this.n.ushrn(1);
+  this.g = this.curve.g;
+
+  // Point on curve
+  this.g = options.curve.g;
+  this.g.precompute(options.curve.n.bitLength() + 1);
+
+  // Hash for function for DRBG
+  this.hash = options.hash || options.curve.hash;
+}
+module.exports = EC;
+
+EC.prototype.keyPair = function keyPair(options) {
+  return new KeyPair(this, options);
+};
+
+EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
+  return KeyPair.fromPrivate(this, priv, enc);
+};
+
+EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
+  return KeyPair.fromPublic(this, pub, enc);
+};
+
+EC.prototype.genKeyPair = function genKeyPair(options) {
+  if (!options)
+    options = {};
+
+  // Instantiate Hmac_DRBG
+  var drbg = new HmacDRBG({
+    hash: this.hash,
+    pers: options.pers,
+    persEnc: options.persEnc || 'utf8',
+    entropy: options.entropy || elliptic.rand(this.hash.hmacStrength),
+    entropyEnc: options.entropy && options.entropyEnc || 'utf8',
+    nonce: this.n.toArray()
+  });
+
+  var bytes = this.n.byteLength();
+  var ns2 = this.n.sub(new BN(2));
+  do {
+    var priv = new BN(drbg.generate(bytes));
+    if (priv.cmp(ns2) > 0)
+      continue;
+
+    priv.iaddn(1);
+    return this.keyFromPrivate(priv);
+  } while (true);
+};
+
+EC.prototype._truncateToN = function truncateToN(msg, truncOnly) {
+  var delta = msg.byteLength() * 8 - this.n.bitLength();
+  if (delta > 0)
+    msg = msg.ushrn(delta);
+  if (!truncOnly && msg.cmp(this.n) >= 0)
+    return msg.sub(this.n);
+  else
+    return msg;
+};
+
+EC.prototype.sign = function sign(msg, key, enc, options) {
+  if (typeof enc === 'object') {
+    options = enc;
+    enc = null;
+  }
+  if (!options)
+    options = {};
+
+  key = this.keyFromPrivate(key, enc);
+  msg = this._truncateToN(new BN(msg, 16));
+
+  // Zero-extend key to provide enough entropy
+  var bytes = this.n.byteLength();
+  var bkey = key.getPrivate().toArray('be', bytes);
+
+  // Zero-extend nonce to have the same byte size as N
+  var nonce = msg.toArray('be', bytes);
+
+  // Instantiate Hmac_DRBG
+  var drbg = new HmacDRBG({
+    hash: this.hash,
+    entropy: bkey,
+    nonce: nonce,
+    pers: options.pers,
+    persEnc: options.persEnc || 'utf8'
+  });
+
+  // Number of bytes to generate
+  var ns1 = this.n.sub(new BN(1));
+
+  for (var iter = 0; true; iter++) {
+    var k = options.k ?
+        options.k(iter) :
+        new BN(drbg.generate(this.n.byteLength()));
+    k = this._truncateToN(k, true);
+    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)
+      continue;
+
+    var kp = this.g.mul(k);
+    if (kp.isInfinity())
+      continue;
+
+    var kpX = kp.getX();
+    var r = kpX.umod(this.n);
+    if (r.cmpn(0) === 0)
+      continue;
+
+    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
+    s = s.umod(this.n);
+    if (s.cmpn(0) === 0)
+      continue;
+
+    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |
+                        (kpX.cmp(r) !== 0 ? 2 : 0);
+
+    // Use complement of `s`, if it is > `n / 2`
+    if (options.canonical && s.cmp(this.nh) > 0) {
+      s = this.n.sub(s);
+      recoveryParam ^= 1;
+    }
+
+    return new Signature({ r: r, s: s, recoveryParam: recoveryParam });
+  }
+};
+
+EC.prototype.verify = function verify(msg, signature, key, enc) {
+  msg = this._truncateToN(new BN(msg, 16));
+  key = this.keyFromPublic(key, enc);
+  signature = new Signature(signature, 'hex');
+
+  // Perform primitive values validation
+  var r = signature.r;
+  var s = signature.s;
+  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)
+    return false;
+  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)
+    return false;
+
+  // Validate signature
+  var sinv = s.invm(this.n);
+  var u1 = sinv.mul(msg).umod(this.n);
+  var u2 = sinv.mul(r).umod(this.n);
+
+  if (!this.curve._maxwellTrick) {
+    var p = this.g.mulAdd(u1, key.getPublic(), u2);
+    if (p.isInfinity())
+      return false;
+
+    return p.getX().umod(this.n).cmp(r) === 0;
+  }
+
+  // NOTE: Greg Maxwell's trick, inspired by:
+  // https://git.io/vad3K
+
+  var p = this.g.jmulAdd(u1, key.getPublic(), u2);
+  if (p.isInfinity())
+    return false;
+
+  // Compare `p.x` of Jacobian point with `r`,
+  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the
+  // inverse of `p.z^2`
+  return p.eqXToP(r);
+};
+
+EC.prototype.recoverPubKey = function(msg, signature, j, enc) {
+  assert((3 & j) === j, 'The recovery param is more than two bits');
+  signature = new Signature(signature, enc);
+
+  var n = this.n;
+  var e = new BN(msg);
+  var r = signature.r;
+  var s = signature.s;
+
+  // A set LSB signifies that the y-coordinate is odd
+  var isYOdd = j & 1;
+  var isSecondKey = j >> 1;
+  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)
+    throw new Error('Unable to find sencond key candinate');
+
+  // 1.1. Let x = r + jn.
+  if (isSecondKey)
+    r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);
+  else
+    r = this.curve.pointFromX(r, isYOdd);
+
+  var rInv = signature.r.invm(n);
+  var s1 = n.sub(e).mul(rInv).umod(n);
+  var s2 = s.mul(rInv).umod(n);
+
+  // 1.6.1 Compute Q = r^-1 (sR -  eG)
+  //               Q = r^-1 (sR + -eG)
+  return this.g.mulAdd(s1, r, s2);
+};
+
+EC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {
+  signature = new Signature(signature, enc);
+  if (signature.recoveryParam !== null)
+    return signature.recoveryParam;
+
+  for (var i = 0; i < 4; i++) {
+    var Qprime;
+    try {
+      Qprime = this.recoverPubKey(e, signature, i);
+    } catch (e) {
+      continue;
+    }
+
+    if (Qprime.eq(Q))
+      return i;
+  }
+  throw new Error('Unable to find valid recovery factor');
+};
+
+},{"../../elliptic":74,"./key":82,"./signature":83,"bn.js":24,"hmac-drbg":105}],82:[function(require,module,exports){
+'use strict';
+
+var BN = require('bn.js');
+var elliptic = require('../../elliptic');
+var utils = elliptic.utils;
+var assert = utils.assert;
+
+function KeyPair(ec, options) {
+  this.ec = ec;
+  this.priv = null;
+  this.pub = null;
+
+  // KeyPair(ec, { priv: ..., pub: ... })
+  if (options.priv)
+    this._importPrivate(options.priv, options.privEnc);
+  if (options.pub)
+    this._importPublic(options.pub, options.pubEnc);
+}
+module.exports = KeyPair;
+
+KeyPair.fromPublic = function fromPublic(ec, pub, enc) {
+  if (pub instanceof KeyPair)
+    return pub;
+
+  return new KeyPair(ec, {
+    pub: pub,
+    pubEnc: enc
+  });
+};
+
+KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {
+  if (priv instanceof KeyPair)
+    return priv;
+
+  return new KeyPair(ec, {
+    priv: priv,
+    privEnc: enc
+  });
+};
+
+KeyPair.prototype.validate = function validate() {
+  var pub = this.getPublic();
+
+  if (pub.isInfinity())
+    return { result: false, reason: 'Invalid public key' };
+  if (!pub.validate())
+    return { result: false, reason: 'Public key is not a point' };
+  if (!pub.mul(this.ec.curve.n).isInfinity())
+    return { result: false, reason: 'Public key * N != O' };
+
+  return { result: true, reason: null };
+};
+
+KeyPair.prototype.getPublic = function getPublic(compact, enc) {
+  // compact is optional argument
+  if (typeof compact === 'string') {
+    enc = compact;
+    compact = null;
+  }
+
+  if (!this.pub)
+    this.pub = this.ec.g.mul(this.priv);
+
+  if (!enc)
+    return this.pub;
+
+  return this.pub.encode(enc, compact);
+};
+
+KeyPair.prototype.getPrivate = function getPrivate(enc) {
+  if (enc === 'hex')
+    return this.priv.toString(16, 2);
+  else
+    return this.priv;
+};
+
+KeyPair.prototype._importPrivate = function _importPrivate(key, enc) {
+  this.priv = new BN(key, enc || 16);
+
+  // Ensure that the priv won't be bigger than n, otherwise we may fail
+  // in fixed multiplication method
+  this.priv = this.priv.umod(this.ec.curve.n);
+};
+
+KeyPair.prototype._importPublic = function _importPublic(key, enc) {
+  if (key.x || key.y) {
+    // Montgomery points only have an `x` coordinate.
+    // Weierstrass/Edwards points on the other hand have both `x` and
+    // `y` coordinates.
+    if (this.ec.curve.type === 'mont') {
+      assert(key.x, 'Need x coordinate');
+    } else if (this.ec.curve.type === 'short' ||
+               this.ec.curve.type === 'edwards') {
+      assert(key.x && key.y, 'Need both x and y coordinate');
+    }
+    this.pub = this.ec.curve.point(key.x, key.y);
+    return;
+  }
+  this.pub = this.ec.curve.decodePoint(key, enc);
+};
+
+// ECDH
+KeyPair.prototype.derive = function derive(pub) {
+  return pub.mul(this.priv).getX();
+};
+
+// ECDSA
+KeyPair.prototype.sign = function sign(msg, enc, options) {
+  return this.ec.sign(msg, this, enc, options);
+};
+
+KeyPair.prototype.verify = function verify(msg, signature) {
+  return this.ec.verify(msg, signature, this);
+};
+
+KeyPair.prototype.inspect = function inspect() {
+  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +
+         ' pub: ' + (this.pub && this.pub.inspect()) + ' >';
+};
+
+},{"../../elliptic":74,"bn.js":24}],83:[function(require,module,exports){
+'use strict';
+
+var BN = require('bn.js');
+
+var elliptic = require('../../elliptic');
+var utils = elliptic.utils;
+var assert = utils.assert;
+
+function Signature(options, enc) {
+  if (options instanceof Signature)
+    return options;
+
+  if (this._importDER(options, enc))
+    return;
+
+  assert(options.r && options.s, 'Signature without r or s');
+  this.r = new BN(options.r, 16);
+  this.s = new BN(options.s, 16);
+  if (options.recoveryParam === undefined)
+    this.recoveryParam = null;
+  else
+    this.recoveryParam = options.recoveryParam;
+}
+module.exports = Signature;
+
+function Position() {
+  this.place = 0;
+}
+
+function getLength(buf, p) {
+  var initial = buf[p.place++];
+  if (!(initial & 0x80)) {
+    return initial;
+  }
+  var octetLen = initial & 0xf;
+  var val = 0;
+  for (var i = 0, off = p.place; i < octetLen; i++, off++) {
+    val <<= 8;
+    val |= buf[off];
+  }
+  p.place = off;
+  return val;
+}
+
+function rmPadding(buf) {
+  var i = 0;
+  var len = buf.length - 1;
+  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {
+    i++;
+  }
+  if (i === 0) {
+    return buf;
+  }
+  return buf.slice(i);
+}
+
+Signature.prototype._importDER = function _importDER(data, enc) {
+  data = utils.toArray(data, enc);
+  var p = new Position();
+  if (data[p.place++] !== 0x30) {
+    return false;
+  }
+  var len = getLength(data, p);
+  if ((len + p.place) !== data.length) {
+    return false;
+  }
+  if (data[p.place++] !== 0x02) {
+    return false;
+  }
+  var rlen = getLength(data, p);
+  var r = data.slice(p.place, rlen + p.place);
+  p.place += rlen;
+  if (data[p.place++] !== 0x02) {
+    return false;
+  }
+  var slen = getLength(data, p);
+  if (data.length !== slen + p.place) {
+    return false;
+  }
+  var s = data.slice(p.place, slen + p.place);
+  if (r[0] === 0 && (r[1] & 0x80)) {
+    r = r.slice(1);
+  }
+  if (s[0] === 0 && (s[1] & 0x80)) {
+    s = s.slice(1);
+  }
+
+  this.r = new BN(r);
+  this.s = new BN(s);
+  this.recoveryParam = null;
+
+  return true;
+};
+
+function constructLength(arr, len) {
+  if (len < 0x80) {
+    arr.push(len);
+    return;
+  }
+  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
+  arr.push(octets | 0x80);
+  while (--octets) {
+    arr.push((len >>> (octets << 3)) & 0xff);
+  }
+  arr.push(len);
+}
+
+Signature.prototype.toDER = function toDER(enc) {
+  var r = this.r.toArray();
+  var s = this.s.toArray();
+
+  // Pad values
+  if (r[0] & 0x80)
+    r = [ 0 ].concat(r);
+  // Pad values
+  if (s[0] & 0x80)
+    s = [ 0 ].concat(s);
+
+  r = rmPadding(r);
+  s = rmPadding(s);
+
+  while (!s[0] && !(s[1] & 0x80)) {
+    s = s.slice(1);
+  }
+  var arr = [ 0x02 ];
+  constructLength(arr, r.length);
+  arr = arr.concat(r);
+  arr.push(0x02);
+  constructLength(arr, s.length);
+  var backHalf = arr.concat(s);
+  var res = [ 0x30 ];
+  constructLength(res, backHalf.length);
+  res = res.concat(backHalf);
+  return utils.encode(res, enc);
+};
+
+},{"../../elliptic":74,"bn.js":24}],84:[function(require,module,exports){
+'use strict';
+
+var hash = require('hash.js');
+var elliptic = require('../../elliptic');
+var utils = elliptic.utils;
+var assert = utils.assert;
+var parseBytes = utils.parseBytes;
+var KeyPair = require('./key');
+var Signature = require('./signature');
+
+function EDDSA(curve) {
+  assert(curve === 'ed25519', 'only tested with ed25519 so far');
+
+  if (!(this instanceof EDDSA))
+    return new EDDSA(curve);
+
+  var curve = elliptic.curves[curve].curve;
+  this.curve = curve;
+  this.g = curve.g;
+  this.g.precompute(curve.n.bitLength() + 1);
+
+  this.pointClass = curve.point().constructor;
+  this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
+  this.hash = hash.sha512;
+}
+
+module.exports = EDDSA;
+
+/**
+* @param {Array|String} message - message bytes
+* @param {Array|String|KeyPair} secret - secret bytes or a keypair
+* @returns {Signature} - signature
+*/
+EDDSA.prototype.sign = function sign(message, secret) {
+  message = parseBytes(message);
+  var key = this.keyFromSecret(secret);
+  var r = this.hashInt(key.messagePrefix(), message);
+  var R = this.g.mul(r);
+  var Rencoded = this.encodePoint(R);
+  var s_ = this.hashInt(Rencoded, key.pubBytes(), message)
+               .mul(key.priv());
+  var S = r.add(s_).umod(this.curve.n);
+  return this.makeSignature({ R: R, S: S, Rencoded: Rencoded });
+};
+
+/**
+* @param {Array} message - message bytes
+* @param {Array|String|Signature} sig - sig bytes
+* @param {Array|String|Point|KeyPair} pub - public key
+* @returns {Boolean} - true if public key matches sig of message
+*/
+EDDSA.prototype.verify = function verify(message, sig, pub) {
+  message = parseBytes(message);
+  sig = this.makeSignature(sig);
+  var key = this.keyFromPublic(pub);
+  var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);
+  var SG = this.g.mul(sig.S());
+  var RplusAh = sig.R().add(key.pub().mul(h));
+  return RplusAh.eq(SG);
+};
+
+EDDSA.prototype.hashInt = function hashInt() {
+  var hash = this.hash();
+  for (var i = 0; i < arguments.length; i++)
+    hash.update(arguments[i]);
+  return utils.intFromLE(hash.digest()).umod(this.curve.n);
+};
+
+EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
+  return KeyPair.fromPublic(this, pub);
+};
+
+EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
+  return KeyPair.fromSecret(this, secret);
+};
+
+EDDSA.prototype.makeSignature = function makeSignature(sig) {
+  if (sig instanceof Signature)
+    return sig;
+  return new Signature(this, sig);
+};
+
+/**
+* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2
+*
+* EDDSA defines methods for encoding and decoding points and integers. These are
+* helper convenience methods, that pass along to utility functions implied
+* parameters.
+*
+*/
+EDDSA.prototype.encodePoint = function encodePoint(point) {
+  var enc = point.getY().toArray('le', this.encodingLength);
+  enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;
+  return enc;
+};
+
+EDDSA.prototype.decodePoint = function decodePoint(bytes) {
+  bytes = utils.parseBytes(bytes);
+
+  var lastIx = bytes.length - 1;
+  var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);
+  var xIsOdd = (bytes[lastIx] & 0x80) !== 0;
+
+  var y = utils.intFromLE(normed);
+  return this.curve.pointFromY(y, xIsOdd);
+};
+
+EDDSA.prototype.encodeInt = function encodeInt(num) {
+  return num.toArray('le', this.encodingLength);
+};
+
+EDDSA.prototype.decodeInt = function decodeInt(bytes) {
+  return utils.intFromLE(bytes);
+};
+
+EDDSA.prototype.isPoint = function isPoint(val) {
+  return val instanceof this.pointClass;
+};
+
+},{"../../elliptic":74,"./key":85,"./signature":86,"hash.js":93}],85:[function(require,module,exports){
+'use strict';
+
+var elliptic = require('../../elliptic');
+var utils = elliptic.utils;
+var assert = utils.assert;
+var parseBytes = utils.parseBytes;
+var cachedProperty = utils.cachedProperty;
+
+/**
+* @param {EDDSA} eddsa - instance
+* @param {Object} params - public/private key parameters
+*
+* @param {Array<Byte>} [params.secret] - secret seed bytes
+* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)
+* @param {Array<Byte>} [params.pub] - public key point encoded as bytes
+*
+*/
+function KeyPair(eddsa, params) {
+  this.eddsa = eddsa;
+  this._secret = parseBytes(params.secret);
+  if (eddsa.isPoint(params.pub))
+    this._pub = params.pub;
+  else
+    this._pubBytes = parseBytes(params.pub);
+}
+
+KeyPair.fromPublic = function fromPublic(eddsa, pub) {
+  if (pub instanceof KeyPair)
+    return pub;
+  return new KeyPair(eddsa, { pub: pub });
+};
+
+KeyPair.fromSecret = function fromSecret(eddsa, secret) {
+  if (secret instanceof KeyPair)
+    return secret;
+  return new KeyPair(eddsa, { secret: secret });
+};
+
+KeyPair.prototype.secret = function secret() {
+  return this._secret;
+};
+
+cachedProperty(KeyPair, 'pubBytes', function pubBytes() {
+  return this.eddsa.encodePoint(this.pub());
+});
+
+cachedProperty(KeyPair, 'pub', function pub() {
+  if (this._pubBytes)
+    return this.eddsa.decodePoint(this._pubBytes);
+  return this.eddsa.g.mul(this.priv());
+});
+
+cachedProperty(KeyPair, 'privBytes', function privBytes() {
+  var eddsa = this.eddsa;
+  var hash = this.hash();
+  var lastIx = eddsa.encodingLength - 1;
+
+  var a = hash.slice(0, eddsa.encodingLength);
+  a[0] &= 248;
+  a[lastIx] &= 127;
+  a[lastIx] |= 64;
+
+  return a;
+});
+
+cachedProperty(KeyPair, 'priv', function priv() {
+  return this.eddsa.decodeInt(this.privBytes());
+});
+
+cachedProperty(KeyPair, 'hash', function hash() {
+  return this.eddsa.hash().update(this.secret()).digest();
+});
+
+cachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {
+  return this.hash().slice(this.eddsa.encodingLength);
+});
+
+KeyPair.prototype.sign = function sign(message) {
+  assert(this._secret, 'KeyPair can only verify');
+  return this.eddsa.sign(message, this);
+};
+
+KeyPair.prototype.verify = function verify(message, sig) {
+  return this.eddsa.verify(message, sig, this);
+};
+
+KeyPair.prototype.getSecret = function getSecret(enc) {
+  assert(this._secret, 'KeyPair is public only');
+  return utils.encode(this.secret(), enc);
+};
+
+KeyPair.prototype.getPublic = function getPublic(enc) {
+  return utils.encode(this.pubBytes(), enc);
+};
+
+module.exports = KeyPair;
+
+},{"../../elliptic":74}],86:[function(require,module,exports){
+'use strict';
+
+var BN = require('bn.js');
+var elliptic = require('../../elliptic');
+var utils = elliptic.utils;
+var assert = utils.assert;
+var cachedProperty = utils.cachedProperty;
+var parseBytes = utils.parseBytes;
+
+/**
+* @param {EDDSA} eddsa - eddsa instance
+* @param {Array<Bytes>|Object} sig -
+* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes
+* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes
+* @param {Array<Bytes>} [sig.Rencoded] - R point encoded
+* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded
+*/
+function Signature(eddsa, sig) {
+  this.eddsa = eddsa;
+
+  if (typeof sig !== 'object')
+    sig = parseBytes(sig);
+
+  if (Array.isArray(sig)) {
+    sig = {
+      R: sig.slice(0, eddsa.encodingLength),
+      S: sig.slice(eddsa.encodingLength)
+    };
+  }
+
+  assert(sig.R && sig.S, 'Signature without R or S');
+
+  if (eddsa.isPoint(sig.R))
+    this._R = sig.R;
+  if (sig.S instanceof BN)
+    this._S = sig.S;
+
+  this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
+  this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
+}
+
+cachedProperty(Signature, 'S', function S() {
+  return this.eddsa.decodeInt(this.Sencoded());
+});
+
+cachedProperty(Signature, 'R', function R() {
+  return this.eddsa.decodePoint(this.Rencoded());
+});
+
+cachedProperty(Signature, 'Rencoded', function Rencoded() {
+  return this.eddsa.encodePoint(this.R());
+});
+
+cachedProperty(Signature, 'Sencoded', function Sencoded() {
+  return this.eddsa.encodeInt(this.S());
+});
+
+Signature.prototype.toBytes = function toBytes() {
+  return this.Rencoded().concat(this.Sencoded());
+};
+
+Signature.prototype.toHex = function toHex() {
+  return utils.encode(this.toBytes(), 'hex').toUpperCase();
+};
+
+module.exports = Signature;
+
+},{"../../elliptic":74,"bn.js":24}],87:[function(require,module,exports){
+module.exports = {
+  doubles: {
+    step: 4,
+    points: [
+      [
+        'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a',
+        'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821'
+      ],
+      [
+        '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508',
+        '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf'
+      ],
+      [
+        '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739',
+        'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695'
+      ],
+      [
+        '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640',
+        '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9'
+      ],
+      [
+        '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c',
+        '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36'
+      ],
+      [
+        '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda',
+        '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f'
+      ],
+      [
+        'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa',
+        '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999'
+      ],
+      [
+        '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0',
+        'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09'
+      ],
+      [
+        'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d',
+        '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d'
+      ],
+      [
+        'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d',
+        'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088'
+      ],
+      [
+        'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1',
+        '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d'
+      ],
+      [
+        '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0',
+        '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8'
+      ],
+      [
+        '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047',
+        '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a'
+      ],
+      [
+        '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862',
+        '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453'
+      ],
+      [
+        '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7',
+        '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160'
+      ],
+      [
+        '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd',
+        '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0'
+      ],
+      [
+        '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83',
+        '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6'
+      ],
+      [
+        '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a',
+        '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589'
+      ],
+      [
+        '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8',
+        'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17'
+      ],
+      [
+        'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d',
+        '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda'
+      ],
+      [
+        'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725',
+        '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd'
+      ],
+      [
+        '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754',
+        '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2'
+      ],
+      [
+        '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c',
+        '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6'
+      ],
+      [
+        'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6',
+        '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f'
+      ],
+      [
+        '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39',
+        'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01'
+      ],
+      [
+        'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891',
+        '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3'
+      ],
+      [
+        'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b',
+        'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f'
+      ],
+      [
+        'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03',
+        '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7'
+      ],
+      [
+        'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d',
+        'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78'
+      ],
+      [
+        'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070',
+        '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1'
+      ],
+      [
+        '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4',
+        'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150'
+      ],
+      [
+        '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da',
+        '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82'
+      ],
+      [
+        'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11',
+        '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc'
+      ],
+      [
+        '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e',
+        'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b'
+      ],
+      [
+        'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41',
+        '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51'
+      ],
+      [
+        'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef',
+        '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45'
+      ],
+      [
+        'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8',
+        'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120'
+      ],
+      [
+        '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d',
+        '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84'
+      ],
+      [
+        '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96',
+        '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d'
+      ],
+      [
+        '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd',
+        'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d'
+      ],
+      [
+        '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5',
+        '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8'
+      ],
+      [
+        'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266',
+        '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8'
+      ],
+      [
+        '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71',
+        '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac'
+      ],
+      [
+        '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac',
+        'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f'
+      ],
+      [
+        '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751',
+        '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962'
+      ],
+      [
+        'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e',
+        '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907'
+      ],
+      [
+        '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241',
+        'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec'
+      ],
+      [
+        'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3',
+        'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d'
+      ],
+      [
+        'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f',
+        '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414'
+      ],
+      [
+        '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19',
+        'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd'
+      ],
+      [
+        '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be',
+        'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0'
+      ],
+      [
+        'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9',
+        '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811'
+      ],
+      [
+        'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2',
+        '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1'
+      ],
+      [
+        'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13',
+        '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c'
+      ],
+      [
+        '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c',
+        'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73'
+      ],
+      [
+        '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba',
+        '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd'
+      ],
+      [
+        'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151',
+        'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405'
+      ],
+      [
+        '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073',
+        'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589'
+      ],
+      [
+        '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458',
+        '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e'
+      ],
+      [
+        '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b',
+        '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27'
+      ],
+      [
+        'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366',
+        'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1'
+      ],
+      [
+        '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa',
+        '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482'
+      ],
+      [
+        '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0',
+        '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945'
+      ],
+      [
+        'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787',
+        '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573'
+      ],
+      [
+        'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e',
+        'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82'
+      ]
+    ]
+  },
+  naf: {
+    wnd: 7,
+    points: [
+      [
+        'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',
+        '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672'
+      ],
+      [
+        '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4',
+        'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6'
+      ],
+      [
+        '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc',
+        '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da'
+      ],
+      [
+        'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe',
+        'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37'
+      ],
+      [
+        '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb',
+        'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b'
+      ],
+      [
+        'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8',
+        'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81'
+      ],
+      [
+        'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e',
+        '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58'
+      ],
+      [
+        'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34',
+        '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77'
+      ],
+      [
+        '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c',
+        '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a'
+      ],
+      [
+        '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5',
+        '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c'
+      ],
+      [
+        '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f',
+        '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67'
+      ],
+      [
+        '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714',
+        '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402'
+      ],
+      [
+        'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729',
+        'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55'
+      ],
+      [
+        'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db',
+        '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482'
+      ],
+      [
+        '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4',
+        'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82'
+      ],
+      [
+        '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5',
+        'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396'
+      ],
+      [
+        '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479',
+        '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49'
+      ],
+      [
+        '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d',
+        '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf'
+      ],
+      [
+        '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f',
+        '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a'
+      ],
+      [
+        '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb',
+        'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7'
+      ],
+      [
+        'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9',
+        'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933'
+      ],
+      [
+        '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963',
+        '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a'
+      ],
+      [
+        '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74',
+        '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6'
+      ],
+      [
+        'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530',
+        'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37'
+      ],
+      [
+        '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b',
+        '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e'
+      ],
+      [
+        'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247',
+        'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6'
+      ],
+      [
+        'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1',
+        'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476'
+      ],
+      [
+        '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120',
+        '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40'
+      ],
+      [
+        '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435',
+        '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61'
+      ],
+      [
+        '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18',
+        '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683'
+      ],
+      [
+        'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8',
+        '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5'
+      ],
+      [
+        '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb',
+        '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b'
+      ],
+      [
+        'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f',
+        '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417'
+      ],
+      [
+        '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143',
+        'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868'
+      ],
+      [
+        '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba',
+        'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a'
+      ],
+      [
+        'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45',
+        'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6'
+      ],
+      [
+        '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a',
+        '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996'
+      ],
+      [
+        '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e',
+        'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e'
+      ],
+      [
+        'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8',
+        'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d'
+      ],
+      [
+        '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c',
+        '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2'
+      ],
+      [
+        '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519',
+        'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e'
+      ],
+      [
+        '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab',
+        '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437'
+      ],
+      [
+        '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca',
+        'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311'
+      ],
+      [
+        'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf',
+        '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4'
+      ],
+      [
+        '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610',
+        '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575'
+      ],
+      [
+        '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4',
+        'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d'
+      ],
+      [
+        '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c',
+        'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d'
+      ],
+      [
+        'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940',
+        'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629'
+      ],
+      [
+        'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980',
+        'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06'
+      ],
+      [
+        '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3',
+        '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374'
+      ],
+      [
+        '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf',
+        '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee'
+      ],
+      [
+        'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63',
+        '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1'
+      ],
+      [
+        'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448',
+        'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b'
+      ],
+      [
+        '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf',
+        '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661'
+      ],
+      [
+        '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5',
+        '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6'
+      ],
+      [
+        'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6',
+        '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e'
+      ],
+      [
+        '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5',
+        '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d'
+      ],
+      [
+        'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99',
+        'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc'
+      ],
+      [
+        '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51',
+        'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4'
+      ],
+      [
+        '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5',
+        '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c'
+      ],
+      [
+        'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5',
+        '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b'
+      ],
+      [
+        'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997',
+        '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913'
+      ],
+      [
+        '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881',
+        '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154'
+      ],
+      [
+        '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5',
+        '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865'
+      ],
+      [
+        '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66',
+        'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc'
+      ],
+      [
+        '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726',
+        'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224'
+      ],
+      [
+        '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede',
+        '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e'
+      ],
+      [
+        '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94',
+        '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6'
+      ],
+      [
+        '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31',
+        '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511'
+      ],
+      [
+        '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51',
+        'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b'
+      ],
+      [
+        'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252',
+        'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2'
+      ],
+      [
+        '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5',
+        'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c'
+      ],
+      [
+        'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b',
+        '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3'
+      ],
+      [
+        'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4',
+        '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d'
+      ],
+      [
+        'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f',
+        '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700'
+      ],
+      [
+        'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889',
+        '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4'
+      ],
+      [
+        '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246',
+        'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196'
+      ],
+      [
+        '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984',
+        '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4'
+      ],
+      [
+        '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a',
+        'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257'
+      ],
+      [
+        'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030',
+        'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13'
+      ],
+      [
+        'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197',
+        '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096'
+      ],
+      [
+        'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593',
+        'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38'
+      ],
+      [
+        'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef',
+        '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f'
+      ],
+      [
+        '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38',
+        '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448'
+      ],
+      [
+        'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a',
+        '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a'
+      ],
+      [
+        'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111',
+        '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4'
+      ],
+      [
+        '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502',
+        '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437'
+      ],
+      [
+        '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea',
+        'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7'
+      ],
+      [
+        'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26',
+        '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d'
+      ],
+      [
+        'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986',
+        '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a'
+      ],
+      [
+        'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e',
+        '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54'
+      ],
+      [
+        '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4',
+        '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77'
+      ],
+      [
+        'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda',
+        'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517'
+      ],
+      [
+        '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859',
+        'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10'
+      ],
+      [
+        'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f',
+        'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125'
+      ],
+      [
+        'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c',
+        '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e'
+      ],
+      [
+        '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942',
+        'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1'
+      ],
+      [
+        'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a',
+        '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2'
+      ],
+      [
+        'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80',
+        '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423'
+      ],
+      [
+        'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d',
+        '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8'
+      ],
+      [
+        '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1',
+        'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758'
+      ],
+      [
+        '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63',
+        'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375'
+      ],
+      [
+        'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352',
+        '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d'
+      ],
+      [
+        '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193',
+        'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec'
+      ],
+      [
+        '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00',
+        '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0'
+      ],
+      [
+        '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58',
+        'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c'
+      ],
+      [
+        'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7',
+        'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4'
+      ],
+      [
+        '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8',
+        'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f'
+      ],
+      [
+        '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e',
+        '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649'
+      ],
+      [
+        '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d',
+        'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826'
+      ],
+      [
+        '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b',
+        '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5'
+      ],
+      [
+        'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f',
+        'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87'
+      ],
+      [
+        '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6',
+        '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b'
+      ],
+      [
+        'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297',
+        '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc'
+      ],
+      [
+        '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a',
+        '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c'
+      ],
+      [
+        'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c',
+        'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f'
+      ],
+      [
+        'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52',
+        '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a'
+      ],
+      [
+        'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb',
+        'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46'
+      ],
+      [
+        '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065',
+        'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f'
+      ],
+      [
+        '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917',
+        '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03'
+      ],
+      [
+        '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9',
+        'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08'
+      ],
+      [
+        '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3',
+        '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8'
+      ],
+      [
+        '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57',
+        '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373'
+      ],
+      [
+        '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66',
+        'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3'
+      ],
+      [
+        '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8',
+        '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8'
+      ],
+      [
+        '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721',
+        '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1'
+      ],
+      [
+        '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180',
+        '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9'
+      ]
+    ]
+  }
+};
+
+},{}],88:[function(require,module,exports){
+'use strict';
+
+var utils = exports;
+var BN = require('bn.js');
+var minAssert = require('minimalistic-assert');
+var minUtils = require('minimalistic-crypto-utils');
+
+utils.assert = minAssert;
+utils.toArray = minUtils.toArray;
+utils.zero2 = minUtils.zero2;
+utils.toHex = minUtils.toHex;
+utils.encode = minUtils.encode;
+
+// Represent num in a w-NAF form
+function getNAF(num, w) {
+  var naf = [];
+  var ws = 1 << (w + 1);
+  var k = num.clone();
+  while (k.cmpn(1) >= 0) {
+    var z;
+    if (k.isOdd()) {
+      var mod = k.andln(ws - 1);
+      if (mod > (ws >> 1) - 1)
+        z = (ws >> 1) - mod;
+      else
+        z = mod;
+      k.isubn(z);
+    } else {
+      z = 0;
+    }
+    naf.push(z);
+
+    // Optimization, shift by word if possible
+    var shift = (k.cmpn(0) !== 0 && k.andln(ws - 1) === 0) ? (w + 1) : 1;
+    for (var i = 1; i < shift; i++)
+      naf.push(0);
+    k.iushrn(shift);
+  }
+
+  return naf;
+}
+utils.getNAF = getNAF;
+
+// Represent k1, k2 in a Joint Sparse Form
+function getJSF(k1, k2) {
+  var jsf = [
+    [],
+    []
+  ];
+
+  k1 = k1.clone();
+  k2 = k2.clone();
+  var d1 = 0;
+  var d2 = 0;
+  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
+
+    // First phase
+    var m14 = (k1.andln(3) + d1) & 3;
+    var m24 = (k2.andln(3) + d2) & 3;
+    if (m14 === 3)
+      m14 = -1;
+    if (m24 === 3)
+      m24 = -1;
+    var u1;
+    if ((m14 & 1) === 0) {
+      u1 = 0;
+    } else {
+      var m8 = (k1.andln(7) + d1) & 7;
+      if ((m8 === 3 || m8 === 5) && m24 === 2)
+        u1 = -m14;
+      else
+        u1 = m14;
+    }
+    jsf[0].push(u1);
+
+    var u2;
+    if ((m24 & 1) === 0) {
+      u2 = 0;
+    } else {
+      var m8 = (k2.andln(7) + d2) & 7;
+      if ((m8 === 3 || m8 === 5) && m14 === 2)
+        u2 = -m24;
+      else
+        u2 = m24;
+    }
+    jsf[1].push(u2);
+
+    // Second phase
+    if (2 * d1 === u1 + 1)
+      d1 = 1 - d1;
+    if (2 * d2 === u2 + 1)
+      d2 = 1 - d2;
+    k1.iushrn(1);
+    k2.iushrn(1);
+  }
+
+  return jsf;
+}
+utils.getJSF = getJSF;
+
+function cachedProperty(obj, name, computer) {
+  var key = '_' + name;
+  obj.prototype[name] = function cachedProperty() {
+    return this[key] !== undefined ? this[key] :
+           this[key] = computer.call(this);
+  };
+}
+utils.cachedProperty = cachedProperty;
+
+function parseBytes(bytes) {
+  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :
+                                     bytes;
+}
+utils.parseBytes = parseBytes;
+
+function intFromLE(bytes) {
+  return new BN(bytes, 'hex', 'le');
+}
+utils.intFromLE = intFromLE;
+
+
+},{"bn.js":24,"minimalistic-assert":112,"minimalistic-crypto-utils":113}],89:[function(require,module,exports){
+module.exports={
+  "_from": "elliptic@^6.0.0",
+  "_id": "elliptic@6.4.0",
+  "_inBundle": false,
+  "_integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=",
+  "_location": "/browserify/elliptic",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "elliptic@^6.0.0",
+    "name": "elliptic",
+    "escapedName": "elliptic",
+    "rawSpec": "^6.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^6.0.0"
+  },
+  "_requiredBy": [
+    "/browserify/browserify-sign",
+    "/browserify/create-ecdh"
+  ],
+  "_resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz",
+  "_shasum": "cac9af8762c85836187003c8dfe193e5e2eae5df",
+  "_spec": "elliptic@^6.0.0",
+  "_where": "/usr/local/lib/node_modules/browserify/node_modules/browserify-sign",
+  "author": {
+    "name": "Fedor Indutny",
+    "email": "fedor@indutny.com"
+  },
+  "bugs": {
+    "url": "https://github.com/indutny/elliptic/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "bn.js": "^4.4.0",
+    "brorand": "^1.0.1",
+    "hash.js": "^1.0.0",
+    "hmac-drbg": "^1.0.0",
+    "inherits": "^2.0.1",
+    "minimalistic-assert": "^1.0.0",
+    "minimalistic-crypto-utils": "^1.0.0"
+  },
+  "deprecated": false,
+  "description": "EC cryptography",
+  "devDependencies": {
+    "brfs": "^1.4.3",
+    "coveralls": "^2.11.3",
+    "grunt": "^0.4.5",
+    "grunt-browserify": "^5.0.0",
+    "grunt-cli": "^1.2.0",
+    "grunt-contrib-connect": "^1.0.0",
+    "grunt-contrib-copy": "^1.0.0",
+    "grunt-contrib-uglify": "^1.0.1",
+    "grunt-mocha-istanbul": "^3.0.1",
+    "grunt-saucelabs": "^8.6.2",
+    "istanbul": "^0.4.2",
+    "jscs": "^2.9.0",
+    "jshint": "^2.6.0",
+    "mocha": "^2.1.0"
+  },
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/indutny/elliptic",
+  "keywords": [
+    "EC",
+    "Elliptic",
+    "curve",
+    "Cryptography"
+  ],
+  "license": "MIT",
+  "main": "lib/elliptic.js",
+  "name": "elliptic",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/indutny/elliptic.git"
+  },
+  "scripts": {
+    "jscs": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js",
+    "jshint": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js",
+    "lint": "npm run jscs && npm run jshint",
+    "test": "npm run lint && npm run unit",
+    "unit": "istanbul test _mocha --reporter=spec test/index.js",
+    "version": "grunt dist && git add dist/"
+  },
+  "version": "6.4.0"
+}
+
+},{}],90:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var objectCreate = Object.create || objectCreatePolyfill
+var objectKeys = Object.keys || objectKeysPolyfill
+var bind = Function.prototype.bind || functionBindPolyfill
+
+function EventEmitter() {
+  if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
+    this._events = objectCreate(null);
+    this._eventsCount = 0;
+  }
+
+  this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+var hasDefineProperty;
+try {
+  var o = {};
+  if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
+  hasDefineProperty = o.x === 0;
+} catch (err) { hasDefineProperty = false }
+if (hasDefineProperty) {
+  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+    enumerable: true,
+    get: function() {
+      return defaultMaxListeners;
+    },
+    set: function(arg) {
+      // check whether the input is a positive number (whose value is zero or
+      // greater and not a NaN).
+      if (typeof arg !== 'number' || arg < 0 || arg !== arg)
+        throw new TypeError('"defaultMaxListeners" must be a positive number');
+      defaultMaxListeners = arg;
+    }
+  });
+} else {
+  EventEmitter.defaultMaxListeners = defaultMaxListeners;
+}
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || isNaN(n))
+    throw new TypeError('"n" argument must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
+
+function $getMaxListeners(that) {
+  if (that._maxListeners === undefined)
+    return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return $getMaxListeners(this);
+};
+
+// These standalone emit* functions are used to optimize calling of event
+// handlers for fast cases because emit() itself often has a variable number of
+// arguments and can be deoptimized because of that. These functions always have
+// the same number of arguments and thus do not get deoptimized, so the code
+// inside them can execute faster.
+function emitNone(handler, isFn, self) {
+  if (isFn)
+    handler.call(self);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].call(self);
+  }
+}
+function emitOne(handler, isFn, self, arg1) {
+  if (isFn)
+    handler.call(self, arg1);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].call(self, arg1);
+  }
+}
+function emitTwo(handler, isFn, self, arg1, arg2) {
+  if (isFn)
+    handler.call(self, arg1, arg2);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].call(self, arg1, arg2);
+  }
+}
+function emitThree(handler, isFn, self, arg1, arg2, arg3) {
+  if (isFn)
+    handler.call(self, arg1, arg2, arg3);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].call(self, arg1, arg2, arg3);
+  }
+}
+
+function emitMany(handler, isFn, self, args) {
+  if (isFn)
+    handler.apply(self, args);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].apply(self, args);
+  }
+}
+
+EventEmitter.prototype.emit = function emit(type) {
+  var er, handler, len, args, i, events;
+  var doError = (type === 'error');
+
+  events = this._events;
+  if (events)
+    doError = (doError && events.error == null);
+  else if (!doError)
+    return false;
+
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+    if (arguments.length > 1)
+      er = arguments[1];
+    if (er instanceof Error) {
+      throw er; // Unhandled 'error' event
+    } else {
+      // At least give some kind of context to the user
+      var err = new Error('Unhandled "error" event. (' + er + ')');
+      err.context = er;
+      throw err;
+    }
+    return false;
+  }
+
+  handler = events[type];
+
+  if (!handler)
+    return false;
+
+  var isFn = typeof handler === 'function';
+  len = arguments.length;
+  switch (len) {
+      // fast cases
+    case 1:
+      emitNone(handler, isFn, this);
+      break;
+    case 2:
+      emitOne(handler, isFn, this, arguments[1]);
+      break;
+    case 3:
+      emitTwo(handler, isFn, this, arguments[1], arguments[2]);
+      break;
+    case 4:
+      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
+      break;
+      // slower
+    default:
+      args = new Array(len - 1);
+      for (i = 1; i < len; i++)
+        args[i - 1] = arguments[i];
+      emitMany(handler, isFn, this, args);
+  }
+
+  return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events;
+  var existing;
+
+  if (typeof listener !== 'function')
+    throw new TypeError('"listener" argument must be a function');
+
+  events = target._events;
+  if (!events) {
+    events = target._events = objectCreate(null);
+    target._eventsCount = 0;
+  } else {
+    // To avoid recursion in the case that type === "newListener"! Before
+    // adding it to the listeners, first emit "newListener".
+    if (events.newListener) {
+      target.emit('newListener', type,
+          listener.listener ? listener.listener : listener);
+
+      // Re-assign `events` because a newListener handler could have caused the
+      // this._events to be assigned to a new object
+      events = target._events;
+    }
+    existing = events[type];
+  }
+
+  if (!existing) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === 'function') {
+      // Adding the second element, need to change to array.
+      existing = events[type] =
+          prepend ? [listener, existing] : [existing, listener];
+    } else {
+      // If we've already got an array, just append.
+      if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+    }
+
+    // Check for listener leak
+    if (!existing.warned) {
+      m = $getMaxListeners(target);
+      if (m && m > 0 && existing.length > m) {
+        existing.warned = true;
+        var w = new Error('Possible EventEmitter memory leak detected. ' +
+            existing.length + ' "' + String(type) + '" listeners ' +
+            'added. Use emitter.setMaxListeners() to ' +
+            'increase limit.');
+        w.name = 'MaxListenersExceededWarning';
+        w.emitter = target;
+        w.type = type;
+        w.count = existing.length;
+        if (typeof console === 'object' && console.warn) {
+          console.warn('%s: %s', w.name, w.message);
+        }
+      }
+    }
+  }
+
+  return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+    function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
+
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    switch (arguments.length) {
+      case 0:
+        return this.listener.call(this.target);
+      case 1:
+        return this.listener.call(this.target, arguments[0]);
+      case 2:
+        return this.listener.call(this.target, arguments[0], arguments[1]);
+      case 3:
+        return this.listener.call(this.target, arguments[0], arguments[1],
+            arguments[2]);
+      default:
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; ++i)
+          args[i] = arguments[i];
+        this.listener.apply(this.target, args);
+    }
+  }
+}
+
+function _onceWrap(target, type, listener) {
+  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+  var wrapped = bind.call(onceWrapper, state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+  if (typeof listener !== 'function')
+    throw new TypeError('"listener" argument must be a function');
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+    function prependOnceListener(type, listener) {
+      if (typeof listener !== 'function')
+        throw new TypeError('"listener" argument must be a function');
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+    function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
+
+      if (typeof listener !== 'function')
+        throw new TypeError('"listener" argument must be a function');
+
+      events = this._events;
+      if (!events)
+        return this;
+
+      list = events[type];
+      if (!list)
+        return this;
+
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = objectCreate(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit('removeListener', type, list.listener || listener);
+        }
+      } else if (typeof list !== 'function') {
+        position = -1;
+
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+
+        if (position < 0)
+          return this;
+
+        if (position === 0)
+          list.shift();
+        else
+          spliceOne(list, position);
+
+        if (list.length === 1)
+          events[type] = list[0];
+
+        if (events.removeListener)
+          this.emit('removeListener', type, originalListener || listener);
+      }
+
+      return this;
+    };
+
+EventEmitter.prototype.removeAllListeners =
+    function removeAllListeners(type) {
+      var listeners, events, i;
+
+      events = this._events;
+      if (!events)
+        return this;
+
+      // not listening for removeListener, no need to emit
+      if (!events.removeListener) {
+        if (arguments.length === 0) {
+          this._events = objectCreate(null);
+          this._eventsCount = 0;
+        } else if (events[type]) {
+          if (--this._eventsCount === 0)
+            this._events = objectCreate(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
+
+      // emit removeListener for all listeners on all events
+      if (arguments.length === 0) {
+        var keys = objectKeys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === 'removeListener') continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners('removeListener');
+        this._events = objectCreate(null);
+        this._eventsCount = 0;
+        return this;
+      }
+
+      listeners = events[type];
+
+      if (typeof listeners === 'function') {
+        this.removeListener(type, listeners);
+      } else if (listeners) {
+        // LIFO order
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+
+      return this;
+    };
+
+function _listeners(target, type, unwrap) {
+  var events = target._events;
+
+  if (!events)
+    return [];
+
+  var evlistener = events[type];
+  if (!evlistener)
+    return [];
+
+  if (typeof evlistener === 'function')
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === 'function') {
+    return emitter.listenerCount(type);
+  } else {
+    return listenerCount.call(emitter, type);
+  }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events = this._events;
+
+  if (events) {
+    var evlistener = events[type];
+
+    if (typeof evlistener === 'function') {
+      return 1;
+    } else if (evlistener) {
+      return evlistener.length;
+    }
+  }
+
+  return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+};
+
+// About 1.5x faster than the two-arg version of Array#splice().
+function spliceOne(list, index) {
+  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
+    list[i] = list[k];
+  list.pop();
+}
+
+function arrayClone(arr, n) {
+  var copy = new Array(n);
+  for (var i = 0; i < n; ++i)
+    copy[i] = arr[i];
+  return copy;
+}
+
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
+
+function objectCreatePolyfill(proto) {
+  var F = function() {};
+  F.prototype = proto;
+  return new F;
+}
+function objectKeysPolyfill(obj) {
+  var keys = [];
+  for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
+    keys.push(k);
+  }
+  return k;
+}
+function functionBindPolyfill(context) {
+  var fn = this;
+  return function () {
+    return fn.apply(context, arguments);
+  };
+}
+
+},{}],91:[function(require,module,exports){
+var Buffer = require('safe-buffer').Buffer
+var MD5 = require('md5.js')
+
+/* eslint-disable camelcase */
+function EVP_BytesToKey (password, salt, keyBits, ivLen) {
+  if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary')
+  if (salt) {
+    if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary')
+    if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length')
+  }
+
+  var keyLen = keyBits / 8
+  var key = Buffer.alloc(keyLen)
+  var iv = Buffer.alloc(ivLen || 0)
+  var tmp = Buffer.alloc(0)
+
+  while (keyLen > 0 || ivLen > 0) {
+    var hash = new MD5()
+    hash.update(tmp)
+    hash.update(password)
+    if (salt) hash.update(salt)
+    tmp = hash.digest()
+
+    var used = 0
+
+    if (keyLen > 0) {
+      var keyStart = key.length - keyLen
+      used = Math.min(keyLen, tmp.length)
+      tmp.copy(key, keyStart, 0, used)
+      keyLen -= used
+    }
+
+    if (used < tmp.length && ivLen > 0) {
+      var ivStart = iv.length - ivLen
+      var length = Math.min(ivLen, tmp.length - used)
+      tmp.copy(iv, ivStart, used, used + length)
+      ivLen -= length
+    }
+  }
+
+  tmp.fill(0)
+  return { key: key, iv: iv }
+}
+
+module.exports = EVP_BytesToKey
+
+},{"md5.js":110,"safe-buffer":148}],92:[function(require,module,exports){
+'use strict'
+var Buffer = require('safe-buffer').Buffer
+var Transform = require('stream').Transform
+var inherits = require('inherits')
+
+function throwIfNotStringOrBuffer (val, prefix) {
+  if (!Buffer.isBuffer(val) && typeof val !== 'string') {
+    throw new TypeError(prefix + ' must be a string or a buffer')
+  }
+}
+
+function HashBase (blockSize) {
+  Transform.call(this)
+
+  this._block = Buffer.allocUnsafe(blockSize)
+  this._blockSize = blockSize
+  this._blockOffset = 0
+  this._length = [0, 0, 0, 0]
+
+  this._finalized = false
+}
+
+inherits(HashBase, Transform)
+
+HashBase.prototype._transform = function (chunk, encoding, callback) {
+  var error = null
+  try {
+    this.update(chunk, encoding)
+  } catch (err) {
+    error = err
+  }
+
+  callback(error)
+}
+
+HashBase.prototype._flush = function (callback) {
+  var error = null
+  try {
+    this.push(this.digest())
+  } catch (err) {
+    error = err
+  }
+
+  callback(error)
+}
+
+HashBase.prototype.update = function (data, encoding) {
+  throwIfNotStringOrBuffer(data, 'Data')
+  if (this._finalized) throw new Error('Digest already called')
+  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)
+
+  // consume data
+  var block = this._block
+  var offset = 0
+  while (this._blockOffset + data.length - offset >= this._blockSize) {
+    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]
+    this._update()
+    this._blockOffset = 0
+  }
+  while (offset < data.length) block[this._blockOffset++] = data[offset++]
+
+  // update length
+  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
+    this._length[j] += carry
+    carry = (this._length[j] / 0x0100000000) | 0
+    if (carry > 0) this._length[j] -= 0x0100000000 * carry
+  }
+
+  return this
+}
+
+HashBase.prototype._update = function () {
+  throw new Error('_update is not implemented')
+}
+
+HashBase.prototype.digest = function (encoding) {
+  if (this._finalized) throw new Error('Digest already called')
+  this._finalized = true
+
+  var digest = this._digest()
+  if (encoding !== undefined) digest = digest.toString(encoding)
+
+  // reset state
+  this._block.fill(0)
+  this._blockOffset = 0
+  for (var i = 0; i < 4; ++i) this._length[i] = 0
+
+  return digest
+}
+
+HashBase.prototype._digest = function () {
+  throw new Error('_digest is not implemented')
+}
+
+module.exports = HashBase
+
+},{"inherits":107,"safe-buffer":148,"stream":157}],93:[function(require,module,exports){
+var hash = exports;
+
+hash.utils = require('./hash/utils');
+hash.common = require('./hash/common');
+hash.sha = require('./hash/sha');
+hash.ripemd = require('./hash/ripemd');
+hash.hmac = require('./hash/hmac');
+
+// Proxy hash functions to the main object
+hash.sha1 = hash.sha.sha1;
+hash.sha256 = hash.sha.sha256;
+hash.sha224 = hash.sha.sha224;
+hash.sha384 = hash.sha.sha384;
+hash.sha512 = hash.sha.sha512;
+hash.ripemd160 = hash.ripemd.ripemd160;
+
+},{"./hash/common":94,"./hash/hmac":95,"./hash/ripemd":96,"./hash/sha":97,"./hash/utils":104}],94:[function(require,module,exports){
+'use strict';
+
+var utils = require('./utils');
+var assert = require('minimalistic-assert');
+
+function BlockHash() {
+  this.pending = null;
+  this.pendingTotal = 0;
+  this.blockSize = this.constructor.blockSize;
+  this.outSize = this.constructor.outSize;
+  this.hmacStrength = this.constructor.hmacStrength;
+  this.padLength = this.constructor.padLength / 8;
+  this.endian = 'big';
+
+  this._delta8 = this.blockSize / 8;
+  this._delta32 = this.blockSize / 32;
+}
+exports.BlockHash = BlockHash;
+
+BlockHash.prototype.update = function update(msg, enc) {
+  // Convert message to array, pad it, and join into 32bit blocks
+  msg = utils.toArray(msg, enc);
+  if (!this.pending)
+    this.pending = msg;
+  else
+    this.pending = this.pending.concat(msg);
+  this.pendingTotal += msg.length;
+
+  // Enough data, try updating
+  if (this.pending.length >= this._delta8) {
+    msg = this.pending;
+
+    // Process pending data in blocks
+    var r = msg.length % this._delta8;
+    this.pending = msg.slice(msg.length - r, msg.length);
+    if (this.pending.length === 0)
+      this.pending = null;
+
+    msg = utils.join32(msg, 0, msg.length - r, this.endian);
+    for (var i = 0; i < msg.length; i += this._delta32)
+      this._update(msg, i, i + this._delta32);
+  }
+
+  return this;
+};
+
+BlockHash.prototype.digest = function digest(enc) {
+  this.update(this._pad());
+  assert(this.pending === null);
+
+  return this._digest(enc);
+};
+
+BlockHash.prototype._pad = function pad() {
+  var len = this.pendingTotal;
+  var bytes = this._delta8;
+  var k = bytes - ((len + this.padLength) % bytes);
+  var res = new Array(k + this.padLength);
+  res[0] = 0x80;
+  for (var i = 1; i < k; i++)
+    res[i] = 0;
+
+  // Append length
+  len <<= 3;
+  if (this.endian === 'big') {
+    for (var t = 8; t < this.padLength; t++)
+      res[i++] = 0;
+
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = (len >>> 24) & 0xff;
+    res[i++] = (len >>> 16) & 0xff;
+    res[i++] = (len >>> 8) & 0xff;
+    res[i++] = len & 0xff;
+  } else {
+    res[i++] = len & 0xff;
+    res[i++] = (len >>> 8) & 0xff;
+    res[i++] = (len >>> 16) & 0xff;
+    res[i++] = (len >>> 24) & 0xff;
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = 0;
+    res[i++] = 0;
+
+    for (t = 8; t < this.padLength; t++)
+      res[i++] = 0;
+  }
+
+  return res;
+};
+
+},{"./utils":104,"minimalistic-assert":112}],95:[function(require,module,exports){
+'use strict';
+
+var utils = require('./utils');
+var assert = require('minimalistic-assert');
+
+function Hmac(hash, key, enc) {
+  if (!(this instanceof Hmac))
+    return new Hmac(hash, key, enc);
+  this.Hash = hash;
+  this.blockSize = hash.blockSize / 8;
+  this.outSize = hash.outSize / 8;
+  this.inner = null;
+  this.outer = null;
+
+  this._init(utils.toArray(key, enc));
+}
+module.exports = Hmac;
+
+Hmac.prototype._init = function init(key) {
+  // Shorten key, if needed
+  if (key.length > this.blockSize)
+    key = new this.Hash().update(key).digest();
+  assert(key.length <= this.blockSize);
+
+  // Add padding to key
+  for (var i = key.length; i < this.blockSize; i++)
+    key.push(0);
+
+  for (i = 0; i < key.length; i++)
+    key[i] ^= 0x36;
+  this.inner = new this.Hash().update(key);
+
+  // 0x36 ^ 0x5c = 0x6a
+  for (i = 0; i < key.length; i++)
+    key[i] ^= 0x6a;
+  this.outer = new this.Hash().update(key);
+};
+
+Hmac.prototype.update = function update(msg, enc) {
+  this.inner.update(msg, enc);
+  return this;
+};
+
+Hmac.prototype.digest = function digest(enc) {
+  this.outer.update(this.inner.digest());
+  return this.outer.digest(enc);
+};
+
+},{"./utils":104,"minimalistic-assert":112}],96:[function(require,module,exports){
+'use strict';
+
+var utils = require('./utils');
+var common = require('./common');
+
+var rotl32 = utils.rotl32;
+var sum32 = utils.sum32;
+var sum32_3 = utils.sum32_3;
+var sum32_4 = utils.sum32_4;
+var BlockHash = common.BlockHash;
+
+function RIPEMD160() {
+  if (!(this instanceof RIPEMD160))
+    return new RIPEMD160();
+
+  BlockHash.call(this);
+
+  this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];
+  this.endian = 'little';
+}
+utils.inherits(RIPEMD160, BlockHash);
+exports.ripemd160 = RIPEMD160;
+
+RIPEMD160.blockSize = 512;
+RIPEMD160.outSize = 160;
+RIPEMD160.hmacStrength = 192;
+RIPEMD160.padLength = 64;
+
+RIPEMD160.prototype._update = function update(msg, start) {
+  var A = this.h[0];
+  var B = this.h[1];
+  var C = this.h[2];
+  var D = this.h[3];
+  var E = this.h[4];
+  var Ah = A;
+  var Bh = B;
+  var Ch = C;
+  var Dh = D;
+  var Eh = E;
+  for (var j = 0; j < 80; j++) {
+    var T = sum32(
+      rotl32(
+        sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
+        s[j]),
+      E);
+    A = E;
+    E = D;
+    D = rotl32(C, 10);
+    C = B;
+    B = T;
+    T = sum32(
+      rotl32(
+        sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
+        sh[j]),
+      Eh);
+    Ah = Eh;
+    Eh = Dh;
+    Dh = rotl32(Ch, 10);
+    Ch = Bh;
+    Bh = T;
+  }
+  T = sum32_3(this.h[1], C, Dh);
+  this.h[1] = sum32_3(this.h[2], D, Eh);
+  this.h[2] = sum32_3(this.h[3], E, Ah);
+  this.h[3] = sum32_3(this.h[4], A, Bh);
+  this.h[4] = sum32_3(this.h[0], B, Ch);
+  this.h[0] = T;
+};
+
+RIPEMD160.prototype._digest = function digest(enc) {
+  if (enc === 'hex')
+    return utils.toHex32(this.h, 'little');
+  else
+    return utils.split32(this.h, 'little');
+};
+
+function f(j, x, y, z) {
+  if (j <= 15)
+    return x ^ y ^ z;
+  else if (j <= 31)
+    return (x & y) | ((~x) & z);
+  else if (j <= 47)
+    return (x | (~y)) ^ z;
+  else if (j <= 63)
+    return (x & z) | (y & (~z));
+  else
+    return x ^ (y | (~z));
+}
+
+function K(j) {
+  if (j <= 15)
+    return 0x00000000;
+  else if (j <= 31)
+    return 0x5a827999;
+  else if (j <= 47)
+    return 0x6ed9eba1;
+  else if (j <= 63)
+    return 0x8f1bbcdc;
+  else
+    return 0xa953fd4e;
+}
+
+function Kh(j) {
+  if (j <= 15)
+    return 0x50a28be6;
+  else if (j <= 31)
+    return 0x5c4dd124;
+  else if (j <= 47)
+    return 0x6d703ef3;
+  else if (j <= 63)
+    return 0x7a6d76e9;
+  else
+    return 0x00000000;
+}
+
+var r = [
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
+];
+
+var rh = [
+  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
+];
+
+var s = [
+  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
+];
+
+var sh = [
+  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
+];
+
+},{"./common":94,"./utils":104}],97:[function(require,module,exports){
+'use strict';
+
+exports.sha1 = require('./sha/1');
+exports.sha224 = require('./sha/224');
+exports.sha256 = require('./sha/256');
+exports.sha384 = require('./sha/384');
+exports.sha512 = require('./sha/512');
+
+},{"./sha/1":98,"./sha/224":99,"./sha/256":100,"./sha/384":101,"./sha/512":102}],98:[function(require,module,exports){
+'use strict';
+
+var utils = require('../utils');
+var common = require('../common');
+var shaCommon = require('./common');
+
+var rotl32 = utils.rotl32;
+var sum32 = utils.sum32;
+var sum32_5 = utils.sum32_5;
+var ft_1 = shaCommon.ft_1;
+var BlockHash = common.BlockHash;
+
+var sha1_K = [
+  0x5A827999, 0x6ED9EBA1,
+  0x8F1BBCDC, 0xCA62C1D6
+];
+
+function SHA1() {
+  if (!(this instanceof SHA1))
+    return new SHA1();
+
+  BlockHash.call(this);
+  this.h = [
+    0x67452301, 0xefcdab89, 0x98badcfe,
+    0x10325476, 0xc3d2e1f0 ];
+  this.W = new Array(80);
+}
+
+utils.inherits(SHA1, BlockHash);
+module.exports = SHA1;
+
+SHA1.blockSize = 512;
+SHA1.outSize = 160;
+SHA1.hmacStrength = 80;
+SHA1.padLength = 64;
+
+SHA1.prototype._update = function _update(msg, start) {
+  var W = this.W;
+
+  for (var i = 0; i < 16; i++)
+    W[i] = msg[start + i];
+
+  for(; i < W.length; i++)
+    W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
+
+  var a = this.h[0];
+  var b = this.h[1];
+  var c = this.h[2];
+  var d = this.h[3];
+  var e = this.h[4];
+
+  for (i = 0; i < W.length; i++) {
+    var s = ~~(i / 20);
+    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
+    e = d;
+    d = c;
+    c = rotl32(b, 30);
+    b = a;
+    a = t;
+  }
+
+  this.h[0] = sum32(this.h[0], a);
+  this.h[1] = sum32(this.h[1], b);
+  this.h[2] = sum32(this.h[2], c);
+  this.h[3] = sum32(this.h[3], d);
+  this.h[4] = sum32(this.h[4], e);
+};
+
+SHA1.prototype._digest = function digest(enc) {
+  if (enc === 'hex')
+    return utils.toHex32(this.h, 'big');
+  else
+    return utils.split32(this.h, 'big');
+};
+
+},{"../common":94,"../utils":104,"./common":103}],99:[function(require,module,exports){
+'use strict';
+
+var utils = require('../utils');
+var SHA256 = require('./256');
+
+function SHA224() {
+  if (!(this instanceof SHA224))
+    return new SHA224();
+
+  SHA256.call(this);
+  this.h = [
+    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
+    0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ];
+}
+utils.inherits(SHA224, SHA256);
+module.exports = SHA224;
+
+SHA224.blockSize = 512;
+SHA224.outSize = 224;
+SHA224.hmacStrength = 192;
+SHA224.padLength = 64;
+
+SHA224.prototype._digest = function digest(enc) {
+  // Just truncate output
+  if (enc === 'hex')
+    return utils.toHex32(this.h.slice(0, 7), 'big');
+  else
+    return utils.split32(this.h.slice(0, 7), 'big');
+};
+
+
+},{"../utils":104,"./256":100}],100:[function(require,module,exports){
+'use strict';
+
+var utils = require('../utils');
+var common = require('../common');
+var shaCommon = require('./common');
+var assert = require('minimalistic-assert');
+
+var sum32 = utils.sum32;
+var sum32_4 = utils.sum32_4;
+var sum32_5 = utils.sum32_5;
+var ch32 = shaCommon.ch32;
+var maj32 = shaCommon.maj32;
+var s0_256 = shaCommon.s0_256;
+var s1_256 = shaCommon.s1_256;
+var g0_256 = shaCommon.g0_256;
+var g1_256 = shaCommon.g1_256;
+
+var BlockHash = common.BlockHash;
+
+var sha256_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
+];
+
+function SHA256() {
+  if (!(this instanceof SHA256))
+    return new SHA256();
+
+  BlockHash.call(this);
+  this.h = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+  ];
+  this.k = sha256_K;
+  this.W = new Array(64);
+}
+utils.inherits(SHA256, BlockHash);
+module.exports = SHA256;
+
+SHA256.blockSize = 512;
+SHA256.outSize = 256;
+SHA256.hmacStrength = 192;
+SHA256.padLength = 64;
+
+SHA256.prototype._update = function _update(msg, start) {
+  var W = this.W;
+
+  for (var i = 0; i < 16; i++)
+    W[i] = msg[start + i];
+  for (; i < W.length; i++)
+    W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
+
+  var a = this.h[0];
+  var b = this.h[1];
+  var c = this.h[2];
+  var d = this.h[3];
+  var e = this.h[4];
+  var f = this.h[5];
+  var g = this.h[6];
+  var h = this.h[7];
+
+  assert(this.k.length === W.length);
+  for (i = 0; i < W.length; i++) {
+    var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
+    var T2 = sum32(s0_256(a), maj32(a, b, c));
+    h = g;
+    g = f;
+    f = e;
+    e = sum32(d, T1);
+    d = c;
+    c = b;
+    b = a;
+    a = sum32(T1, T2);
+  }
+
+  this.h[0] = sum32(this.h[0], a);
+  this.h[1] = sum32(this.h[1], b);
+  this.h[2] = sum32(this.h[2], c);
+  this.h[3] = sum32(this.h[3], d);
+  this.h[4] = sum32(this.h[4], e);
+  this.h[5] = sum32(this.h[5], f);
+  this.h[6] = sum32(this.h[6], g);
+  this.h[7] = sum32(this.h[7], h);
+};
+
+SHA256.prototype._digest = function digest(enc) {
+  if (enc === 'hex')
+    return utils.toHex32(this.h, 'big');
+  else
+    return utils.split32(this.h, 'big');
+};
+
+},{"../common":94,"../utils":104,"./common":103,"minimalistic-assert":112}],101:[function(require,module,exports){
+'use strict';
+
+var utils = require('../utils');
+
+var SHA512 = require('./512');
+
+function SHA384() {
+  if (!(this instanceof SHA384))
+    return new SHA384();
+
+  SHA512.call(this);
+  this.h = [
+    0xcbbb9d5d, 0xc1059ed8,
+    0x629a292a, 0x367cd507,
+    0x9159015a, 0x3070dd17,
+    0x152fecd8, 0xf70e5939,
+    0x67332667, 0xffc00b31,
+    0x8eb44a87, 0x68581511,
+    0xdb0c2e0d, 0x64f98fa7,
+    0x47b5481d, 0xbefa4fa4 ];
+}
+utils.inherits(SHA384, SHA512);
+module.exports = SHA384;
+
+SHA384.blockSize = 1024;
+SHA384.outSize = 384;
+SHA384.hmacStrength = 192;
+SHA384.padLength = 128;
+
+SHA384.prototype._digest = function digest(enc) {
+  if (enc === 'hex')
+    return utils.toHex32(this.h.slice(0, 12), 'big');
+  else
+    return utils.split32(this.h.slice(0, 12), 'big');
+};
+
+},{"../utils":104,"./512":102}],102:[function(require,module,exports){
+'use strict';
+
+var utils = require('../utils');
+var common = require('../common');
+var assert = require('minimalistic-assert');
+
+var rotr64_hi = utils.rotr64_hi;
+var rotr64_lo = utils.rotr64_lo;
+var shr64_hi = utils.shr64_hi;
+var shr64_lo = utils.shr64_lo;
+var sum64 = utils.sum64;
+var sum64_hi = utils.sum64_hi;
+var sum64_lo = utils.sum64_lo;
+var sum64_4_hi = utils.sum64_4_hi;
+var sum64_4_lo = utils.sum64_4_lo;
+var sum64_5_hi = utils.sum64_5_hi;
+var sum64_5_lo = utils.sum64_5_lo;
+
+var BlockHash = common.BlockHash;
+
+var sha512_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 SHA512() {
+  if (!(this instanceof SHA512))
+    return new SHA512();
+
+  BlockHash.call(this);
+  this.h = [
+    0x6a09e667, 0xf3bcc908,
+    0xbb67ae85, 0x84caa73b,
+    0x3c6ef372, 0xfe94f82b,
+    0xa54ff53a, 0x5f1d36f1,
+    0x510e527f, 0xade682d1,
+    0x9b05688c, 0x2b3e6c1f,
+    0x1f83d9ab, 0xfb41bd6b,
+    0x5be0cd19, 0x137e2179 ];
+  this.k = sha512_K;
+  this.W = new Array(160);
+}
+utils.inherits(SHA512, BlockHash);
+module.exports = SHA512;
+
+SHA512.blockSize = 1024;
+SHA512.outSize = 512;
+SHA512.hmacStrength = 192;
+SHA512.padLength = 128;
+
+SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
+  var W = this.W;
+
+  // 32 x 32bit words
+  for (var i = 0; i < 32; i++)
+    W[i] = msg[start + i];
+  for (; i < W.length; i += 2) {
+    var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);  // i - 2
+    var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
+    var c1_hi = W[i - 14];  // i - 7
+    var c1_lo = W[i - 13];
+    var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);  // i - 15
+    var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
+    var c3_hi = W[i - 32];  // i - 16
+    var c3_lo = W[i - 31];
+
+    W[i] = sum64_4_hi(
+      c0_hi, c0_lo,
+      c1_hi, c1_lo,
+      c2_hi, c2_lo,
+      c3_hi, c3_lo);
+    W[i + 1] = sum64_4_lo(
+      c0_hi, c0_lo,
+      c1_hi, c1_lo,
+      c2_hi, c2_lo,
+      c3_hi, c3_lo);
+  }
+};
+
+SHA512.prototype._update = function _update(msg, start) {
+  this._prepareBlock(msg, start);
+
+  var W = this.W;
+
+  var ah = this.h[0];
+  var al = this.h[1];
+  var bh = this.h[2];
+  var bl = this.h[3];
+  var ch = this.h[4];
+  var cl = this.h[5];
+  var dh = this.h[6];
+  var dl = this.h[7];
+  var eh = this.h[8];
+  var el = this.h[9];
+  var fh = this.h[10];
+  var fl = this.h[11];
+  var gh = this.h[12];
+  var gl = this.h[13];
+  var hh = this.h[14];
+  var hl = this.h[15];
+
+  assert(this.k.length === W.length);
+  for (var i = 0; i < W.length; i += 2) {
+    var c0_hi = hh;
+    var c0_lo = hl;
+    var c1_hi = s1_512_hi(eh, el);
+    var c1_lo = s1_512_lo(eh, el);
+    var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
+    var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
+    var c3_hi = this.k[i];
+    var c3_lo = this.k[i + 1];
+    var c4_hi = W[i];
+    var c4_lo = W[i + 1];
+
+    var T1_hi = sum64_5_hi(
+      c0_hi, c0_lo,
+      c1_hi, c1_lo,
+      c2_hi, c2_lo,
+      c3_hi, c3_lo,
+      c4_hi, c4_lo);
+    var T1_lo = sum64_5_lo(
+      c0_hi, c0_lo,
+      c1_hi, c1_lo,
+      c2_hi, c2_lo,
+      c3_hi, c3_lo,
+      c4_hi, c4_lo);
+
+    c0_hi = s0_512_hi(ah, al);
+    c0_lo = s0_512_lo(ah, al);
+    c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
+    c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
+
+    var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
+    var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
+
+    hh = gh;
+    hl = gl;
+
+    gh = fh;
+    gl = fl;
+
+    fh = eh;
+    fl = el;
+
+    eh = sum64_hi(dh, dl, T1_hi, T1_lo);
+    el = sum64_lo(dl, dl, T1_hi, T1_lo);
+
+    dh = ch;
+    dl = cl;
+
+    ch = bh;
+    cl = bl;
+
+    bh = ah;
+    bl = al;
+
+    ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
+    al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
+  }
+
+  sum64(this.h, 0, ah, al);
+  sum64(this.h, 2, bh, bl);
+  sum64(this.h, 4, ch, cl);
+  sum64(this.h, 6, dh, dl);
+  sum64(this.h, 8, eh, el);
+  sum64(this.h, 10, fh, fl);
+  sum64(this.h, 12, gh, gl);
+  sum64(this.h, 14, hh, hl);
+};
+
+SHA512.prototype._digest = function digest(enc) {
+  if (enc === 'hex')
+    return utils.toHex32(this.h, 'big');
+  else
+    return utils.split32(this.h, 'big');
+};
+
+function ch64_hi(xh, xl, yh, yl, zh) {
+  var r = (xh & yh) ^ ((~xh) & zh);
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function ch64_lo(xh, xl, yh, yl, zh, zl) {
+  var r = (xl & yl) ^ ((~xl) & zl);
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function maj64_hi(xh, xl, yh, yl, zh) {
+  var r = (xh & yh) ^ (xh & zh) ^ (yh & zh);
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function maj64_lo(xh, xl, yh, yl, zh, zl) {
+  var r = (xl & yl) ^ (xl & zl) ^ (yl & zl);
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function s0_512_hi(xh, xl) {
+  var c0_hi = rotr64_hi(xh, xl, 28);
+  var c1_hi = rotr64_hi(xl, xh, 2);  // 34
+  var c2_hi = rotr64_hi(xl, xh, 7);  // 39
+
+  var r = c0_hi ^ c1_hi ^ c2_hi;
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function s0_512_lo(xh, xl) {
+  var c0_lo = rotr64_lo(xh, xl, 28);
+  var c1_lo = rotr64_lo(xl, xh, 2);  // 34
+  var c2_lo = rotr64_lo(xl, xh, 7);  // 39
+
+  var r = c0_lo ^ c1_lo ^ c2_lo;
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function s1_512_hi(xh, xl) {
+  var c0_hi = rotr64_hi(xh, xl, 14);
+  var c1_hi = rotr64_hi(xh, xl, 18);
+  var c2_hi = rotr64_hi(xl, xh, 9);  // 41
+
+  var r = c0_hi ^ c1_hi ^ c2_hi;
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function s1_512_lo(xh, xl) {
+  var c0_lo = rotr64_lo(xh, xl, 14);
+  var c1_lo = rotr64_lo(xh, xl, 18);
+  var c2_lo = rotr64_lo(xl, xh, 9);  // 41
+
+  var r = c0_lo ^ c1_lo ^ c2_lo;
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function g0_512_hi(xh, xl) {
+  var c0_hi = rotr64_hi(xh, xl, 1);
+  var c1_hi = rotr64_hi(xh, xl, 8);
+  var c2_hi = shr64_hi(xh, xl, 7);
+
+  var r = c0_hi ^ c1_hi ^ c2_hi;
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function g0_512_lo(xh, xl) {
+  var c0_lo = rotr64_lo(xh, xl, 1);
+  var c1_lo = rotr64_lo(xh, xl, 8);
+  var c2_lo = shr64_lo(xh, xl, 7);
+
+  var r = c0_lo ^ c1_lo ^ c2_lo;
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function g1_512_hi(xh, xl) {
+  var c0_hi = rotr64_hi(xh, xl, 19);
+  var c1_hi = rotr64_hi(xl, xh, 29);  // 61
+  var c2_hi = shr64_hi(xh, xl, 6);
+
+  var r = c0_hi ^ c1_hi ^ c2_hi;
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+function g1_512_lo(xh, xl) {
+  var c0_lo = rotr64_lo(xh, xl, 19);
+  var c1_lo = rotr64_lo(xl, xh, 29);  // 61
+  var c2_lo = shr64_lo(xh, xl, 6);
+
+  var r = c0_lo ^ c1_lo ^ c2_lo;
+  if (r < 0)
+    r += 0x100000000;
+  return r;
+}
+
+},{"../common":94,"../utils":104,"minimalistic-assert":112}],103:[function(require,module,exports){
+'use strict';
+
+var utils = require('../utils');
+var rotr32 = utils.rotr32;
+
+function ft_1(s, x, y, z) {
+  if (s === 0)
+    return ch32(x, y, z);
+  if (s === 1 || s === 3)
+    return p32(x, y, z);
+  if (s === 2)
+    return maj32(x, y, z);
+}
+exports.ft_1 = ft_1;
+
+function ch32(x, y, z) {
+  return (x & y) ^ ((~x) & z);
+}
+exports.ch32 = ch32;
+
+function maj32(x, y, z) {
+  return (x & y) ^ (x & z) ^ (y & z);
+}
+exports.maj32 = maj32;
+
+function p32(x, y, z) {
+  return x ^ y ^ z;
+}
+exports.p32 = p32;
+
+function s0_256(x) {
+  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
+}
+exports.s0_256 = s0_256;
+
+function s1_256(x) {
+  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
+}
+exports.s1_256 = s1_256;
+
+function g0_256(x) {
+  return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);
+}
+exports.g0_256 = g0_256;
+
+function g1_256(x) {
+  return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);
+}
+exports.g1_256 = g1_256;
+
+},{"../utils":104}],104:[function(require,module,exports){
+'use strict';
+
+var assert = require('minimalistic-assert');
+var inherits = require('inherits');
+
+exports.inherits = inherits;
+
+function toArray(msg, enc) {
+  if (Array.isArray(msg))
+    return msg.slice();
+  if (!msg)
+    return [];
+  var res = [];
+  if (typeof msg === 'string') {
+    if (!enc) {
+      for (var i = 0; i < msg.length; i++) {
+        var c = msg.charCodeAt(i);
+        var hi = c >> 8;
+        var lo = c & 0xff;
+        if (hi)
+          res.push(hi, lo);
+        else
+          res.push(lo);
+      }
+    } else if (enc === 'hex') {
+      msg = msg.replace(/[^a-z0-9]+/ig, '');
+      if (msg.length % 2 !== 0)
+        msg = '0' + msg;
+      for (i = 0; i < msg.length; i += 2)
+        res.push(parseInt(msg[i] + msg[i + 1], 16));
+    }
+  } else {
+    for (i = 0; i < msg.length; i++)
+      res[i] = msg[i] | 0;
+  }
+  return res;
+}
+exports.toArray = toArray;
+
+function toHex(msg) {
+  var res = '';
+  for (var i = 0; i < msg.length; i++)
+    res += zero2(msg[i].toString(16));
+  return res;
+}
+exports.toHex = toHex;
+
+function htonl(w) {
+  var res = (w >>> 24) |
+            ((w >>> 8) & 0xff00) |
+            ((w << 8) & 0xff0000) |
+            ((w & 0xff) << 24);
+  return res >>> 0;
+}
+exports.htonl = htonl;
+
+function toHex32(msg, endian) {
+  var res = '';
+  for (var i = 0; i < msg.length; i++) {
+    var w = msg[i];
+    if (endian === 'little')
+      w = htonl(w);
+    res += zero8(w.toString(16));
+  }
+  return res;
+}
+exports.toHex32 = toHex32;
+
+function zero2(word) {
+  if (word.length === 1)
+    return '0' + word;
+  else
+    return word;
+}
+exports.zero2 = zero2;
+
+function zero8(word) {
+  if (word.length === 7)
+    return '0' + word;
+  else if (word.length === 6)
+    return '00' + word;
+  else if (word.length === 5)
+    return '000' + word;
+  else if (word.length === 4)
+    return '0000' + word;
+  else if (word.length === 3)
+    return '00000' + word;
+  else if (word.length === 2)
+    return '000000' + word;
+  else if (word.length === 1)
+    return '0000000' + word;
+  else
+    return word;
+}
+exports.zero8 = zero8;
+
+function join32(msg, start, end, endian) {
+  var len = end - start;
+  assert(len % 4 === 0);
+  var res = new Array(len / 4);
+  for (var i = 0, k = start; i < res.length; i++, k += 4) {
+    var w;
+    if (endian === 'big')
+      w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];
+    else
+      w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];
+    res[i] = w >>> 0;
+  }
+  return res;
+}
+exports.join32 = join32;
+
+function split32(msg, endian) {
+  var res = new Array(msg.length * 4);
+  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
+    var m = msg[i];
+    if (endian === 'big') {
+      res[k] = m >>> 24;
+      res[k + 1] = (m >>> 16) & 0xff;
+      res[k + 2] = (m >>> 8) & 0xff;
+      res[k + 3] = m & 0xff;
+    } else {
+      res[k + 3] = m >>> 24;
+      res[k + 2] = (m >>> 16) & 0xff;
+      res[k + 1] = (m >>> 8) & 0xff;
+      res[k] = m & 0xff;
+    }
+  }
+  return res;
+}
+exports.split32 = split32;
+
+function rotr32(w, b) {
+  return (w >>> b) | (w << (32 - b));
+}
+exports.rotr32 = rotr32;
+
+function rotl32(w, b) {
+  return (w << b) | (w >>> (32 - b));
+}
+exports.rotl32 = rotl32;
+
+function sum32(a, b) {
+  return (a + b) >>> 0;
+}
+exports.sum32 = sum32;
+
+function sum32_3(a, b, c) {
+  return (a + b + c) >>> 0;
+}
+exports.sum32_3 = sum32_3;
+
+function sum32_4(a, b, c, d) {
+  return (a + b + c + d) >>> 0;
+}
+exports.sum32_4 = sum32_4;
+
+function sum32_5(a, b, c, d, e) {
+  return (a + b + c + d + e) >>> 0;
+}
+exports.sum32_5 = sum32_5;
+
+function sum64(buf, pos, ah, al) {
+  var bh = buf[pos];
+  var bl = buf[pos + 1];
+
+  var lo = (al + bl) >>> 0;
+  var hi = (lo < al ? 1 : 0) + ah + bh;
+  buf[pos] = hi >>> 0;
+  buf[pos + 1] = lo;
+}
+exports.sum64 = sum64;
+
+function sum64_hi(ah, al, bh, bl) {
+  var lo = (al + bl) >>> 0;
+  var hi = (lo < al ? 1 : 0) + ah + bh;
+  return hi >>> 0;
+}
+exports.sum64_hi = sum64_hi;
+
+function sum64_lo(ah, al, bh, bl) {
+  var lo = al + bl;
+  return lo >>> 0;
+}
+exports.sum64_lo = sum64_lo;
+
+function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
+  var carry = 0;
+  var lo = al;
+  lo = (lo + bl) >>> 0;
+  carry += lo < al ? 1 : 0;
+  lo = (lo + cl) >>> 0;
+  carry += lo < cl ? 1 : 0;
+  lo = (lo + dl) >>> 0;
+  carry += lo < dl ? 1 : 0;
+
+  var hi = ah + bh + ch + dh + carry;
+  return hi >>> 0;
+}
+exports.sum64_4_hi = sum64_4_hi;
+
+function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
+  var lo = al + bl + cl + dl;
+  return lo >>> 0;
+}
+exports.sum64_4_lo = sum64_4_lo;
+
+function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+  var carry = 0;
+  var lo = al;
+  lo = (lo + bl) >>> 0;
+  carry += lo < al ? 1 : 0;
+  lo = (lo + cl) >>> 0;
+  carry += lo < cl ? 1 : 0;
+  lo = (lo + dl) >>> 0;
+  carry += lo < dl ? 1 : 0;
+  lo = (lo + el) >>> 0;
+  carry += lo < el ? 1 : 0;
+
+  var hi = ah + bh + ch + dh + eh + carry;
+  return hi >>> 0;
+}
+exports.sum64_5_hi = sum64_5_hi;
+
+function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+  var lo = al + bl + cl + dl + el;
+
+  return lo >>> 0;
+}
+exports.sum64_5_lo = sum64_5_lo;
+
+function rotr64_hi(ah, al, num) {
+  var r = (al << (32 - num)) | (ah >>> num);
+  return r >>> 0;
+}
+exports.rotr64_hi = rotr64_hi;
+
+function rotr64_lo(ah, al, num) {
+  var r = (ah << (32 - num)) | (al >>> num);
+  return r >>> 0;
+}
+exports.rotr64_lo = rotr64_lo;
+
+function shr64_hi(ah, al, num) {
+  return ah >>> num;
+}
+exports.shr64_hi = shr64_hi;
+
+function shr64_lo(ah, al, num) {
+  var r = (ah << (32 - num)) | (al >>> num);
+  return r >>> 0;
+}
+exports.shr64_lo = shr64_lo;
+
+},{"inherits":107,"minimalistic-assert":112}],105:[function(require,module,exports){
+'use strict';
+
+var hash = require('hash.js');
+var utils = require('minimalistic-crypto-utils');
+var assert = require('minimalistic-assert');
+
+function HmacDRBG(options) {
+  if (!(this instanceof HmacDRBG))
+    return new HmacDRBG(options);
+  this.hash = options.hash;
+  this.predResist = !!options.predResist;
+
+  this.outLen = this.hash.outSize;
+  this.minEntropy = options.minEntropy || this.hash.hmacStrength;
+
+  this._reseed = null;
+  this.reseedInterval = null;
+  this.K = null;
+  this.V = null;
+
+  var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');
+  var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');
+  var pers = utils.toArray(options.pers, options.persEnc || 'hex');
+  assert(entropy.length >= (this.minEntropy / 8),
+         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
+  this._init(entropy, nonce, pers);
+}
+module.exports = HmacDRBG;
+
+HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
+  var seed = entropy.concat(nonce).concat(pers);
+
+  this.K = new Array(this.outLen / 8);
+  this.V = new Array(this.outLen / 8);
+  for (var i = 0; i < this.V.length; i++) {
+    this.K[i] = 0x00;
+    this.V[i] = 0x01;
+  }
+
+  this._update(seed);
+  this._reseed = 1;
+  this.reseedInterval = 0x1000000000000;  // 2^48
+};
+
+HmacDRBG.prototype._hmac = function hmac() {
+  return new hash.hmac(this.hash, this.K);
+};
+
+HmacDRBG.prototype._update = function update(seed) {
+  var kmac = this._hmac()
+                 .update(this.V)
+                 .update([ 0x00 ]);
+  if (seed)
+    kmac = kmac.update(seed);
+  this.K = kmac.digest();
+  this.V = this._hmac().update(this.V).digest();
+  if (!seed)
+    return;
+
+  this.K = this._hmac()
+               .update(this.V)
+               .update([ 0x01 ])
+               .update(seed)
+               .digest();
+  this.V = this._hmac().update(this.V).digest();
+};
+
+HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
+  // Optional entropy enc
+  if (typeof entropyEnc !== 'string') {
+    addEnc = add;
+    add = entropyEnc;
+    entropyEnc = null;
+  }
+
+  entropy = utils.toArray(entropy, entropyEnc);
+  add = utils.toArray(add, addEnc);
+
+  assert(entropy.length >= (this.minEntropy / 8),
+         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
+
+  this._update(entropy.concat(add || []));
+  this._reseed = 1;
+};
+
+HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
+  if (this._reseed > this.reseedInterval)
+    throw new Error('Reseed is required');
+
+  // Optional encoding
+  if (typeof enc !== 'string') {
+    addEnc = add;
+    add = enc;
+    enc = null;
+  }
+
+  // Optional additional data
+  if (add) {
+    add = utils.toArray(add, addEnc || 'hex');
+    this._update(add);
+  }
+
+  var temp = [];
+  while (temp.length < len) {
+    this.V = this._hmac().update(this.V).digest();
+    temp = temp.concat(this.V);
+  }
+
+  var res = temp.slice(0, len);
+  this._update(add);
+  this._reseed++;
+  return utils.encode(res, enc);
+};
+
+},{"hash.js":93,"minimalistic-assert":112,"minimalistic-crypto-utils":113}],106:[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
+}
+
+},{}],107:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}
+
+},{}],108:[function(require,module,exports){
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+// The _isBuffer check is for Safari 5-7 support, because it's missing
+// Object.prototype.constructor. Remove this eventually
+module.exports = function (obj) {
+  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+}
+
+function isBuffer (obj) {
+  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+}
+
+// For Node v0.10 support. Remove this eventually.
+function isSlowBuffer (obj) {
+  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
+}
+
+},{}],109:[function(require,module,exports){
+var toString = {}.toString;
+
+module.exports = Array.isArray || function (arr) {
+  return toString.call(arr) == '[object Array]';
+};
+
+},{}],110:[function(require,module,exports){
+(function (Buffer){
+'use strict'
+var inherits = require('inherits')
+var HashBase = require('hash-base')
+
+var ARRAY16 = new Array(16)
+
+function MD5 () {
+  HashBase.call(this, 64)
+
+  // state
+  this._a = 0x67452301
+  this._b = 0xefcdab89
+  this._c = 0x98badcfe
+  this._d = 0x10325476
+}
+
+inherits(MD5, HashBase)
+
+MD5.prototype._update = function () {
+  var M = ARRAY16
+  for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)
+
+  var a = this._a
+  var b = this._b
+  var c = this._c
+  var d = this._d
+
+  a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)
+  d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)
+  c = fnF(c, d, a, b, M[2], 0x242070db, 17)
+  b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)
+  a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)
+  d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)
+  c = fnF(c, d, a, b, M[6], 0xa8304613, 17)
+  b = fnF(b, c, d, a, M[7], 0xfd469501, 22)
+  a = fnF(a, b, c, d, M[8], 0x698098d8, 7)
+  d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)
+  c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)
+  b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)
+  a = fnF(a, b, c, d, M[12], 0x6b901122, 7)
+  d = fnF(d, a, b, c, M[13], 0xfd987193, 12)
+  c = fnF(c, d, a, b, M[14], 0xa679438e, 17)
+  b = fnF(b, c, d, a, M[15], 0x49b40821, 22)
+
+  a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)
+  d = fnG(d, a, b, c, M[6], 0xc040b340, 9)
+  c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)
+  b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)
+  a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)
+  d = fnG(d, a, b, c, M[10], 0x02441453, 9)
+  c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)
+  b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)
+  a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)
+  d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)
+  c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)
+  b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)
+  a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)
+  d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)
+  c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)
+  b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)
+
+  a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)
+  d = fnH(d, a, b, c, M[8], 0x8771f681, 11)
+  c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)
+  b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)
+  a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)
+  d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)
+  c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)
+  b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)
+  a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)
+  d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)
+  c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)
+  b = fnH(b, c, d, a, M[6], 0x04881d05, 23)
+  a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)
+  d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)
+  c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)
+  b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)
+
+  a = fnI(a, b, c, d, M[0], 0xf4292244, 6)
+  d = fnI(d, a, b, c, M[7], 0x432aff97, 10)
+  c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)
+  b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)
+  a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)
+  d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)
+  c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)
+  b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)
+  a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)
+  d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)
+  c = fnI(c, d, a, b, M[6], 0xa3014314, 15)
+  b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)
+  a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)
+  d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)
+  c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)
+  b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)
+
+  this._a = (this._a + a) | 0
+  this._b = (this._b + b) | 0
+  this._c = (this._c + c) | 0
+  this._d = (this._d + d) | 0
+}
+
+MD5.prototype._digest = function () {
+  // create padding and handle blocks
+  this._block[this._blockOffset++] = 0x80
+  if (this._blockOffset > 56) {
+    this._block.fill(0, this._blockOffset, 64)
+    this._update()
+    this._blockOffset = 0
+  }
+
+  this._block.fill(0, this._blockOffset, 56)
+  this._block.writeUInt32LE(this._length[0], 56)
+  this._block.writeUInt32LE(this._length[1], 60)
+  this._update()
+
+  // produce result
+  var buffer = new Buffer(16)
+  buffer.writeInt32LE(this._a, 0)
+  buffer.writeInt32LE(this._b, 4)
+  buffer.writeInt32LE(this._c, 8)
+  buffer.writeInt32LE(this._d, 12)
+  return buffer
+}
+
+function rotl (x, n) {
+  return (x << n) | (x >>> (32 - n))
+}
+
+function fnF (a, b, c, d, m, k, s) {
+  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0
+}
+
+function fnG (a, b, c, d, m, k, s) {
+  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0
+}
+
+function fnH (a, b, c, d, m, k, s) {
+  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0
+}
+
+function fnI (a, b, c, d, m, k, s) {
+  return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0
+}
+
+module.exports = MD5
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":55,"hash-base":92,"inherits":107}],111:[function(require,module,exports){
+var bn = require('bn.js');
+var brorand = require('brorand');
+
+function MillerRabin(rand) {
+  this.rand = rand || new brorand.Rand();
+}
+module.exports = MillerRabin;
+
+MillerRabin.create = function create(rand) {
+  return new MillerRabin(rand);
+};
+
+MillerRabin.prototype._randbelow = function _randbelow(n) {
+  var len = n.bitLength();
+  var min_bytes = Math.ceil(len / 8);
+
+  // Generage random bytes until a number less than n is found.
+  // This ensures that 0..n-1 have an equal probability of being selected.
+  do
+    var a = new bn(this.rand.generate(min_bytes));
+  while (a.cmp(n) >= 0);
+
+  return a;
+};
+
+MillerRabin.prototype._randrange = function _randrange(start, stop) {
+  // Generate a random number greater than or equal to start and less than stop.
+  var size = stop.sub(start);
+  return start.add(this._randbelow(size));
+};
+
+MillerRabin.prototype.test = function test(n, k, cb) {
+  var len = n.bitLength();
+  var red = bn.mont(n);
+  var rone = new bn(1).toRed(red);
+
+  if (!k)
+    k = Math.max(1, (len / 48) | 0);
+
+  // Find d and s, (n - 1) = (2 ^ s) * d;
+  var n1 = n.subn(1);
+  for (var s = 0; !n1.testn(s); s++) {}
+  var d = n.shrn(s);
+
+  var rn1 = n1.toRed(red);
+
+  var prime = true;
+  for (; k > 0; k--) {
+    var a = this._randrange(new bn(2), n1);
+    if (cb)
+      cb(a);
+
+    var x = a.toRed(red).redPow(d);
+    if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
+      continue;
+
+    for (var i = 1; i < s; i++) {
+      x = x.redSqr();
+
+      if (x.cmp(rone) === 0)
+        return false;
+      if (x.cmp(rn1) === 0)
+        break;
+    }
+
+    if (i === s)
+      return false;
+  }
+
+  return prime;
+};
+
+MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
+  var len = n.bitLength();
+  var red = bn.mont(n);
+  var rone = new bn(1).toRed(red);
+
+  if (!k)
+    k = Math.max(1, (len / 48) | 0);
+
+  // Find d and s, (n - 1) = (2 ^ s) * d;
+  var n1 = n.subn(1);
+  for (var s = 0; !n1.testn(s); s++) {}
+  var d = n.shrn(s);
+
+  var rn1 = n1.toRed(red);
+
+  for (; k > 0; k--) {
+    var a = this._randrange(new bn(2), n1);
+
+    var g = n.gcd(a);
+    if (g.cmpn(1) !== 0)
+      return g;
+
+    var x = a.toRed(red).redPow(d);
+    if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
+      continue;
+
+    for (var i = 1; i < s; i++) {
+      x = x.redSqr();
+
+      if (x.cmp(rone) === 0)
+        return x.fromRed().subn(1).gcd(n);
+      if (x.cmp(rn1) === 0)
+        break;
+    }
+
+    if (i === s) {
+      x = x.redSqr();
+      return x.fromRed().subn(1).gcd(n);
+    }
+  }
+
+  return false;
+};
+
+},{"bn.js":24,"brorand":25}],112:[function(require,module,exports){
+module.exports = assert;
+
+function assert(val, msg) {
+  if (!val)
+    throw new Error(msg || 'Assertion failed');
+}
+
+assert.equal = function assertEqual(l, r, msg) {
+  if (l != r)
+    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
+};
+
+},{}],113:[function(require,module,exports){
+'use strict';
+
+var utils = exports;
+
+function toArray(msg, enc) {
+  if (Array.isArray(msg))
+    return msg.slice();
+  if (!msg)
+    return [];
+  var res = [];
+  if (typeof msg !== 'string') {
+    for (var i = 0; i < msg.length; i++)
+      res[i] = msg[i] | 0;
+    return res;
+  }
+  if (enc === 'hex') {
+    msg = msg.replace(/[^a-z0-9]+/ig, '');
+    if (msg.length % 2 !== 0)
+      msg = '0' + msg;
+    for (var i = 0; i < msg.length; i += 2)
+      res.push(parseInt(msg[i] + msg[i + 1], 16));
+  } else {
+    for (var i = 0; i < msg.length; i++) {
+      var c = msg.charCodeAt(i);
+      var hi = c >> 8;
+      var lo = c & 0xff;
+      if (hi)
+        res.push(hi, lo);
+      else
+        res.push(lo);
+    }
+  }
+  return res;
+}
+utils.toArray = toArray;
+
+function zero2(word) {
+  if (word.length === 1)
+    return '0' + word;
+  else
+    return word;
+}
+utils.zero2 = zero2;
+
+function toHex(msg) {
+  var res = '';
+  for (var i = 0; i < msg.length; i++)
+    res += zero2(msg[i].toString(16));
+  return res;
+}
+utils.toHex = toHex;
+
+utils.encode = function encode(arr, enc) {
+  if (enc === 'hex')
+    return toHex(arr);
+  else
+    return arr;
+};
+
+},{}],114:[function(require,module,exports){
+module.exports={"2.16.840.1.101.3.4.1.1": "aes-128-ecb",
+"2.16.840.1.101.3.4.1.2": "aes-128-cbc",
+"2.16.840.1.101.3.4.1.3": "aes-128-ofb",
+"2.16.840.1.101.3.4.1.4": "aes-128-cfb",
+"2.16.840.1.101.3.4.1.21": "aes-192-ecb",
+"2.16.840.1.101.3.4.1.22": "aes-192-cbc",
+"2.16.840.1.101.3.4.1.23": "aes-192-ofb",
+"2.16.840.1.101.3.4.1.24": "aes-192-cfb",
+"2.16.840.1.101.3.4.1.41": "aes-256-ecb",
+"2.16.840.1.101.3.4.1.42": "aes-256-cbc",
+"2.16.840.1.101.3.4.1.43": "aes-256-ofb",
+"2.16.840.1.101.3.4.1.44": "aes-256-cfb"
+}
+},{}],115:[function(require,module,exports){
+// from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js
+// Fedor, you are amazing.
+'use strict'
+
+var asn1 = require('asn1.js')
+
+exports.certificate = require('./certificate')
+
+var RSAPrivateKey = asn1.define('RSAPrivateKey', function () {
+  this.seq().obj(
+    this.key('version').int(),
+    this.key('modulus').int(),
+    this.key('publicExponent').int(),
+    this.key('privateExponent').int(),
+    this.key('prime1').int(),
+    this.key('prime2').int(),
+    this.key('exponent1').int(),
+    this.key('exponent2').int(),
+    this.key('coefficient').int()
+  )
+})
+exports.RSAPrivateKey = RSAPrivateKey
+
+var RSAPublicKey = asn1.define('RSAPublicKey', function () {
+  this.seq().obj(
+    this.key('modulus').int(),
+    this.key('publicExponent').int()
+  )
+})
+exports.RSAPublicKey = RSAPublicKey
+
+var PublicKey = asn1.define('SubjectPublicKeyInfo', function () {
+  this.seq().obj(
+    this.key('algorithm').use(AlgorithmIdentifier),
+    this.key('subjectPublicKey').bitstr()
+  )
+})
+exports.PublicKey = PublicKey
+
+var AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () {
+  this.seq().obj(
+    this.key('algorithm').objid(),
+    this.key('none').null_().optional(),
+    this.key('curve').objid().optional(),
+    this.key('params').seq().obj(
+      this.key('p').int(),
+      this.key('q').int(),
+      this.key('g').int()
+    ).optional()
+  )
+})
+
+var PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () {
+  this.seq().obj(
+    this.key('version').int(),
+    this.key('algorithm').use(AlgorithmIdentifier),
+    this.key('subjectPrivateKey').octstr()
+  )
+})
+exports.PrivateKey = PrivateKeyInfo
+var EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () {
+  this.seq().obj(
+    this.key('algorithm').seq().obj(
+      this.key('id').objid(),
+      this.key('decrypt').seq().obj(
+        this.key('kde').seq().obj(
+          this.key('id').objid(),
+          this.key('kdeparams').seq().obj(
+            this.key('salt').octstr(),
+            this.key('iters').int()
+          )
+        ),
+        this.key('cipher').seq().obj(
+          this.key('algo').objid(),
+          this.key('iv').octstr()
+        )
+      )
+    ),
+    this.key('subjectPrivateKey').octstr()
+  )
+})
+
+exports.EncryptedPrivateKey = EncryptedPrivateKeyInfo
+
+var DSAPrivateKey = asn1.define('DSAPrivateKey', function () {
+  this.seq().obj(
+    this.key('version').int(),
+    this.key('p').int(),
+    this.key('q').int(),
+    this.key('g').int(),
+    this.key('pub_key').int(),
+    this.key('priv_key').int()
+  )
+})
+exports.DSAPrivateKey = DSAPrivateKey
+
+exports.DSAparam = asn1.define('DSAparam', function () {
+  this.int()
+})
+
+var ECPrivateKey = asn1.define('ECPrivateKey', function () {
+  this.seq().obj(
+    this.key('version').int(),
+    this.key('privateKey').octstr(),
+    this.key('parameters').optional().explicit(0).use(ECParameters),
+    this.key('publicKey').optional().explicit(1).bitstr()
+  )
+})
+exports.ECPrivateKey = ECPrivateKey
+
+var ECParameters = asn1.define('ECParameters', function () {
+  this.choice({
+    namedCurve: this.objid()
+  })
+})
+
+exports.signature = asn1.define('signature', function () {
+  this.seq().obj(
+    this.key('r').int(),
+    this.key('s').int()
+  )
+})
+
+},{"./certificate":116,"asn1.js":9}],116:[function(require,module,exports){
+// from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js
+// thanks to @Rantanen
+
+'use strict'
+
+var asn = require('asn1.js')
+
+var Time = asn.define('Time', function () {
+  this.choice({
+    utcTime: this.utctime(),
+    generalTime: this.gentime()
+  })
+})
+
+var AttributeTypeValue = asn.define('AttributeTypeValue', function () {
+  this.seq().obj(
+    this.key('type').objid(),
+    this.key('value').any()
+  )
+})
+
+var AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () {
+  this.seq().obj(
+    this.key('algorithm').objid(),
+    this.key('parameters').optional()
+  )
+})
+
+var SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () {
+  this.seq().obj(
+    this.key('algorithm').use(AlgorithmIdentifier),
+    this.key('subjectPublicKey').bitstr()
+  )
+})
+
+var RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () {
+  this.setof(AttributeTypeValue)
+})
+
+var RDNSequence = asn.define('RDNSequence', function () {
+  this.seqof(RelativeDistinguishedName)
+})
+
+var Name = asn.define('Name', function () {
+  this.choice({
+    rdnSequence: this.use(RDNSequence)
+  })
+})
+
+var Validity = asn.define('Validity', function () {
+  this.seq().obj(
+    this.key('notBefore').use(Time),
+    this.key('notAfter').use(Time)
+  )
+})
+
+var Extension = asn.define('Extension', function () {
+  this.seq().obj(
+    this.key('extnID').objid(),
+    this.key('critical').bool().def(false),
+    this.key('extnValue').octstr()
+  )
+})
+
+var TBSCertificate = asn.define('TBSCertificate', function () {
+  this.seq().obj(
+    this.key('version').explicit(0).int(),
+    this.key('serialNumber').int(),
+    this.key('signature').use(AlgorithmIdentifier),
+    this.key('issuer').use(Name),
+    this.key('validity').use(Validity),
+    this.key('subject').use(Name),
+    this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo),
+    this.key('issuerUniqueID').implicit(1).bitstr().optional(),
+    this.key('subjectUniqueID').implicit(2).bitstr().optional(),
+    this.key('extensions').explicit(3).seqof(Extension).optional()
+  )
+})
+
+var X509Certificate = asn.define('X509Certificate', function () {
+  this.seq().obj(
+    this.key('tbsCertificate').use(TBSCertificate),
+    this.key('signatureAlgorithm').use(AlgorithmIdentifier),
+    this.key('signatureValue').bitstr()
+  )
+})
+
+module.exports = X509Certificate
+
+},{"asn1.js":9}],117:[function(require,module,exports){
+(function (Buffer){
+// adapted from https://github.com/apatil/pemstrip
+var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r\+\/\=]+)[\n\r]+/m
+var startRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----/m
+var fullRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----([0-9A-z\n\r\+\/\=]+)-----END \1-----$/m
+var evp = require('evp_bytestokey')
+var ciphers = require('browserify-aes')
+module.exports = function (okey, password) {
+  var key = okey.toString()
+  var match = key.match(findProc)
+  var decrypted
+  if (!match) {
+    var match2 = key.match(fullRegex)
+    decrypted = new Buffer(match2[2].replace(/[\r\n]/g, ''), 'base64')
+  } else {
+    var suite = 'aes' + match[1]
+    var iv = new Buffer(match[2], 'hex')
+    var cipherText = new Buffer(match[3].replace(/[\r\n]/g, ''), 'base64')
+    var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key
+    var out = []
+    var cipher = ciphers.createDecipheriv(suite, cipherKey, iv)
+    out.push(cipher.update(cipherText))
+    out.push(cipher.final())
+    decrypted = Buffer.concat(out)
+  }
+  var tag = key.match(startRegex)[1]
+  return {
+    tag: tag,
+    data: decrypted
+  }
+}
+
+}).call(this,require("buffer").Buffer)
+},{"browserify-aes":29,"buffer":55,"evp_bytestokey":91}],118:[function(require,module,exports){
+(function (Buffer){
+var asn1 = require('./asn1')
+var aesid = require('./aesid.json')
+var fixProc = require('./fixProc')
+var ciphers = require('browserify-aes')
+var compat = require('pbkdf2')
+module.exports = parseKeys
+
+function parseKeys (buffer) {
+  var password
+  if (typeof buffer === 'object' && !Buffer.isBuffer(buffer)) {
+    password = buffer.passphrase
+    buffer = buffer.key
+  }
+  if (typeof buffer === 'string') {
+    buffer = new Buffer(buffer)
+  }
+
+  var stripped = fixProc(buffer, password)
+
+  var type = stripped.tag
+  var data = stripped.data
+  var subtype, ndata
+  switch (type) {
+    case 'CERTIFICATE':
+      ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo
+      // falls through
+    case 'PUBLIC KEY':
+      if (!ndata) {
+        ndata = asn1.PublicKey.decode(data, 'der')
+      }
+      subtype = ndata.algorithm.algorithm.join('.')
+      switch (subtype) {
+        case '1.2.840.113549.1.1.1':
+          return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der')
+        case '1.2.840.10045.2.1':
+          ndata.subjectPrivateKey = ndata.subjectPublicKey
+          return {
+            type: 'ec',
+            data: ndata
+          }
+        case '1.2.840.10040.4.1':
+          ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der')
+          return {
+            type: 'dsa',
+            data: ndata.algorithm.params
+          }
+        default: throw new Error('unknown key id ' + subtype)
+      }
+      throw new Error('unknown key type ' + type)
+    case 'ENCRYPTED PRIVATE KEY':
+      data = asn1.EncryptedPrivateKey.decode(data, 'der')
+      data = decrypt(data, password)
+      // falls through
+    case 'PRIVATE KEY':
+      ndata = asn1.PrivateKey.decode(data, 'der')
+      subtype = ndata.algorithm.algorithm.join('.')
+      switch (subtype) {
+        case '1.2.840.113549.1.1.1':
+          return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der')
+        case '1.2.840.10045.2.1':
+          return {
+            curve: ndata.algorithm.curve,
+            privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, 'der').privateKey
+          }
+        case '1.2.840.10040.4.1':
+          ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, 'der')
+          return {
+            type: 'dsa',
+            params: ndata.algorithm.params
+          }
+        default: throw new Error('unknown key id ' + subtype)
+      }
+      throw new Error('unknown key type ' + type)
+    case 'RSA PUBLIC KEY':
+      return asn1.RSAPublicKey.decode(data, 'der')
+    case 'RSA PRIVATE KEY':
+      return asn1.RSAPrivateKey.decode(data, 'der')
+    case 'DSA PRIVATE KEY':
+      return {
+        type: 'dsa',
+        params: asn1.DSAPrivateKey.decode(data, 'der')
+      }
+    case 'EC PRIVATE KEY':
+      data = asn1.ECPrivateKey.decode(data, 'der')
+      return {
+        curve: data.parameters.value,
+        privateKey: data.privateKey
+      }
+    default: throw new Error('unknown key type ' + type)
+  }
+}
+parseKeys.signature = asn1.signature
+function decrypt (data, password) {
+  var salt = data.algorithm.decrypt.kde.kdeparams.salt
+  var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10)
+  var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')]
+  var iv = data.algorithm.decrypt.cipher.iv
+  var cipherText = data.subjectPrivateKey
+  var keylen = parseInt(algo.split('-')[1], 10) / 8
+  var key = compat.pbkdf2Sync(password, salt, iters, keylen)
+  var cipher = ciphers.createDecipheriv(algo, key, iv)
+  var out = []
+  out.push(cipher.update(cipherText))
+  out.push(cipher.final())
+  return Buffer.concat(out)
+}
+
+}).call(this,require("buffer").Buffer)
+},{"./aesid.json":114,"./asn1":115,"./fixProc":117,"browserify-aes":29,"buffer":55,"pbkdf2":119}],119:[function(require,module,exports){
+exports.pbkdf2 = require('./lib/async')
+exports.pbkdf2Sync = require('./lib/sync')
+
+},{"./lib/async":120,"./lib/sync":123}],120:[function(require,module,exports){
+(function (process,global){
+var checkParameters = require('./precondition')
+var defaultEncoding = require('./default-encoding')
+var sync = require('./sync')
+var Buffer = require('safe-buffer').Buffer
+
+var ZERO_BUF
+var subtle = global.crypto && global.crypto.subtle
+var toBrowser = {
+  'sha': 'SHA-1',
+  'sha-1': 'SHA-1',
+  'sha1': 'SHA-1',
+  'sha256': 'SHA-256',
+  'sha-256': 'SHA-256',
+  'sha384': 'SHA-384',
+  'sha-384': 'SHA-384',
+  'sha-512': 'SHA-512',
+  'sha512': 'SHA-512'
+}
+var checks = []
+function checkNative (algo) {
+  if (global.process && !global.process.browser) {
+    return Promise.resolve(false)
+  }
+  if (!subtle || !subtle.importKey || !subtle.deriveBits) {
+    return Promise.resolve(false)
+  }
+  if (checks[algo] !== undefined) {
+    return checks[algo]
+  }
+  ZERO_BUF = ZERO_BUF || Buffer.alloc(8)
+  var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo)
+    .then(function () {
+      return true
+    }).catch(function () {
+      return false
+    })
+  checks[algo] = prom
+  return prom
+}
+
+function browserPbkdf2 (password, salt, iterations, length, algo) {
+  return subtle.importKey(
+    'raw', password, {name: 'PBKDF2'}, false, ['deriveBits']
+  ).then(function (key) {
+    return subtle.deriveBits({
+      name: 'PBKDF2',
+      salt: salt,
+      iterations: iterations,
+      hash: {
+        name: algo
+      }
+    }, key, length << 3)
+  }).then(function (res) {
+    return Buffer.from(res)
+  })
+}
+
+function resolvePromise (promise, callback) {
+  promise.then(function (out) {
+    process.nextTick(function () {
+      callback(null, out)
+    })
+  }, function (e) {
+    process.nextTick(function () {
+      callback(e)
+    })
+  })
+}
+module.exports = function (password, salt, iterations, keylen, digest, callback) {
+  if (typeof digest === 'function') {
+    callback = digest
+    digest = undefined
+  }
+
+  digest = digest || 'sha1'
+  var algo = toBrowser[digest.toLowerCase()]
+
+  if (!algo || typeof global.Promise !== 'function') {
+    return process.nextTick(function () {
+      var out
+      try {
+        out = sync(password, salt, iterations, keylen, digest)
+      } catch (e) {
+        return callback(e)
+      }
+      callback(null, out)
+    })
+  }
+
+  checkParameters(password, salt, iterations, keylen)
+  if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2')
+  if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding)
+  if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding)
+
+  resolvePromise(checkNative(algo).then(function (resp) {
+    if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo)
+
+    return sync(password, salt, iterations, keylen, digest)
+  }), callback)
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./default-encoding":121,"./precondition":122,"./sync":123,"_process":125,"safe-buffer":148}],121:[function(require,module,exports){
+(function (process){
+var defaultEncoding
+/* istanbul ignore next */
+if (process.browser) {
+  defaultEncoding = 'utf-8'
+} else {
+  var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10)
+
+  defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary'
+}
+module.exports = defaultEncoding
+
+}).call(this,require('_process'))
+},{"_process":125}],122:[function(require,module,exports){
+(function (Buffer){
+var MAX_ALLOC = Math.pow(2, 30) - 1 // default in iojs
+
+function checkBuffer (buf, name) {
+  if (typeof buf !== 'string' && !Buffer.isBuffer(buf)) {
+    throw new TypeError(name + ' must be a buffer or string')
+  }
+}
+
+module.exports = function (password, salt, iterations, keylen) {
+  checkBuffer(password, 'Password')
+  checkBuffer(salt, 'Salt')
+
+  if (typeof iterations !== 'number') {
+    throw new TypeError('Iterations not a number')
+  }
+
+  if (iterations < 0) {
+    throw new TypeError('Bad iterations')
+  }
+
+  if (typeof keylen !== 'number') {
+    throw new TypeError('Key length not a number')
+  }
+
+  if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { /* eslint no-self-compare: 0 */
+    throw new TypeError('Bad key length')
+  }
+}
+
+}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
+},{"../../is-buffer/index.js":108}],123:[function(require,module,exports){
+var md5 = require('create-hash/md5')
+var rmd160 = require('ripemd160')
+var sha = require('sha.js')
+
+var checkParameters = require('./precondition')
+var defaultEncoding = require('./default-encoding')
+var Buffer = require('safe-buffer').Buffer
+var ZEROS = Buffer.alloc(128)
+var sizes = {
+  md5: 16,
+  sha1: 20,
+  sha224: 28,
+  sha256: 32,
+  sha384: 48,
+  sha512: 64,
+  rmd160: 20,
+  ripemd160: 20
+}
+
+function Hmac (alg, key, saltLen) {
+  var hash = getDigest(alg)
+  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64
+
+  if (key.length > blocksize) {
+    key = hash(key)
+  } else if (key.length < blocksize) {
+    key = Buffer.concat([key, ZEROS], blocksize)
+  }
+
+  var ipad = Buffer.allocUnsafe(blocksize + sizes[alg])
+  var opad = Buffer.allocUnsafe(blocksize + sizes[alg])
+  for (var i = 0; i < blocksize; i++) {
+    ipad[i] = key[i] ^ 0x36
+    opad[i] = key[i] ^ 0x5C
+  }
+
+  var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4)
+  ipad.copy(ipad1, 0, 0, blocksize)
+  this.ipad1 = ipad1
+  this.ipad2 = ipad
+  this.opad = opad
+  this.alg = alg
+  this.blocksize = blocksize
+  this.hash = hash
+  this.size = sizes[alg]
+}
+
+Hmac.prototype.run = function (data, ipad) {
+  data.copy(ipad, this.blocksize)
+  var h = this.hash(ipad)
+  h.copy(this.opad, this.blocksize)
+  return this.hash(this.opad)
+}
+
+function getDigest (alg) {
+  function shaFunc (data) {
+    return sha(alg).update(data).digest()
+  }
+
+  if (alg === 'rmd160' || alg === 'ripemd160') return rmd160
+  if (alg === 'md5') return md5
+  return shaFunc
+}
+
+function pbkdf2 (password, salt, iterations, keylen, digest) {
+  checkParameters(password, salt, iterations, keylen)
+
+  if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding)
+  if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding)
+
+  digest = digest || 'sha1'
+
+  var hmac = new Hmac(digest, password, salt.length)
+
+  var DK = Buffer.allocUnsafe(keylen)
+  var block1 = Buffer.allocUnsafe(salt.length + 4)
+  salt.copy(block1, 0, 0, salt.length)
+
+  var destPos = 0
+  var hLen = sizes[digest]
+  var l = Math.ceil(keylen / hLen)
+
+  for (var i = 1; i <= l; i++) {
+    block1.writeUInt32BE(i, salt.length)
+
+    var T = hmac.run(block1, hmac.ipad1)
+    var U = T
+
+    for (var j = 1; j < iterations; j++) {
+      U = hmac.run(U, hmac.ipad2)
+      for (var k = 0; k < hLen; k++) T[k] ^= U[k]
+    }
+
+    T.copy(DK, destPos)
+    destPos += hLen
+  }
+
+  return DK
+}
+
+module.exports = pbkdf2
+
+},{"./default-encoding":121,"./precondition":122,"create-hash/md5":60,"ripemd160":147,"safe-buffer":148,"sha.js":150}],124:[function(require,module,exports){
+(function (process){
+'use strict';
+
+if (!process.version ||
+    process.version.indexOf('v0.') === 0 ||
+    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+  module.exports = { nextTick: nextTick };
+} else {
+  module.exports = process
+}
+
+function nextTick(fn, arg1, arg2, arg3) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('"callback" argument must be a function');
+  }
+  var len = arguments.length;
+  var args, i;
+  switch (len) {
+  case 0:
+  case 1:
+    return process.nextTick(fn);
+  case 2:
+    return process.nextTick(function afterTickOne() {
+      fn.call(null, arg1);
+    });
+  case 3:
+    return process.nextTick(function afterTickTwo() {
+      fn.call(null, arg1, arg2);
+    });
+  case 4:
+    return process.nextTick(function afterTickThree() {
+      fn.call(null, arg1, arg2, arg3);
+    });
+  default:
+    args = new Array(len - 1);
+    i = 0;
+    while (i < args.length) {
+      args[i++] = arguments[i];
+    }
+    return process.nextTick(function afterTick() {
+      fn.apply(null, args);
+    });
+  }
+}
+
+
+}).call(this,require('_process'))
+},{"_process":125}],125:[function(require,module,exports){
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+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; };
+
+},{}],126:[function(require,module,exports){
+exports.publicEncrypt = require('./publicEncrypt');
+exports.privateDecrypt = require('./privateDecrypt');
+
+exports.privateEncrypt = function privateEncrypt(key, buf) {
+  return exports.publicEncrypt(key, buf, true);
+};
+
+exports.publicDecrypt = function publicDecrypt(key, buf) {
+  return exports.privateDecrypt(key, buf, true);
+};
+},{"./privateDecrypt":128,"./publicEncrypt":129}],127:[function(require,module,exports){
+(function (Buffer){
+var createHash = require('create-hash');
+module.exports = function (seed, len) {
+  var t = new Buffer('');
+  var  i = 0, c;
+  while (t.length < len) {
+    c = i2ops(i++);
+    t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()]);
+  }
+  return t.slice(0, len);
+};
+
+function i2ops(c) {
+  var out = new Buffer(4);
+  out.writeUInt32BE(c,0);
+  return out;
+}
+}).call(this,require("buffer").Buffer)
+},{"buffer":55,"create-hash":59}],128:[function(require,module,exports){
+(function (Buffer){
+var parseKeys = require('parse-asn1');
+var mgf = require('./mgf');
+var xor = require('./xor');
+var bn = require('bn.js');
+var crt = require('browserify-rsa');
+var createHash = require('create-hash');
+var withPublic = require('./withPublic');
+module.exports = function privateDecrypt(private_key, enc, reverse) {
+  var padding;
+  if (private_key.padding) {
+    padding = private_key.padding;
+  } else if (reverse) {
+    padding = 1;
+  } else {
+    padding = 4;
+  }
+  
+  var key = parseKeys(private_key);
+  var k = key.modulus.byteLength();
+  if (enc.length > k || new bn(enc).cmp(key.modulus) >= 0) {
+    throw new Error('decryption error');
+  }
+  var msg;
+  if (reverse) {
+    msg = withPublic(new bn(enc), key);
+  } else {
+    msg = crt(enc, key);
+  }
+  var zBuffer = new Buffer(k - msg.length);
+  zBuffer.fill(0);
+  msg = Buffer.concat([zBuffer, msg], k);
+  if (padding === 4) {
+    return oaep(key, msg);
+  } else if (padding === 1) {
+    return pkcs1(key, msg, reverse);
+  } else if (padding === 3) {
+    return msg;
+  } else {
+    throw new Error('unknown padding');
+  }
+};
+
+function oaep(key, msg){
+  var n = key.modulus;
+  var k = key.modulus.byteLength();
+  var mLen = msg.length;
+  var iHash = createHash('sha1').update(new Buffer('')).digest();
+  var hLen = iHash.length;
+  var hLen2 = 2 * hLen;
+  if (msg[0] !== 0) {
+    throw new Error('decryption error');
+  }
+  var maskedSeed = msg.slice(1, hLen + 1);
+  var maskedDb =  msg.slice(hLen + 1);
+  var seed = xor(maskedSeed, mgf(maskedDb, hLen));
+  var db = xor(maskedDb, mgf(seed, k - hLen - 1));
+  if (compare(iHash, db.slice(0, hLen))) {
+    throw new Error('decryption error');
+  }
+  var i = hLen;
+  while (db[i] === 0) {
+    i++;
+  }
+  if (db[i++] !== 1) {
+    throw new Error('decryption error');
+  }
+  return db.slice(i);
+}
+
+function pkcs1(key, msg, reverse){
+  var p1 = msg.slice(0, 2);
+  var i = 2;
+  var status = 0;
+  while (msg[i++] !== 0) {
+    if (i >= msg.length) {
+      status++;
+      break;
+    }
+  }
+  var ps = msg.slice(2, i - 1);
+  var p2 = msg.slice(i - 1, i);
+
+  if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)){
+    status++;
+  }
+  if (ps.length < 8) {
+    status++;
+  }
+  if (status) {
+    throw new Error('decryption error');
+  }
+  return  msg.slice(i);
+}
+function compare(a, b){
+  a = new Buffer(a);
+  b = new Buffer(b);
+  var dif = 0;
+  var len = a.length;
+  if (a.length !== b.length) {
+    dif++;
+    len = Math.min(a.length, b.length);
+  }
+  var i = -1;
+  while (++i < len) {
+    dif += (a[i] ^ b[i]);
+  }
+  return dif;
+}
+}).call(this,require("buffer").Buffer)
+},{"./mgf":127,"./withPublic":130,"./xor":131,"bn.js":24,"browserify-rsa":47,"buffer":55,"create-hash":59,"parse-asn1":118}],129:[function(require,module,exports){
+(function (Buffer){
+var parseKeys = require('parse-asn1');
+var randomBytes = require('randombytes');
+var createHash = require('create-hash');
+var mgf = require('./mgf');
+var xor = require('./xor');
+var bn = require('bn.js');
+var withPublic = require('./withPublic');
+var crt = require('browserify-rsa');
+
+var constants = {
+  RSA_PKCS1_OAEP_PADDING: 4,
+  RSA_PKCS1_PADDIN: 1,
+  RSA_NO_PADDING: 3
+};
+
+module.exports = function publicEncrypt(public_key, msg, reverse) {
+  var padding;
+  if (public_key.padding) {
+    padding = public_key.padding;
+  } else if (reverse) {
+    padding = 1;
+  } else {
+    padding = 4;
+  }
+  var key = parseKeys(public_key);
+  var paddedMsg;
+  if (padding === 4) {
+    paddedMsg = oaep(key, msg);
+  } else if (padding === 1) {
+    paddedMsg = pkcs1(key, msg, reverse);
+  } else if (padding === 3) {
+    paddedMsg = new bn(msg);
+    if (paddedMsg.cmp(key.modulus) >= 0) {
+      throw new Error('data too long for modulus');
+    }
+  } else {
+    throw new Error('unknown padding');
+  }
+  if (reverse) {
+    return crt(paddedMsg, key);
+  } else {
+    return withPublic(paddedMsg, key);
+  }
+};
+
+function oaep(key, msg){
+  var k = key.modulus.byteLength();
+  var mLen = msg.length;
+  var iHash = createHash('sha1').update(new Buffer('')).digest();
+  var hLen = iHash.length;
+  var hLen2 = 2 * hLen;
+  if (mLen > k - hLen2 - 2) {
+    throw new Error('message too long');
+  }
+  var ps = new Buffer(k - mLen - hLen2 - 2);
+  ps.fill(0);
+  var dblen = k - hLen - 1;
+  var seed = randomBytes(hLen);
+  var maskedDb = xor(Buffer.concat([iHash, ps, new Buffer([1]), msg], dblen), mgf(seed, dblen));
+  var maskedSeed = xor(seed, mgf(maskedDb, hLen));
+  return new bn(Buffer.concat([new Buffer([0]), maskedSeed, maskedDb], k));
+}
+function pkcs1(key, msg, reverse){
+  var mLen = msg.length;
+  var k = key.modulus.byteLength();
+  if (mLen > k - 11) {
+    throw new Error('message too long');
+  }
+  var ps;
+  if (reverse) {
+    ps = new Buffer(k - mLen - 3);
+    ps.fill(0xff);
+  } else {
+    ps = nonZero(k - mLen - 3);
+  }
+  return new bn(Buffer.concat([new Buffer([0, reverse?1:2]), ps, new Buffer([0]), msg], k));
+}
+function nonZero(len, crypto) {
+  var out = new Buffer(len);
+  var i = 0;
+  var cache = randomBytes(len*2);
+  var cur = 0;
+  var num;
+  while (i < len) {
+    if (cur === cache.length) {
+      cache = randomBytes(len*2);
+      cur = 0;
+    }
+    num = cache[cur++];
+    if (num) {
+      out[i++] = num;
+    }
+  }
+  return out;
+}
+}).call(this,require("buffer").Buffer)
+},{"./mgf":127,"./withPublic":130,"./xor":131,"bn.js":24,"browserify-rsa":47,"buffer":55,"create-hash":59,"parse-asn1":118,"randombytes":132}],130:[function(require,module,exports){
+(function (Buffer){
+var bn = require('bn.js');
+function withPublic(paddedMsg, key) {
+  return new Buffer(paddedMsg
+    .toRed(bn.mont(key.modulus))
+    .redPow(new bn(key.publicExponent))
+    .fromRed()
+    .toArray());
+}
+
+module.exports = withPublic;
+}).call(this,require("buffer").Buffer)
+},{"bn.js":24,"buffer":55}],131:[function(require,module,exports){
+module.exports = function xor(a, b) {
+  var len = a.length;
+  var i = -1;
+  while (++i < len) {
+    a[i] ^= b[i];
+  }
+  return a
+};
+},{}],132:[function(require,module,exports){
+arguments[4][6][0].apply(exports,arguments)
+},{"_process":125,"dup":6,"safe-buffer":148}],133:[function(require,module,exports){
+(function (process,global){
+'use strict'
+
+function oldBrowser () {
+  throw new Error('secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11')
+}
+var safeBuffer = require('safe-buffer')
+var randombytes = require('randombytes')
+var Buffer = safeBuffer.Buffer
+var kBufferMaxLength = safeBuffer.kMaxLength
+var crypto = global.crypto || global.msCrypto
+var kMaxUint32 = Math.pow(2, 32) - 1
+function assertOffset (offset, length) {
+  if (typeof offset !== 'number' || offset !== offset) { // eslint-disable-line no-self-compare
+    throw new TypeError('offset must be a number')
+  }
+
+  if (offset > kMaxUint32 || offset < 0) {
+    throw new TypeError('offset must be a uint32')
+  }
+
+  if (offset > kBufferMaxLength || offset > length) {
+    throw new RangeError('offset out of range')
+  }
+}
+
+function assertSize (size, offset, length) {
+  if (typeof size !== 'number' || size !== size) { // eslint-disable-line no-self-compare
+    throw new TypeError('size must be a number')
+  }
+
+  if (size > kMaxUint32 || size < 0) {
+    throw new TypeError('size must be a uint32')
+  }
+
+  if (size + offset > length || size > kBufferMaxLength) {
+    throw new RangeError('buffer too small')
+  }
+}
+if ((crypto && crypto.getRandomValues) || !process.browser) {
+  exports.randomFill = randomFill
+  exports.randomFillSync = randomFillSync
+} else {
+  exports.randomFill = oldBrowser
+  exports.randomFillSync = oldBrowser
+}
+function randomFill (buf, offset, size, cb) {
+  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
+    throw new TypeError('"buf" argument must be a Buffer or Uint8Array')
+  }
+
+  if (typeof offset === 'function') {
+    cb = offset
+    offset = 0
+    size = buf.length
+  } else if (typeof size === 'function') {
+    cb = size
+    size = buf.length - offset
+  } else if (typeof cb !== 'function') {
+    throw new TypeError('"cb" argument must be a function')
+  }
+  assertOffset(offset, buf.length)
+  assertSize(size, offset, buf.length)
+  return actualFill(buf, offset, size, cb)
+}
+
+function actualFill (buf, offset, size, cb) {
+  if (process.browser) {
+    var ourBuf = buf.buffer
+    var uint = new Uint8Array(ourBuf, offset, size)
+    crypto.getRandomValues(uint)
+    if (cb) {
+      process.nextTick(function () {
+        cb(null, buf)
+      })
+      return
+    }
+    return buf
+  }
+  if (cb) {
+    randombytes(size, function (err, bytes) {
+      if (err) {
+        return cb(err)
+      }
+      bytes.copy(buf, offset)
+      cb(null, buf)
+    })
+    return
+  }
+  var bytes = randombytes(size)
+  bytes.copy(buf, offset)
+  return buf
+}
+function randomFillSync (buf, offset, size) {
+  if (typeof offset === 'undefined') {
+    offset = 0
+  }
+  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
+    throw new TypeError('"buf" argument must be a Buffer or Uint8Array')
+  }
+
+  assertOffset(offset, buf.length)
+
+  if (size === undefined) size = buf.length - offset
+
+  assertSize(size, offset, buf.length)
+
+  return actualFill(buf, offset, size)
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"_process":125,"randombytes":132,"safe-buffer":148}],134:[function(require,module,exports){
+module.exports = require('./lib/_stream_duplex.js');
+
+},{"./lib/_stream_duplex.js":135}],135:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+'use strict';
+
+/*<replacement>*/
+
+var pna = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) {
+    keys.push(key);
+  }return keys;
+};
+/*</replacement>*/
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+{
+  // avoid scope creep, the keys array can then be collected
+  var keys = objectKeys(Writable.prototype);
+  for (var v = 0; v < keys.length; v++) {
+    var method = keys[v];
+    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+  }
+}
+
+function Duplex(options) {
+  if (!(this instanceof Duplex)) return new Duplex(options);
+
+  Readable.call(this, options);
+  Writable.call(this, options);
+
+  if (options && options.readable === false) this.readable = false;
+
+  if (options && options.writable === false) this.writable = false;
+
+  this.allowHalfOpen = true;
+  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+
+  this.once('end', onend);
+}
+
+Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function () {
+    return this._writableState.highWaterMark;
+  }
+});
+
+// the no-half-open enforcer
+function onend() {
+  // if we allow half-open state, or if the writable side ended,
+  // then we're ok.
+  if (this.allowHalfOpen || this._writableState.ended) return;
+
+  // no more data can be written.
+  // But allow more writes to happen in this tick.
+  pna.nextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+  self.end();
+}
+
+Object.defineProperty(Duplex.prototype, 'destroyed', {
+  get: function () {
+    if (this._readableState === undefined || this._writableState === undefined) {
+      return false;
+    }
+    return this._readableState.destroyed && this._writableState.destroyed;
+  },
+  set: function (value) {
+    // we ignore the value if the stream
+    // has not been initialized yet
+    if (this._readableState === undefined || this._writableState === undefined) {
+      return;
+    }
+
+    // backward compatibility, the user is explicitly
+    // managing destroyed
+    this._readableState.destroyed = value;
+    this._writableState.destroyed = value;
+  }
+});
+
+Duplex.prototype._destroy = function (err, cb) {
+  this.push(null);
+  this.end();
+
+  pna.nextTick(cb, err);
+};
+},{"./_stream_readable":137,"./_stream_writable":139,"core-util-is":57,"inherits":107,"process-nextick-args":124}],136:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+'use strict';
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+  if (!(this instanceof PassThrough)) return new PassThrough(options);
+
+  Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+  cb(null, chunk);
+};
+},{"./_stream_transform":138,"core-util-is":57,"inherits":107}],137:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+/*<replacement>*/
+
+var pna = require('process-nextick-args');
+/*</replacement>*/
+
+module.exports = Readable;
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+/*<replacement>*/
+var Duplex;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+/*<replacement>*/
+var EE = require('events').EventEmitter;
+
+var EElistenerCount = function (emitter, type) {
+  return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream = require('./internal/streams/stream');
+/*</replacement>*/
+
+/*<replacement>*/
+
+var Buffer = require('safe-buffer').Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+  return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+
+/*</replacement>*/
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+/*<replacement>*/
+var debugUtil = require('util');
+var debug = void 0;
+if (debugUtil && debugUtil.debuglog) {
+  debug = debugUtil.debuglog('stream');
+} else {
+  debug = function () {};
+}
+/*</replacement>*/
+
+var BufferList = require('./internal/streams/BufferList');
+var destroyImpl = require('./internal/streams/destroy');
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
+
+function prependListener(emitter, event, fn) {
+  // Sadly this is not cacheable as some libraries bundle their own
+  // event emitter implementation with them.
+  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
+
+  // This is a hack to make sure that our error handler is attached before any
+  // userland ones.  NEVER DO THIS. This is here only because this code needs
+  // to continue to work with older versions of Node.js that do not include
+  // the prependListener() method. The goal is to eventually remove this hack.
+  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
+}
+
+function ReadableState(options, stream) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  options = options || {};
+
+  // Duplex streams are both readable and writable, but share
+  // the same options object.
+  // However, some cases require setting options to different
+  // values for the readable and the writable sides of the duplex stream.
+  // These options can be provided separately as readableXXX and writableXXX.
+  var isDuplex = stream instanceof Duplex;
+
+  // object stream flag. Used to make read(n) ignore n and to
+  // make all the buffer merging and length checks go away
+  this.objectMode = !!options.objectMode;
+
+  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+
+  // the point at which it stops calling _read() to fill the buffer
+  // Note: 0 is a valid value, means "don't call _read preemptively ever"
+  var hwm = options.highWaterMark;
+  var readableHwm = options.readableHighWaterMark;
+  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+
+  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
+
+  // cast to ints.
+  this.highWaterMark = Math.floor(this.highWaterMark);
+
+  // A linked list is used to store data chunks instead of an array because the
+  // linked list can remove elements from the beginning faster than
+  // array.shift()
+  this.buffer = new BufferList();
+  this.length = 0;
+  this.pipes = null;
+  this.pipesCount = 0;
+  this.flowing = null;
+  this.ended = false;
+  this.endEmitted = false;
+  this.reading = false;
+
+  // a flag to be able to tell if the event 'readable'/'data' is emitted
+  // immediately, or on a later tick.  We set this to true at first, because
+  // any actions that shouldn't happen until "later" should generally also
+  // not happen before the first read call.
+  this.sync = true;
+
+  // whenever we return null, then we set a flag to say
+  // that we're awaiting a 'readable' event emission.
+  this.needReadable = false;
+  this.emittedReadable = false;
+  this.readableListening = false;
+  this.resumeScheduled = false;
+
+  // has it been destroyed
+  this.destroyed = false;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // the number of writers that are awaiting a drain event in .pipe()s
+  this.awaitDrain = 0;
+
+  // if true, a maybeReadMore has been scheduled
+  this.readingMore = false;
+
+  this.decoder = null;
+  this.encoding = null;
+  if (options.encoding) {
+    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+    this.decoder = new StringDecoder(options.encoding);
+    this.encoding = options.encoding;
+  }
+}
+
+function Readable(options) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  if (!(this instanceof Readable)) return new Readable(options);
+
+  this._readableState = new ReadableState(options, this);
+
+  // legacy
+  this.readable = true;
+
+  if (options) {
+    if (typeof options.read === 'function') this._read = options.read;
+
+    if (typeof options.destroy === 'function') this._destroy = options.destroy;
+  }
+
+  Stream.call(this);
+}
+
+Object.defineProperty(Readable.prototype, 'destroyed', {
+  get: function () {
+    if (this._readableState === undefined) {
+      return false;
+    }
+    return this._readableState.destroyed;
+  },
+  set: function (value) {
+    // we ignore the value if the stream
+    // has not been initialized yet
+    if (!this._readableState) {
+      return;
+    }
+
+    // backward compatibility, the user is explicitly
+    // managing destroyed
+    this._readableState.destroyed = value;
+  }
+});
+
+Readable.prototype.destroy = destroyImpl.destroy;
+Readable.prototype._undestroy = destroyImpl.undestroy;
+Readable.prototype._destroy = function (err, cb) {
+  this.push(null);
+  cb(err);
+};
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function (chunk, encoding) {
+  var state = this._readableState;
+  var skipChunkCheck;
+
+  if (!state.objectMode) {
+    if (typeof chunk === 'string') {
+      encoding = encoding || state.defaultEncoding;
+      if (encoding !== state.encoding) {
+        chunk = Buffer.from(chunk, encoding);
+        encoding = '';
+      }
+      skipChunkCheck = true;
+    }
+  } else {
+    skipChunkCheck = true;
+  }
+
+  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function (chunk) {
+  return readableAddChunk(this, chunk, null, true, false);
+};
+
+function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+  var state = stream._readableState;
+  if (chunk === null) {
+    state.reading = false;
+    onEofChunk(stream, state);
+  } else {
+    var er;
+    if (!skipChunkCheck) er = chunkInvalid(state, chunk);
+    if (er) {
+      stream.emit('error', er);
+    } else if (state.objectMode || chunk && chunk.length > 0) {
+      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
+        chunk = _uint8ArrayToBuffer(chunk);
+      }
+
+      if (addToFront) {
+        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
+      } else if (state.ended) {
+        stream.emit('error', new Error('stream.push() after EOF'));
+      } else {
+        state.reading = false;
+        if (state.decoder && !encoding) {
+          chunk = state.decoder.write(chunk);
+          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
+        } else {
+          addChunk(stream, state, chunk, false);
+        }
+      }
+    } else if (!addToFront) {
+      state.reading = false;
+    }
+  }
+
+  return needMoreData(state);
+}
+
+function addChunk(stream, state, chunk, addToFront) {
+  if (state.flowing && state.length === 0 && !state.sync) {
+    stream.emit('data', chunk);
+    stream.read(0);
+  } else {
+    // update the buffer info.
+    state.length += state.objectMode ? 1 : chunk.length;
+    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
+
+    if (state.needReadable) emitReadable(stream);
+  }
+  maybeReadMore(stream, state);
+}
+
+function chunkInvalid(state, chunk) {
+  var er;
+  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  return er;
+}
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes.  This is to work around cases where hwm=0,
+// such as the repl.  Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+}
+
+Readable.prototype.isPaused = function () {
+  return this._readableState.flowing === false;
+};
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function (enc) {
+  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+  this._readableState.decoder = new StringDecoder(enc);
+  this._readableState.encoding = enc;
+  return this;
+};
+
+// Don't raise the hwm > 8MB
+var MAX_HWM = 0x800000;
+function computeNewHighWaterMark(n) {
+  if (n >= MAX_HWM) {
+    n = MAX_HWM;
+  } else {
+    // Get the next highest power of 2 to prevent increasing hwm excessively in
+    // tiny amounts
+    n--;
+    n |= n >>> 1;
+    n |= n >>> 2;
+    n |= n >>> 4;
+    n |= n >>> 8;
+    n |= n >>> 16;
+    n++;
+  }
+  return n;
+}
+
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function howMuchToRead(n, state) {
+  if (n <= 0 || state.length === 0 && state.ended) return 0;
+  if (state.objectMode) return 1;
+  if (n !== n) {
+    // Only flow one buffer at a time
+    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
+  }
+  // If we're asking for more than the current hwm, then raise the hwm.
+  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+  if (n <= state.length) return n;
+  // Don't have enough
+  if (!state.ended) {
+    state.needReadable = true;
+    return 0;
+  }
+  return state.length;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function (n) {
+  debug('read', n);
+  n = parseInt(n, 10);
+  var state = this._readableState;
+  var nOrig = n;
+
+  if (n !== 0) state.emittedReadable = false;
+
+  // if we're doing read(0) to trigger a readable event, but we
+  // already have a bunch of data in the buffer, then just trigger
+  // the 'readable' event and move on.
+  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
+    debug('read: emitReadable', state.length, state.ended);
+    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
+    return null;
+  }
+
+  n = howMuchToRead(n, state);
+
+  // if we've ended, and we're now clear, then finish it up.
+  if (n === 0 && state.ended) {
+    if (state.length === 0) endReadable(this);
+    return null;
+  }
+
+  // All the actual chunk generation logic needs to be
+  // *below* the call to _read.  The reason is that in certain
+  // synthetic stream cases, such as passthrough streams, _read
+  // may be a completely synchronous operation which may change
+  // the state of the read buffer, providing enough data when
+  // before there was *not* enough.
+  //
+  // So, the steps are:
+  // 1. Figure out what the state of things will be after we do
+  // a read from the buffer.
+  //
+  // 2. If that resulting state will trigger a _read, then call _read.
+  // Note that this may be asynchronous, or synchronous.  Yes, it is
+  // deeply ugly to write APIs this way, but that still doesn't mean
+  // that the Readable class should behave improperly, as streams are
+  // designed to be sync/async agnostic.
+  // Take note if the _read call is sync or async (ie, if the read call
+  // has returned yet), so that we know whether or not it's safe to emit
+  // 'readable' etc.
+  //
+  // 3. Actually pull the requested chunks out of the buffer and return.
+
+  // if we need a readable event, then we need to do some reading.
+  var doRead = state.needReadable;
+  debug('need readable', doRead);
+
+  // if we currently have less than the highWaterMark, then also read some
+  if (state.length === 0 || state.length - n < state.highWaterMark) {
+    doRead = true;
+    debug('length less than watermark', doRead);
+  }
+
+  // however, if we've ended, then there's no point, and if we're already
+  // reading, then it's unnecessary.
+  if (state.ended || state.reading) {
+    doRead = false;
+    debug('reading or ended', doRead);
+  } else if (doRead) {
+    debug('do read');
+    state.reading = true;
+    state.sync = true;
+    // if the length is currently zero, then we *need* a readable event.
+    if (state.length === 0) state.needReadable = true;
+    // call internal read method
+    this._read(state.highWaterMark);
+    state.sync = false;
+    // If _read pushed data synchronously, then `reading` will be false,
+    // and we need to re-evaluate how much data we can return to the user.
+    if (!state.reading) n = howMuchToRead(nOrig, state);
+  }
+
+  var ret;
+  if (n > 0) ret = fromList(n, state);else ret = null;
+
+  if (ret === null) {
+    state.needReadable = true;
+    n = 0;
+  } else {
+    state.length -= n;
+  }
+
+  if (state.length === 0) {
+    // If we have nothing in the buffer, then we want to know
+    // as soon as we *do* get something into the buffer.
+    if (!state.ended) state.needReadable = true;
+
+    // If we tried to read() past the EOF, then emit end on the next tick.
+    if (nOrig !== n && state.ended) endReadable(this);
+  }
+
+  if (ret !== null) this.emit('data', ret);
+
+  return ret;
+};
+
+function onEofChunk(stream, state) {
+  if (state.ended) return;
+  if (state.decoder) {
+    var chunk = state.decoder.end();
+    if (chunk && chunk.length) {
+      state.buffer.push(chunk);
+      state.length += state.objectMode ? 1 : chunk.length;
+    }
+  }
+  state.ended = true;
+
+  // emit 'readable' now to make sure it gets picked up.
+  emitReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow.  This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+  var state = stream._readableState;
+  state.needReadable = false;
+  if (!state.emittedReadable) {
+    debug('emitReadable', state.flowing);
+    state.emittedReadable = true;
+    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
+  }
+}
+
+function emitReadable_(stream) {
+  debug('emit readable');
+  stream.emit('readable');
+  flow(stream);
+}
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data.  that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+  if (!state.readingMore) {
+    state.readingMore = true;
+    pna.nextTick(maybeReadMore_, stream, state);
+  }
+}
+
+function maybeReadMore_(stream, state) {
+  var len = state.length;
+  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
+    debug('maybeReadMore read 0');
+    stream.read(0);
+    if (len === state.length)
+      // didn't get any data, stop spinning.
+      break;else len = state.length;
+  }
+  state.readingMore = false;
+}
+
+// abstract method.  to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function (n) {
+  this.emit('error', new Error('_read() is not implemented'));
+};
+
+Readable.prototype.pipe = function (dest, pipeOpts) {
+  var src = this;
+  var state = this._readableState;
+
+  switch (state.pipesCount) {
+    case 0:
+      state.pipes = dest;
+      break;
+    case 1:
+      state.pipes = [state.pipes, dest];
+      break;
+    default:
+      state.pipes.push(dest);
+      break;
+  }
+  state.pipesCount += 1;
+  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
+
+  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+
+  var endFn = doEnd ? onend : unpipe;
+  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
+
+  dest.on('unpipe', onunpipe);
+  function onunpipe(readable, unpipeInfo) {
+    debug('onunpipe');
+    if (readable === src) {
+      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+        unpipeInfo.hasUnpiped = true;
+        cleanup();
+      }
+    }
+  }
+
+  function onend() {
+    debug('onend');
+    dest.end();
+  }
+
+  // when the dest drains, it reduces the awaitDrain counter
+  // on the source.  This would be more elegant with a .once()
+  // handler in flow(), but adding and removing repeatedly is
+  // too slow.
+  var ondrain = pipeOnDrain(src);
+  dest.on('drain', ondrain);
+
+  var cleanedUp = false;
+  function cleanup() {
+    debug('cleanup');
+    // cleanup event handlers once the pipe is broken
+    dest.removeListener('close', onclose);
+    dest.removeListener('finish', onfinish);
+    dest.removeListener('drain', ondrain);
+    dest.removeListener('error', onerror);
+    dest.removeListener('unpipe', onunpipe);
+    src.removeListener('end', onend);
+    src.removeListener('end', unpipe);
+    src.removeListener('data', ondata);
+
+    cleanedUp = true;
+
+    // if the reader is waiting for a drain event from this
+    // specific writer, then it would cause it to never start
+    // flowing again.
+    // So, if this is awaiting a drain, then we just call it now.
+    // If we don't know, then assume that we are waiting for one.
+    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+  }
+
+  // If the user pushes more data while we're writing to dest then we'll end up
+  // in ondata again. However, we only want to increase awaitDrain once because
+  // dest will only emit one 'drain' event for the multiple writes.
+  // => Introduce a guard on increasing awaitDrain.
+  var increasedAwaitDrain = false;
+  src.on('data', ondata);
+  function ondata(chunk) {
+    debug('ondata');
+    increasedAwaitDrain = false;
+    var ret = dest.write(chunk);
+    if (false === ret && !increasedAwaitDrain) {
+      // If the user unpiped during `dest.write()`, it is possible
+      // to get stuck in a permanently paused state if that write
+      // also returned false.
+      // => Check whether `dest` is still a piping destination.
+      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+        debug('false write response, pause', src._readableState.awaitDrain);
+        src._readableState.awaitDrain++;
+        increasedAwaitDrain = true;
+      }
+      src.pause();
+    }
+  }
+
+  // if the dest has an error, then stop piping into it.
+  // however, don't suppress the throwing behavior for this.
+  function onerror(er) {
+    debug('onerror', er);
+    unpipe();
+    dest.removeListener('error', onerror);
+    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+  }
+
+  // Make sure our error handler is attached before userland ones.
+  prependListener(dest, 'error', onerror);
+
+  // Both close and finish should trigger unpipe, but only once.
+  function onclose() {
+    dest.removeListener('finish', onfinish);
+    unpipe();
+  }
+  dest.once('close', onclose);
+  function onfinish() {
+    debug('onfinish');
+    dest.removeListener('close', onclose);
+    unpipe();
+  }
+  dest.once('finish', onfinish);
+
+  function unpipe() {
+    debug('unpipe');
+    src.unpipe(dest);
+  }
+
+  // tell the dest that it's being piped to
+  dest.emit('pipe', src);
+
+  // start the flow if it hasn't been started already.
+  if (!state.flowing) {
+    debug('pipe resume');
+    src.resume();
+  }
+
+  return dest;
+};
+
+function pipeOnDrain(src) {
+  return function () {
+    var state = src._readableState;
+    debug('pipeOnDrain', state.awaitDrain);
+    if (state.awaitDrain) state.awaitDrain--;
+    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
+      state.flowing = true;
+      flow(src);
+    }
+  };
+}
+
+Readable.prototype.unpipe = function (dest) {
+  var state = this._readableState;
+  var unpipeInfo = { hasUnpiped: false };
+
+  // if we're not piping anywhere, then do nothing.
+  if (state.pipesCount === 0) return this;
+
+  // just one destination.  most common case.
+  if (state.pipesCount === 1) {
+    // passed in one, but it's not the right one.
+    if (dest && dest !== state.pipes) return this;
+
+    if (!dest) dest = state.pipes;
+
+    // got a match.
+    state.pipes = null;
+    state.pipesCount = 0;
+    state.flowing = false;
+    if (dest) dest.emit('unpipe', this, unpipeInfo);
+    return this;
+  }
+
+  // slow case. multiple pipe destinations.
+
+  if (!dest) {
+    // remove all.
+    var dests = state.pipes;
+    var len = state.pipesCount;
+    state.pipes = null;
+    state.pipesCount = 0;
+    state.flowing = false;
+
+    for (var i = 0; i < len; i++) {
+      dests[i].emit('unpipe', this, unpipeInfo);
+    }return this;
+  }
+
+  // try to find the right one.
+  var index = indexOf(state.pipes, dest);
+  if (index === -1) return this;
+
+  state.pipes.splice(index, 1);
+  state.pipesCount -= 1;
+  if (state.pipesCount === 1) state.pipes = state.pipes[0];
+
+  dest.emit('unpipe', this, unpipeInfo);
+
+  return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function (ev, fn) {
+  var res = Stream.prototype.on.call(this, ev, fn);
+
+  if (ev === 'data') {
+    // Start flowing on next tick if stream isn't explicitly paused
+    if (this._readableState.flowing !== false) this.resume();
+  } else if (ev === 'readable') {
+    var state = this._readableState;
+    if (!state.endEmitted && !state.readableListening) {
+      state.readableListening = state.needReadable = true;
+      state.emittedReadable = false;
+      if (!state.reading) {
+        pna.nextTick(nReadingNextTick, this);
+      } else if (state.length) {
+        emitReadable(this);
+      }
+    }
+  }
+
+  return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+function nReadingNextTick(self) {
+  debug('readable nexttick read 0');
+  self.read(0);
+}
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function () {
+  var state = this._readableState;
+  if (!state.flowing) {
+    debug('resume');
+    state.flowing = true;
+    resume(this, state);
+  }
+  return this;
+};
+
+function resume(stream, state) {
+  if (!state.resumeScheduled) {
+    state.resumeScheduled = true;
+    pna.nextTick(resume_, stream, state);
+  }
+}
+
+function resume_(stream, state) {
+  if (!state.reading) {
+    debug('resume read 0');
+    stream.read(0);
+  }
+
+  state.resumeScheduled = false;
+  state.awaitDrain = 0;
+  stream.emit('resume');
+  flow(stream);
+  if (state.flowing && !state.reading) stream.read(0);
+}
+
+Readable.prototype.pause = function () {
+  debug('call pause flowing=%j', this._readableState.flowing);
+  if (false !== this._readableState.flowing) {
+    debug('pause');
+    this._readableState.flowing = false;
+    this.emit('pause');
+  }
+  return this;
+};
+
+function flow(stream) {
+  var state = stream._readableState;
+  debug('flow', state.flowing);
+  while (state.flowing && stream.read() !== null) {}
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function (stream) {
+  var _this = this;
+
+  var state = this._readableState;
+  var paused = false;
+
+  stream.on('end', function () {
+    debug('wrapped end');
+    if (state.decoder && !state.ended) {
+      var chunk = state.decoder.end();
+      if (chunk && chunk.length) _this.push(chunk);
+    }
+
+    _this.push(null);
+  });
+
+  stream.on('data', function (chunk) {
+    debug('wrapped data');
+    if (state.decoder) chunk = state.decoder.write(chunk);
+
+    // don't skip over falsy values in objectMode
+    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
+
+    var ret = _this.push(chunk);
+    if (!ret) {
+      paused = true;
+      stream.pause();
+    }
+  });
+
+  // proxy all the other methods.
+  // important when wrapping filters and duplexes.
+  for (var i in stream) {
+    if (this[i] === undefined && typeof stream[i] === 'function') {
+      this[i] = function (method) {
+        return function () {
+          return stream[method].apply(stream, arguments);
+        };
+      }(i);
+    }
+  }
+
+  // proxy certain important events.
+  for (var n = 0; n < kProxyEvents.length; n++) {
+    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+  }
+
+  // when we try to consume some more bytes, simply unpause the
+  // underlying stream.
+  this._read = function (n) {
+    debug('wrapped _read', n);
+    if (paused) {
+      paused = false;
+      stream.resume();
+    }
+  };
+
+  return this;
+};
+
+Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function () {
+    return this._readableState.highWaterMark;
+  }
+});
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromList(n, state) {
+  // nothing buffered
+  if (state.length === 0) return null;
+
+  var ret;
+  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
+    // read it all, truncate the list
+    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
+    state.buffer.clear();
+  } else {
+    // read part of list
+    ret = fromListPartial(n, state.buffer, state.decoder);
+  }
+
+  return ret;
+}
+
+// Extracts only enough buffered data to satisfy the amount requested.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromListPartial(n, list, hasStrings) {
+  var ret;
+  if (n < list.head.data.length) {
+    // slice is the same for buffers and strings
+    ret = list.head.data.slice(0, n);
+    list.head.data = list.head.data.slice(n);
+  } else if (n === list.head.data.length) {
+    // first chunk is a perfect match
+    ret = list.shift();
+  } else {
+    // result spans more than one buffer
+    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+  }
+  return ret;
+}
+
+// Copies a specified amount of characters from the list of buffered data
+// chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBufferString(n, list) {
+  var p = list.head;
+  var c = 1;
+  var ret = p.data;
+  n -= ret.length;
+  while (p = p.next) {
+    var str = p.data;
+    var nb = n > str.length ? str.length : n;
+    if (nb === str.length) ret += str;else ret += str.slice(0, n);
+    n -= nb;
+    if (n === 0) {
+      if (nb === str.length) {
+        ++c;
+        if (p.next) list.head = p.next;else list.head = list.tail = null;
+      } else {
+        list.head = p;
+        p.data = str.slice(nb);
+      }
+      break;
+    }
+    ++c;
+  }
+  list.length -= c;
+  return ret;
+}
+
+// Copies a specified amount of bytes from the list of buffered data chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBuffer(n, list) {
+  var ret = Buffer.allocUnsafe(n);
+  var p = list.head;
+  var c = 1;
+  p.data.copy(ret);
+  n -= p.data.length;
+  while (p = p.next) {
+    var buf = p.data;
+    var nb = n > buf.length ? buf.length : n;
+    buf.copy(ret, ret.length - n, 0, nb);
+    n -= nb;
+    if (n === 0) {
+      if (nb === buf.length) {
+        ++c;
+        if (p.next) list.head = p.next;else list.head = list.tail = null;
+      } else {
+        list.head = p;
+        p.data = buf.slice(nb);
+      }
+      break;
+    }
+    ++c;
+  }
+  list.length -= c;
+  return ret;
+}
+
+function endReadable(stream) {
+  var state = stream._readableState;
+
+  // If we get here before consuming all the bytes, then that is a
+  // bug in node.  Should never happen.
+  if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
+
+  if (!state.endEmitted) {
+    state.ended = true;
+    pna.nextTick(endReadableNT, state, stream);
+  }
+}
+
+function endReadableNT(state, stream) {
+  // Check that we didn't get one last unshift.
+  if (!state.endEmitted && state.length === 0) {
+    state.endEmitted = true;
+    stream.readable = false;
+    stream.emit('end');
+  }
+}
+
+function indexOf(xs, x) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    if (xs[i] === x) return i;
+  }
+  return -1;
+}
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./_stream_duplex":135,"./internal/streams/BufferList":140,"./internal/streams/destroy":141,"./internal/streams/stream":142,"_process":125,"core-util-is":57,"events":90,"inherits":107,"isarray":109,"process-nextick-args":124,"safe-buffer":148,"string_decoder/":158,"util":26}],138:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data.  Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored.  (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation.  For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up.  When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer.  When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks.  If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk.  However,
+// a pathological inflate type of transform can cause excessive buffering
+// here.  For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output.  In this case, you could write a very small
+// amount of input, and end up with a very large amount of output.  In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform.  A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+'use strict';
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+function afterTransform(er, data) {
+  var ts = this._transformState;
+  ts.transforming = false;
+
+  var cb = ts.writecb;
+
+  if (!cb) {
+    return this.emit('error', new Error('write callback called multiple times'));
+  }
+
+  ts.writechunk = null;
+  ts.writecb = null;
+
+  if (data != null) // single equals check for both `null` and `undefined`
+    this.push(data);
+
+  cb(er);
+
+  var rs = this._readableState;
+  rs.reading = false;
+  if (rs.needReadable || rs.length < rs.highWaterMark) {
+    this._read(rs.highWaterMark);
+  }
+}
+
+function Transform(options) {
+  if (!(this instanceof Transform)) return new Transform(options);
+
+  Duplex.call(this, options);
+
+  this._transformState = {
+    afterTransform: afterTransform.bind(this),
+    needTransform: false,
+    transforming: false,
+    writecb: null,
+    writechunk: null,
+    writeencoding: null
+  };
+
+  // start out asking for a readable event once data is transformed.
+  this._readableState.needReadable = true;
+
+  // we have implemented the _read method, and done the other things
+  // that Readable wants before the first _read call, so unset the
+  // sync guard flag.
+  this._readableState.sync = false;
+
+  if (options) {
+    if (typeof options.transform === 'function') this._transform = options.transform;
+
+    if (typeof options.flush === 'function') this._flush = options.flush;
+  }
+
+  // When the writable side finishes, then flush out anything remaining.
+  this.on('prefinish', prefinish);
+}
+
+function prefinish() {
+  var _this = this;
+
+  if (typeof this._flush === 'function') {
+    this._flush(function (er, data) {
+      done(_this, er, data);
+    });
+  } else {
+    done(this, null, null);
+  }
+}
+
+Transform.prototype.push = function (chunk, encoding) {
+  this._transformState.needTransform = false;
+  return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side.  You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk.  If you pass
+// an error, then that'll put the hurt on the whole operation.  If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function (chunk, encoding, cb) {
+  throw new Error('_transform() is not implemented');
+};
+
+Transform.prototype._write = function (chunk, encoding, cb) {
+  var ts = this._transformState;
+  ts.writecb = cb;
+  ts.writechunk = chunk;
+  ts.writeencoding = encoding;
+  if (!ts.transforming) {
+    var rs = this._readableState;
+    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+  }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function (n) {
+  var ts = this._transformState;
+
+  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+    ts.transforming = true;
+    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+  } else {
+    // mark that we need a transform, so that any data that comes in
+    // will get processed, now that we've asked for it.
+    ts.needTransform = true;
+  }
+};
+
+Transform.prototype._destroy = function (err, cb) {
+  var _this2 = this;
+
+  Duplex.prototype._destroy.call(this, err, function (err2) {
+    cb(err2);
+    _this2.emit('close');
+  });
+};
+
+function done(stream, er, data) {
+  if (er) return stream.emit('error', er);
+
+  if (data != null) // single equals check for both `null` and `undefined`
+    stream.push(data);
+
+  // if there's nothing in the write buffer, then that means
+  // that nothing more will ever be provided
+  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
+
+  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
+
+  return stream.push(null);
+}
+},{"./_stream_duplex":135,"core-util-is":57,"inherits":107}],139:[function(require,module,exports){
+(function (process,global,setImmediate){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+
+'use strict';
+
+/*<replacement>*/
+
+var pna = require('process-nextick-args');
+/*</replacement>*/
+
+module.exports = Writable;
+
+/* <replacement> */
+function WriteReq(chunk, encoding, cb) {
+  this.chunk = chunk;
+  this.encoding = encoding;
+  this.callback = cb;
+  this.next = null;
+}
+
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function CorkedRequest(state) {
+  var _this = this;
+
+  this.next = null;
+  this.entry = null;
+  this.finish = function () {
+    onCorkedFinish(_this, state);
+  };
+}
+/* </replacement> */
+
+/*<replacement>*/
+var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
+/*</replacement>*/
+
+/*<replacement>*/
+var Duplex;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+/*<replacement>*/
+var internalUtil = {
+  deprecate: require('util-deprecate')
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream = require('./internal/streams/stream');
+/*</replacement>*/
+
+/*<replacement>*/
+
+var Buffer = require('safe-buffer').Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+  return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+
+/*</replacement>*/
+
+var destroyImpl = require('./internal/streams/destroy');
+
+util.inherits(Writable, Stream);
+
+function nop() {}
+
+function WritableState(options, stream) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  options = options || {};
+
+  // Duplex streams are both readable and writable, but share
+  // the same options object.
+  // However, some cases require setting options to different
+  // values for the readable and the writable sides of the duplex stream.
+  // These options can be provided separately as readableXXX and writableXXX.
+  var isDuplex = stream instanceof Duplex;
+
+  // object stream flag to indicate whether or not this stream
+  // contains buffers or objects.
+  this.objectMode = !!options.objectMode;
+
+  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+
+  // the point at which write() starts returning false
+  // Note: 0 is a valid value, means that we always return false if
+  // the entire buffer is not flushed immediately on write()
+  var hwm = options.highWaterMark;
+  var writableHwm = options.writableHighWaterMark;
+  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+
+  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
+
+  // cast to ints.
+  this.highWaterMark = Math.floor(this.highWaterMark);
+
+  // if _final has been called
+  this.finalCalled = false;
+
+  // drain event flag.
+  this.needDrain = false;
+  // at the start of calling end()
+  this.ending = false;
+  // when end() has been called, and returned
+  this.ended = false;
+  // when 'finish' is emitted
+  this.finished = false;
+
+  // has it been destroyed
+  this.destroyed = false;
+
+  // should we decode strings into buffers before passing to _write?
+  // this is here so that some node-core streams can optimize string
+  // handling at a lower level.
+  var noDecode = options.decodeStrings === false;
+  this.decodeStrings = !noDecode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // not an actual buffer we keep track of, but a measurement
+  // of how much we're waiting to get pushed to some underlying
+  // socket or file.
+  this.length = 0;
+
+  // a flag to see when we're in the middle of a write.
+  this.writing = false;
+
+  // when true all writes will be buffered until .uncork() call
+  this.corked = 0;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, because any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // a flag to know if we're processing previously buffered items, which
+  // may call the _write() callback in the same tick, so that we don't
+  // end up in an overlapped onwrite situation.
+  this.bufferProcessing = false;
+
+  // the callback that's passed to _write(chunk,cb)
+  this.onwrite = function (er) {
+    onwrite(stream, er);
+  };
+
+  // the callback that the user supplies to write(chunk,encoding,cb)
+  this.writecb = null;
+
+  // the amount that is being written when _write is called.
+  this.writelen = 0;
+
+  this.bufferedRequest = null;
+  this.lastBufferedRequest = null;
+
+  // number of pending user-supplied write callbacks
+  // this must be 0 before 'finish' can be emitted
+  this.pendingcb = 0;
+
+  // emit prefinish if the only thing we're waiting for is _write cbs
+  // This is relevant for synchronous Transform streams
+  this.prefinished = false;
+
+  // True if the error was already emitted and should not be thrown again
+  this.errorEmitted = false;
+
+  // count buffered requests
+  this.bufferedRequestCount = 0;
+
+  // allocate the first CorkedRequest, there is always
+  // one allocated and free to use, and we maintain at most two
+  this.corkedRequestsFree = new CorkedRequest(this);
+}
+
+WritableState.prototype.getBuffer = function getBuffer() {
+  var current = this.bufferedRequest;
+  var out = [];
+  while (current) {
+    out.push(current);
+    current = current.next;
+  }
+  return out;
+};
+
+(function () {
+  try {
+    Object.defineProperty(WritableState.prototype, 'buffer', {
+      get: internalUtil.deprecate(function () {
+        return this.getBuffer();
+      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
+    });
+  } catch (_) {}
+})();
+
+// Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
+var realHasInstance;
+if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
+  realHasInstance = Function.prototype[Symbol.hasInstance];
+  Object.defineProperty(Writable, Symbol.hasInstance, {
+    value: function (object) {
+      if (realHasInstance.call(this, object)) return true;
+      if (this !== Writable) return false;
+
+      return object && object._writableState instanceof WritableState;
+    }
+  });
+} else {
+  realHasInstance = function (object) {
+    return object instanceof this;
+  };
+}
+
+function Writable(options) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  // Writable ctor is applied to Duplexes, too.
+  // `realHasInstance` is necessary because using plain `instanceof`
+  // would return false, as no `_writableState` property is attached.
+
+  // Trying to use the custom `instanceof` for Writable here will also break the
+  // Node.js LazyTransform implementation, which has a non-trivial getter for
+  // `_writableState` that would lead to infinite recursion.
+  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
+    return new Writable(options);
+  }
+
+  this._writableState = new WritableState(options, this);
+
+  // legacy.
+  this.writable = true;
+
+  if (options) {
+    if (typeof options.write === 'function') this._write = options.write;
+
+    if (typeof options.writev === 'function') this._writev = options.writev;
+
+    if (typeof options.destroy === 'function') this._destroy = options.destroy;
+
+    if (typeof options.final === 'function') this._final = options.final;
+  }
+
+  Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function () {
+  this.emit('error', new Error('Cannot pipe, not readable'));
+};
+
+function writeAfterEnd(stream, cb) {
+  var er = new Error('write after end');
+  // TODO: defer error events consistently everywhere, not just the cb
+  stream.emit('error', er);
+  pna.nextTick(cb, er);
+}
+
+// Checks that a user-supplied chunk is valid, especially for the particular
+// mode the stream is in. Currently this means that `null` is never accepted
+// and undefined/non-string values are only allowed in object mode.
+function validChunk(stream, state, chunk, cb) {
+  var valid = true;
+  var er = false;
+
+  if (chunk === null) {
+    er = new TypeError('May not write null values to stream');
+  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  if (er) {
+    stream.emit('error', er);
+    pna.nextTick(cb, er);
+    valid = false;
+  }
+  return valid;
+}
+
+Writable.prototype.write = function (chunk, encoding, cb) {
+  var state = this._writableState;
+  var ret = false;
+  var isBuf = !state.objectMode && _isUint8Array(chunk);
+
+  if (isBuf && !Buffer.isBuffer(chunk)) {
+    chunk = _uint8ArrayToBuffer(chunk);
+  }
+
+  if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+
+  if (typeof cb !== 'function') cb = nop;
+
+  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
+    state.pendingcb++;
+    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+  }
+
+  return ret;
+};
+
+Writable.prototype.cork = function () {
+  var state = this._writableState;
+
+  state.corked++;
+};
+
+Writable.prototype.uncork = function () {
+  var state = this._writableState;
+
+  if (state.corked) {
+    state.corked--;
+
+    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+  }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+  // node::ParseEncoding() requires lower case.
+  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
+  this._writableState.defaultEncoding = encoding;
+  return this;
+};
+
+function decodeChunk(state, chunk, encoding) {
+  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+    chunk = Buffer.from(chunk, encoding);
+  }
+  return chunk;
+}
+
+Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function () {
+    return this._writableState.highWaterMark;
+  }
+});
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn.  Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+  if (!isBuf) {
+    var newChunk = decodeChunk(state, chunk, encoding);
+    if (chunk !== newChunk) {
+      isBuf = true;
+      encoding = 'buffer';
+      chunk = newChunk;
+    }
+  }
+  var len = state.objectMode ? 1 : chunk.length;
+
+  state.length += len;
+
+  var ret = state.length < state.highWaterMark;
+  // we must ensure that previous needDrain will not be reset to false.
+  if (!ret) state.needDrain = true;
+
+  if (state.writing || state.corked) {
+    var last = state.lastBufferedRequest;
+    state.lastBufferedRequest = {
+      chunk: chunk,
+      encoding: encoding,
+      isBuf: isBuf,
+      callback: cb,
+      next: null
+    };
+    if (last) {
+      last.next = state.lastBufferedRequest;
+    } else {
+      state.bufferedRequest = state.lastBufferedRequest;
+    }
+    state.bufferedRequestCount += 1;
+  } else {
+    doWrite(stream, state, false, len, chunk, encoding, cb);
+  }
+
+  return ret;
+}
+
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+  state.writelen = len;
+  state.writecb = cb;
+  state.writing = true;
+  state.sync = true;
+  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
+  state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+  --state.pendingcb;
+
+  if (sync) {
+    // defer the callback if we are being called synchronously
+    // to avoid piling up things on the stack
+    pna.nextTick(cb, er);
+    // this can emit finish, and it will always happen
+    // after error
+    pna.nextTick(finishMaybe, stream, state);
+    stream._writableState.errorEmitted = true;
+    stream.emit('error', er);
+  } else {
+    // the caller expect this to happen before if
+    // it is async
+    cb(er);
+    stream._writableState.errorEmitted = true;
+    stream.emit('error', er);
+    // this can emit finish, but finish must
+    // always follow error
+    finishMaybe(stream, state);
+  }
+}
+
+function onwriteStateUpdate(state) {
+  state.writing = false;
+  state.writecb = null;
+  state.length -= state.writelen;
+  state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+  var state = stream._writableState;
+  var sync = state.sync;
+  var cb = state.writecb;
+
+  onwriteStateUpdate(state);
+
+  if (er) onwriteError(stream, state, sync, er, cb);else {
+    // Check if we're actually ready to finish, but don't emit yet
+    var finished = needFinish(state);
+
+    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+      clearBuffer(stream, state);
+    }
+
+    if (sync) {
+      /*<replacement>*/
+      asyncWrite(afterWrite, stream, state, finished, cb);
+      /*</replacement>*/
+    } else {
+      afterWrite(stream, state, finished, cb);
+    }
+  }
+}
+
+function afterWrite(stream, state, finished, cb) {
+  if (!finished) onwriteDrain(stream, state);
+  state.pendingcb--;
+  cb();
+  finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+  if (state.length === 0 && state.needDrain) {
+    state.needDrain = false;
+    stream.emit('drain');
+  }
+}
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+  state.bufferProcessing = true;
+  var entry = state.bufferedRequest;
+
+  if (stream._writev && entry && entry.next) {
+    // Fast case, write everything using _writev()
+    var l = state.bufferedRequestCount;
+    var buffer = new Array(l);
+    var holder = state.corkedRequestsFree;
+    holder.entry = entry;
+
+    var count = 0;
+    var allBuffers = true;
+    while (entry) {
+      buffer[count] = entry;
+      if (!entry.isBuf) allBuffers = false;
+      entry = entry.next;
+      count += 1;
+    }
+    buffer.allBuffers = allBuffers;
+
+    doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+
+    // doWrite is almost always async, defer these to save a bit of time
+    // as the hot path ends with doWrite
+    state.pendingcb++;
+    state.lastBufferedRequest = null;
+    if (holder.next) {
+      state.corkedRequestsFree = holder.next;
+      holder.next = null;
+    } else {
+      state.corkedRequestsFree = new CorkedRequest(state);
+    }
+    state.bufferedRequestCount = 0;
+  } else {
+    // Slow case, write chunks one-by-one
+    while (entry) {
+      var chunk = entry.chunk;
+      var encoding = entry.encoding;
+      var cb = entry.callback;
+      var len = state.objectMode ? 1 : chunk.length;
+
+      doWrite(stream, state, false, len, chunk, encoding, cb);
+      entry = entry.next;
+      state.bufferedRequestCount--;
+      // if we didn't call the onwrite immediately, then
+      // it means that we need to wait until it does.
+      // also, that means that the chunk and cb are currently
+      // being processed, so move the buffer counter past them.
+      if (state.writing) {
+        break;
+      }
+    }
+
+    if (entry === null) state.lastBufferedRequest = null;
+  }
+
+  state.bufferedRequest = entry;
+  state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function (chunk, encoding, cb) {
+  cb(new Error('_write() is not implemented'));
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function (chunk, encoding, cb) {
+  var state = this._writableState;
+
+  if (typeof chunk === 'function') {
+    cb = chunk;
+    chunk = null;
+    encoding = null;
+  } else if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+
+  // .end() fully uncorks
+  if (state.corked) {
+    state.corked = 1;
+    this.uncork();
+  }
+
+  // ignore unnecessary end() calls.
+  if (!state.ending && !state.finished) endWritable(this, state, cb);
+};
+
+function needFinish(state) {
+  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+function callFinal(stream, state) {
+  stream._final(function (err) {
+    state.pendingcb--;
+    if (err) {
+      stream.emit('error', err);
+    }
+    state.prefinished = true;
+    stream.emit('prefinish');
+    finishMaybe(stream, state);
+  });
+}
+function prefinish(stream, state) {
+  if (!state.prefinished && !state.finalCalled) {
+    if (typeof stream._final === 'function') {
+      state.pendingcb++;
+      state.finalCalled = true;
+      pna.nextTick(callFinal, stream, state);
+    } else {
+      state.prefinished = true;
+      stream.emit('prefinish');
+    }
+  }
+}
+
+function finishMaybe(stream, state) {
+  var need = needFinish(state);
+  if (need) {
+    prefinish(stream, state);
+    if (state.pendingcb === 0) {
+      state.finished = true;
+      stream.emit('finish');
+    }
+  }
+  return need;
+}
+
+function endWritable(stream, state, cb) {
+  state.ending = true;
+  finishMaybe(stream, state);
+  if (cb) {
+    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
+  }
+  state.ended = true;
+  stream.writable = false;
+}
+
+function onCorkedFinish(corkReq, state, err) {
+  var entry = corkReq.entry;
+  corkReq.entry = null;
+  while (entry) {
+    var cb = entry.callback;
+    state.pendingcb--;
+    cb(err);
+    entry = entry.next;
+  }
+  if (state.corkedRequestsFree) {
+    state.corkedRequestsFree.next = corkReq;
+  } else {
+    state.corkedRequestsFree = corkReq;
+  }
+}
+
+Object.defineProperty(Writable.prototype, 'destroyed', {
+  get: function () {
+    if (this._writableState === undefined) {
+      return false;
+    }
+    return this._writableState.destroyed;
+  },
+  set: function (value) {
+    // we ignore the value if the stream
+    // has not been initialized yet
+    if (!this._writableState) {
+      return;
+    }
+
+    // backward compatibility, the user is explicitly
+    // managing destroyed
+    this._writableState.destroyed = value;
+  }
+});
+
+Writable.prototype.destroy = destroyImpl.destroy;
+Writable.prototype._undestroy = destroyImpl.undestroy;
+Writable.prototype._destroy = function (err, cb) {
+  this.end();
+  cb(err);
+};
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
+},{"./_stream_duplex":135,"./internal/streams/destroy":141,"./internal/streams/stream":142,"_process":125,"core-util-is":57,"inherits":107,"process-nextick-args":124,"safe-buffer":148,"timers":159,"util-deprecate":160}],140:[function(require,module,exports){
+'use strict';
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Buffer = require('safe-buffer').Buffer;
+var util = require('util');
+
+function copyBuffer(src, target, offset) {
+  src.copy(target, offset);
+}
+
+module.exports = function () {
+  function BufferList() {
+    _classCallCheck(this, BufferList);
+
+    this.head = null;
+    this.tail = null;
+    this.length = 0;
+  }
+
+  BufferList.prototype.push = function push(v) {
+    var entry = { data: v, next: null };
+    if (this.length > 0) this.tail.next = entry;else this.head = entry;
+    this.tail = entry;
+    ++this.length;
+  };
+
+  BufferList.prototype.unshift = function unshift(v) {
+    var entry = { data: v, next: this.head };
+    if (this.length === 0) this.tail = entry;
+    this.head = entry;
+    ++this.length;
+  };
+
+  BufferList.prototype.shift = function shift() {
+    if (this.length === 0) return;
+    var ret = this.head.data;
+    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+    --this.length;
+    return ret;
+  };
+
+  BufferList.prototype.clear = function clear() {
+    this.head = this.tail = null;
+    this.length = 0;
+  };
+
+  BufferList.prototype.join = function join(s) {
+    if (this.length === 0) return '';
+    var p = this.head;
+    var ret = '' + p.data;
+    while (p = p.next) {
+      ret += s + p.data;
+    }return ret;
+  };
+
+  BufferList.prototype.concat = function concat(n) {
+    if (this.length === 0) return Buffer.alloc(0);
+    if (this.length === 1) return this.head.data;
+    var ret = Buffer.allocUnsafe(n >>> 0);
+    var p = this.head;
+    var i = 0;
+    while (p) {
+      copyBuffer(p.data, ret, i);
+      i += p.data.length;
+      p = p.next;
+    }
+    return ret;
+  };
+
+  return BufferList;
+}();
+
+if (util && util.inspect && util.inspect.custom) {
+  module.exports.prototype[util.inspect.custom] = function () {
+    var obj = util.inspect({ length: this.length });
+    return this.constructor.name + ' ' + obj;
+  };
+}
+},{"safe-buffer":148,"util":26}],141:[function(require,module,exports){
+'use strict';
+
+/*<replacement>*/
+
+var pna = require('process-nextick-args');
+/*</replacement>*/
+
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+  var _this = this;
+
+  var readableDestroyed = this._readableState && this._readableState.destroyed;
+  var writableDestroyed = this._writableState && this._writableState.destroyed;
+
+  if (readableDestroyed || writableDestroyed) {
+    if (cb) {
+      cb(err);
+    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+      pna.nextTick(emitErrorNT, this, err);
+    }
+    return this;
+  }
+
+  // we set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
+
+  if (this._readableState) {
+    this._readableState.destroyed = true;
+  }
+
+  // if this is a duplex stream mark the writable part as destroyed as well
+  if (this._writableState) {
+    this._writableState.destroyed = true;
+  }
+
+  this._destroy(err || null, function (err) {
+    if (!cb && err) {
+      pna.nextTick(emitErrorNT, _this, err);
+      if (_this._writableState) {
+        _this._writableState.errorEmitted = true;
+      }
+    } else if (cb) {
+      cb(err);
+    }
+  });
+
+  return this;
+}
+
+function undestroy() {
+  if (this._readableState) {
+    this._readableState.destroyed = false;
+    this._readableState.reading = false;
+    this._readableState.ended = false;
+    this._readableState.endEmitted = false;
+  }
+
+  if (this._writableState) {
+    this._writableState.destroyed = false;
+    this._writableState.ended = false;
+    this._writableState.ending = false;
+    this._writableState.finished = false;
+    this._writableState.errorEmitted = false;
+  }
+}
+
+function emitErrorNT(self, err) {
+  self.emit('error', err);
+}
+
+module.exports = {
+  destroy: destroy,
+  undestroy: undestroy
+};
+},{"process-nextick-args":124}],142:[function(require,module,exports){
+module.exports = require('events').EventEmitter;
+
+},{"events":90}],143:[function(require,module,exports){
+module.exports = require('./readable').PassThrough
+
+},{"./readable":144}],144:[function(require,module,exports){
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+},{"./lib/_stream_duplex.js":135,"./lib/_stream_passthrough.js":136,"./lib/_stream_readable.js":137,"./lib/_stream_transform.js":138,"./lib/_stream_writable.js":139}],145:[function(require,module,exports){
+module.exports = require('./readable').Transform
+
+},{"./readable":144}],146:[function(require,module,exports){
+module.exports = require('./lib/_stream_writable.js');
+
+},{"./lib/_stream_writable.js":139}],147:[function(require,module,exports){
+'use strict'
+var Buffer = require('buffer').Buffer
+var inherits = require('inherits')
+var HashBase = require('hash-base')
+
+var ARRAY16 = new Array(16)
+
+var zl = [
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
+]
+
+var zr = [
+  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
+]
+
+var sl = [
+  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
+]
+
+var sr = [
+  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
+]
+
+var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]
+var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]
+
+function RIPEMD160 () {
+  HashBase.call(this, 64)
+
+  // state
+  this._a = 0x67452301
+  this._b = 0xefcdab89
+  this._c = 0x98badcfe
+  this._d = 0x10325476
+  this._e = 0xc3d2e1f0
+}
+
+inherits(RIPEMD160, HashBase)
+
+RIPEMD160.prototype._update = function () {
+  var words = ARRAY16
+  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)
+
+  var al = this._a | 0
+  var bl = this._b | 0
+  var cl = this._c | 0
+  var dl = this._d | 0
+  var el = this._e | 0
+
+  var ar = this._a | 0
+  var br = this._b | 0
+  var cr = this._c | 0
+  var dr = this._d | 0
+  var er = this._e | 0
+
+  // computation
+  for (var i = 0; i < 80; i += 1) {
+    var tl
+    var tr
+    if (i < 16) {
+      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])
+      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])
+    } else if (i < 32) {
+      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])
+      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])
+    } else if (i < 48) {
+      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])
+      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])
+    } else if (i < 64) {
+      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])
+      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])
+    } else { // if (i<80) {
+      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])
+      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])
+    }
+
+    al = el
+    el = dl
+    dl = rotl(cl, 10)
+    cl = bl
+    bl = tl
+
+    ar = er
+    er = dr
+    dr = rotl(cr, 10)
+    cr = br
+    br = tr
+  }
+
+  // update state
+  var t = (this._b + cl + dr) | 0
+  this._b = (this._c + dl + er) | 0
+  this._c = (this._d + el + ar) | 0
+  this._d = (this._e + al + br) | 0
+  this._e = (this._a + bl + cr) | 0
+  this._a = t
+}
+
+RIPEMD160.prototype._digest = function () {
+  // create padding and handle blocks
+  this._block[this._blockOffset++] = 0x80
+  if (this._blockOffset > 56) {
+    this._block.fill(0, this._blockOffset, 64)
+    this._update()
+    this._blockOffset = 0
+  }
+
+  this._block.fill(0, this._blockOffset, 56)
+  this._block.writeUInt32LE(this._length[0], 56)
+  this._block.writeUInt32LE(this._length[1], 60)
+  this._update()
+
+  // produce result
+  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)
+  buffer.writeInt32LE(this._a, 0)
+  buffer.writeInt32LE(this._b, 4)
+  buffer.writeInt32LE(this._c, 8)
+  buffer.writeInt32LE(this._d, 12)
+  buffer.writeInt32LE(this._e, 16)
+  return buffer
+}
+
+function rotl (x, n) {
+  return (x << n) | (x >>> (32 - n))
+}
+
+function fn1 (a, b, c, d, e, m, k, s) {
+  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0
+}
+
+function fn2 (a, b, c, d, e, m, k, s) {
+  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0
+}
+
+function fn3 (a, b, c, d, e, m, k, s) {
+  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0
+}
+
+function fn4 (a, b, c, d, e, m, k, s) {
+  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0
+}
+
+function fn5 (a, b, c, d, e, m, k, s) {
+  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0
+}
+
+module.exports = RIPEMD160
+
+},{"buffer":55,"hash-base":92,"inherits":107}],148:[function(require,module,exports){
+arguments[4][7][0].apply(exports,arguments)
+},{"buffer":55,"dup":7}],149:[function(require,module,exports){
+var Buffer = require('safe-buffer').Buffer
+
+// prototype class for hash functions
+function Hash (blockSize, finalSize) {
+  this._block = Buffer.alloc(blockSize)
+  this._finalSize = finalSize
+  this._blockSize = blockSize
+  this._len = 0
+}
+
+Hash.prototype.update = function (data, enc) {
+  if (typeof data === 'string') {
+    enc = enc || 'utf8'
+    data = Buffer.from(data, enc)
+  }
+
+  var block = this._block
+  var blockSize = this._blockSize
+  var length = data.length
+  var accum = this._len
+
+  for (var offset = 0; offset < length;) {
+    var assigned = accum % blockSize
+    var remainder = Math.min(length - offset, blockSize - assigned)
+
+    for (var i = 0; i < remainder; i++) {
+      block[assigned + i] = data[offset + i]
+    }
+
+    accum += remainder
+    offset += remainder
+
+    if ((accum % blockSize) === 0) {
+      this._update(block)
+    }
+  }
+
+  this._len += length
+  return this
+}
+
+Hash.prototype.digest = function (enc) {
+  var rem = this._len % this._blockSize
+
+  this._block[rem] = 0x80
+
+  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest
+  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
+  this._block.fill(0, rem + 1)
+
+  if (rem >= this._finalSize) {
+    this._update(this._block)
+    this._block.fill(0)
+  }
+
+  var bits = this._len * 8
+
+  // uint32
+  if (bits <= 0xffffffff) {
+    this._block.writeUInt32BE(bits, this._blockSize - 4)
+
+  // uint64
+  } else {
+    var lowBits = (bits & 0xffffffff) >>> 0
+    var highBits = (bits - lowBits) / 0x100000000
+
+    this._block.writeUInt32BE(highBits, this._blockSize - 8)
+    this._block.writeUInt32BE(lowBits, this._blockSize - 4)
+  }
+
+  this._update(this._block)
+  var hash = this._hash()
+
+  return enc ? hash.toString(enc) : hash
+}
+
+Hash.prototype._update = function () {
+  throw new Error('_update must be implemented by subclass')
+}
+
+module.exports = Hash
+
+},{"safe-buffer":148}],150:[function(require,module,exports){
+var exports = module.exports = function SHA (algorithm) {
+  algorithm = algorithm.toLowerCase()
+
+  var Algorithm = exports[algorithm]
+  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')
+
+  return new Algorithm()
+}
+
+exports.sha = require('./sha')
+exports.sha1 = require('./sha1')
+exports.sha224 = require('./sha224')
+exports.sha256 = require('./sha256')
+exports.sha384 = require('./sha384')
+exports.sha512 = require('./sha512')
+
+},{"./sha":151,"./sha1":152,"./sha224":153,"./sha256":154,"./sha384":155,"./sha512":156}],151:[function(require,module,exports){
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
+ * in FIPS PUB 180-1
+ * This source code is derived from sha1.js of the same repository.
+ * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
+ * operation was added.
+ */
+
+var inherits = require('inherits')
+var Hash = require('./hash')
+var Buffer = require('safe-buffer').Buffer
+
+var K = [
+  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
+]
+
+var W = new Array(80)
+
+function Sha () {
+  this.init()
+  this._w = W
+
+  Hash.call(this, 64, 56)
+}
+
+inherits(Sha, Hash)
+
+Sha.prototype.init = function () {
+  this._a = 0x67452301
+  this._b = 0xefcdab89
+  this._c = 0x98badcfe
+  this._d = 0x10325476
+  this._e = 0xc3d2e1f0
+
+  return this
+}
+
+function rotl5 (num) {
+  return (num << 5) | (num >>> 27)
+}
+
+function rotl30 (num) {
+  return (num << 30) | (num >>> 2)
+}
+
+function ft (s, b, c, d) {
+  if (s === 0) return (b & c) | ((~b) & d)
+  if (s === 2) return (b & c) | (b & d) | (c & d)
+  return b ^ c ^ d
+}
+
+Sha.prototype._update = function (M) {
+  var W = this._w
+
+  var a = this._a | 0
+  var b = this._b | 0
+  var c = this._c | 0
+  var d = this._d | 0
+  var e = this._e | 0
+
+  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
+  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]
+
+  for (var j = 0; j < 80; ++j) {
+    var s = ~~(j / 20)
+    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0
+
+    e = d
+    d = c
+    c = rotl30(b)
+    b = a
+    a = t
+  }
+
+  this._a = (a + this._a) | 0
+  this._b = (b + this._b) | 0
+  this._c = (c + this._c) | 0
+  this._d = (d + this._d) | 0
+  this._e = (e + this._e) | 0
+}
+
+Sha.prototype._hash = function () {
+  var H = Buffer.allocUnsafe(20)
+
+  H.writeInt32BE(this._a | 0, 0)
+  H.writeInt32BE(this._b | 0, 4)
+  H.writeInt32BE(this._c | 0, 8)
+  H.writeInt32BE(this._d | 0, 12)
+  H.writeInt32BE(this._e | 0, 16)
+
+  return H
+}
+
+module.exports = Sha
+
+},{"./hash":149,"inherits":107,"safe-buffer":148}],152:[function(require,module,exports){
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+var inherits = require('inherits')
+var Hash = require('./hash')
+var Buffer = require('safe-buffer').Buffer
+
+var K = [
+  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
+]
+
+var W = new Array(80)
+
+function Sha1 () {
+  this.init()
+  this._w = W
+
+  Hash.call(this, 64, 56)
+}
+
+inherits(Sha1, Hash)
+
+Sha1.prototype.init = function () {
+  this._a = 0x67452301
+  this._b = 0xefcdab89
+  this._c = 0x98badcfe
+  this._d = 0x10325476
+  this._e = 0xc3d2e1f0
+
+  return this
+}
+
+function rotl1 (num) {
+  return (num << 1) | (num >>> 31)
+}
+
+function rotl5 (num) {
+  return (num << 5) | (num >>> 27)
+}
+
+function rotl30 (num) {
+  return (num << 30) | (num >>> 2)
+}
+
+function ft (s, b, c, d) {
+  if (s === 0) return (b & c) | ((~b) & d)
+  if (s === 2) return (b & c) | (b & d) | (c & d)
+  return b ^ c ^ d
+}
+
+Sha1.prototype._update = function (M) {
+  var W = this._w
+
+  var a = this._a | 0
+  var b = this._b | 0
+  var c = this._c | 0
+  var d = this._d | 0
+  var e = this._e | 0
+
+  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
+  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])
+
+  for (var j = 0; j < 80; ++j) {
+    var s = ~~(j / 20)
+    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0
+
+    e = d
+    d = c
+    c = rotl30(b)
+    b = a
+    a = t
+  }
+
+  this._a = (a + this._a) | 0
+  this._b = (b + this._b) | 0
+  this._c = (c + this._c) | 0
+  this._d = (d + this._d) | 0
+  this._e = (e + this._e) | 0
+}
+
+Sha1.prototype._hash = function () {
+  var H = Buffer.allocUnsafe(20)
+
+  H.writeInt32BE(this._a | 0, 0)
+  H.writeInt32BE(this._b | 0, 4)
+  H.writeInt32BE(this._c | 0, 8)
+  H.writeInt32BE(this._d | 0, 12)
+  H.writeInt32BE(this._e | 0, 16)
+
+  return H
+}
+
+module.exports = Sha1
+
+},{"./hash":149,"inherits":107,"safe-buffer":148}],153:[function(require,module,exports){
+/**
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+ * in FIPS 180-2
+ * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ *
+ */
+
+var inherits = require('inherits')
+var Sha256 = require('./sha256')
+var Hash = require('./hash')
+var Buffer = require('safe-buffer').Buffer
+
+var W = new Array(64)
+
+function Sha224 () {
+  this.init()
+
+  this._w = W // new Array(64)
+
+  Hash.call(this, 64, 56)
+}
+
+inherits(Sha224, Sha256)
+
+Sha224.prototype.init = function () {
+  this._a = 0xc1059ed8
+  this._b = 0x367cd507
+  this._c = 0x3070dd17
+  this._d = 0xf70e5939
+  this._e = 0xffc00b31
+  this._f = 0x68581511
+  this._g = 0x64f98fa7
+  this._h = 0xbefa4fa4
+
+  return this
+}
+
+Sha224.prototype._hash = function () {
+  var H = Buffer.allocUnsafe(28)
+
+  H.writeInt32BE(this._a, 0)
+  H.writeInt32BE(this._b, 4)
+  H.writeInt32BE(this._c, 8)
+  H.writeInt32BE(this._d, 12)
+  H.writeInt32BE(this._e, 16)
+  H.writeInt32BE(this._f, 20)
+  H.writeInt32BE(this._g, 24)
+
+  return H
+}
+
+module.exports = Sha224
+
+},{"./hash":149,"./sha256":154,"inherits":107,"safe-buffer":148}],154:[function(require,module,exports){
+/**
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+ * in FIPS 180-2
+ * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ *
+ */
+
+var inherits = require('inherits')
+var Hash = require('./hash')
+var Buffer = require('safe-buffer').Buffer
+
+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 W = new Array(64)
+
+function Sha256 () {
+  this.init()
+
+  this._w = W // new Array(64)
+
+  Hash.call(this, 64, 56)
+}
+
+inherits(Sha256, Hash)
+
+Sha256.prototype.init = function () {
+  this._a = 0x6a09e667
+  this._b = 0xbb67ae85
+  this._c = 0x3c6ef372
+  this._d = 0xa54ff53a
+  this._e = 0x510e527f
+  this._f = 0x9b05688c
+  this._g = 0x1f83d9ab
+  this._h = 0x5be0cd19
+
+  return this
+}
+
+function ch (x, y, z) {
+  return z ^ (x & (y ^ z))
+}
+
+function maj (x, y, z) {
+  return (x & y) | (z & (x | y))
+}
+
+function sigma0 (x) {
+  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)
+}
+
+function sigma1 (x) {
+  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)
+}
+
+function gamma0 (x) {
+  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)
+}
+
+function gamma1 (x) {
+  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)
+}
+
+Sha256.prototype._update = function (M) {
+  var W = this._w
+
+  var a = this._a | 0
+  var b = this._b | 0
+  var c = this._c | 0
+  var d = this._d | 0
+  var e = this._e | 0
+  var f = this._f | 0
+  var g = this._g | 0
+  var h = this._h | 0
+
+  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
+  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0
+
+  for (var j = 0; j < 64; ++j) {
+    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0
+    var T2 = (sigma0(a) + maj(a, b, c)) | 0
+
+    h = g
+    g = f
+    f = e
+    e = (d + T1) | 0
+    d = c
+    c = b
+    b = a
+    a = (T1 + T2) | 0
+  }
+
+  this._a = (a + this._a) | 0
+  this._b = (b + this._b) | 0
+  this._c = (c + this._c) | 0
+  this._d = (d + this._d) | 0
+  this._e = (e + this._e) | 0
+  this._f = (f + this._f) | 0
+  this._g = (g + this._g) | 0
+  this._h = (h + this._h) | 0
+}
+
+Sha256.prototype._hash = function () {
+  var H = Buffer.allocUnsafe(32)
+
+  H.writeInt32BE(this._a, 0)
+  H.writeInt32BE(this._b, 4)
+  H.writeInt32BE(this._c, 8)
+  H.writeInt32BE(this._d, 12)
+  H.writeInt32BE(this._e, 16)
+  H.writeInt32BE(this._f, 20)
+  H.writeInt32BE(this._g, 24)
+  H.writeInt32BE(this._h, 28)
+
+  return H
+}
+
+module.exports = Sha256
+
+},{"./hash":149,"inherits":107,"safe-buffer":148}],155:[function(require,module,exports){
+var inherits = require('inherits')
+var SHA512 = require('./sha512')
+var Hash = require('./hash')
+var Buffer = require('safe-buffer').Buffer
+
+var W = new Array(160)
+
+function Sha384 () {
+  this.init()
+  this._w = W
+
+  Hash.call(this, 128, 112)
+}
+
+inherits(Sha384, SHA512)
+
+Sha384.prototype.init = function () {
+  this._ah = 0xcbbb9d5d
+  this._bh = 0x629a292a
+  this._ch = 0x9159015a
+  this._dh = 0x152fecd8
+  this._eh = 0x67332667
+  this._fh = 0x8eb44a87
+  this._gh = 0xdb0c2e0d
+  this._hh = 0x47b5481d
+
+  this._al = 0xc1059ed8
+  this._bl = 0x367cd507
+  this._cl = 0x3070dd17
+  this._dl = 0xf70e5939
+  this._el = 0xffc00b31
+  this._fl = 0x68581511
+  this._gl = 0x64f98fa7
+  this._hl = 0xbefa4fa4
+
+  return this
+}
+
+Sha384.prototype._hash = function () {
+  var H = Buffer.allocUnsafe(48)
+
+  function writeInt64BE (h, l, offset) {
+    H.writeInt32BE(h, offset)
+    H.writeInt32BE(l, offset + 4)
+  }
+
+  writeInt64BE(this._ah, this._al, 0)
+  writeInt64BE(this._bh, this._bl, 8)
+  writeInt64BE(this._ch, this._cl, 16)
+  writeInt64BE(this._dh, this._dl, 24)
+  writeInt64BE(this._eh, this._el, 32)
+  writeInt64BE(this._fh, this._fl, 40)
+
+  return H
+}
+
+module.exports = Sha384
+
+},{"./hash":149,"./sha512":156,"inherits":107,"safe-buffer":148}],156:[function(require,module,exports){
+var inherits = require('inherits')
+var Hash = require('./hash')
+var Buffer = require('safe-buffer').Buffer
+
+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
+]
+
+var W = new Array(160)
+
+function Sha512 () {
+  this.init()
+  this._w = W
+
+  Hash.call(this, 128, 112)
+}
+
+inherits(Sha512, Hash)
+
+Sha512.prototype.init = function () {
+  this._ah = 0x6a09e667
+  this._bh = 0xbb67ae85
+  this._ch = 0x3c6ef372
+  this._dh = 0xa54ff53a
+  this._eh = 0x510e527f
+  this._fh = 0x9b05688c
+  this._gh = 0x1f83d9ab
+  this._hh = 0x5be0cd19
+
+  this._al = 0xf3bcc908
+  this._bl = 0x84caa73b
+  this._cl = 0xfe94f82b
+  this._dl = 0x5f1d36f1
+  this._el = 0xade682d1
+  this._fl = 0x2b3e6c1f
+  this._gl = 0xfb41bd6b
+  this._hl = 0x137e2179
+
+  return this
+}
+
+function Ch (x, y, z) {
+  return z ^ (x & (y ^ z))
+}
+
+function maj (x, y, z) {
+  return (x & y) | (z & (x | y))
+}
+
+function sigma0 (x, xl) {
+  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)
+}
+
+function sigma1 (x, xl) {
+  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)
+}
+
+function Gamma0 (x, xl) {
+  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)
+}
+
+function Gamma0l (x, xl) {
+  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)
+}
+
+function Gamma1 (x, xl) {
+  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)
+}
+
+function Gamma1l (x, xl) {
+  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)
+}
+
+function getCarry (a, b) {
+  return (a >>> 0) < (b >>> 0) ? 1 : 0
+}
+
+Sha512.prototype._update = function (M) {
+  var W = this._w
+
+  var ah = this._ah | 0
+  var bh = this._bh | 0
+  var ch = this._ch | 0
+  var dh = this._dh | 0
+  var eh = this._eh | 0
+  var fh = this._fh | 0
+  var gh = this._gh | 0
+  var hh = this._hh | 0
+
+  var al = this._al | 0
+  var bl = this._bl | 0
+  var cl = this._cl | 0
+  var dl = this._dl | 0
+  var el = this._el | 0
+  var fl = this._fl | 0
+  var gl = this._gl | 0
+  var hl = this._hl | 0
+
+  for (var i = 0; i < 32; i += 2) {
+    W[i] = M.readInt32BE(i * 4)
+    W[i + 1] = M.readInt32BE(i * 4 + 4)
+  }
+  for (; i < 160; i += 2) {
+    var xh = W[i - 15 * 2]
+    var xl = W[i - 15 * 2 + 1]
+    var gamma0 = Gamma0(xh, xl)
+    var gamma0l = Gamma0l(xl, xh)
+
+    xh = W[i - 2 * 2]
+    xl = W[i - 2 * 2 + 1]
+    var gamma1 = Gamma1(xh, xl)
+    var gamma1l = Gamma1l(xl, xh)
+
+    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
+    var Wi7h = W[i - 7 * 2]
+    var Wi7l = W[i - 7 * 2 + 1]
+
+    var Wi16h = W[i - 16 * 2]
+    var Wi16l = W[i - 16 * 2 + 1]
+
+    var Wil = (gamma0l + Wi7l) | 0
+    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0
+    Wil = (Wil + gamma1l) | 0
+    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0
+    Wil = (Wil + Wi16l) | 0
+    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0
+
+    W[i] = Wih
+    W[i + 1] = Wil
+  }
+
+  for (var j = 0; j < 160; j += 2) {
+    Wih = W[j]
+    Wil = W[j + 1]
+
+    var majh = maj(ah, bh, ch)
+    var majl = maj(al, bl, cl)
+
+    var sigma0h = sigma0(ah, al)
+    var sigma0l = sigma0(al, ah)
+    var sigma1h = sigma1(eh, el)
+    var sigma1l = sigma1(el, eh)
+
+    // t1 = h + sigma1 + ch + K[j] + W[j]
+    var Kih = K[j]
+    var Kil = K[j + 1]
+
+    var chh = Ch(eh, fh, gh)
+    var chl = Ch(el, fl, gl)
+
+    var t1l = (hl + sigma1l) | 0
+    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0
+    t1l = (t1l + chl) | 0
+    t1h = (t1h + chh + getCarry(t1l, chl)) | 0
+    t1l = (t1l + Kil) | 0
+    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0
+    t1l = (t1l + Wil) | 0
+    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0
+
+    // t2 = sigma0 + maj
+    var t2l = (sigma0l + majl) | 0
+    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0
+
+    hh = gh
+    hl = gl
+    gh = fh
+    gl = fl
+    fh = eh
+    fl = el
+    el = (dl + t1l) | 0
+    eh = (dh + t1h + getCarry(el, dl)) | 0
+    dh = ch
+    dl = cl
+    ch = bh
+    cl = bl
+    bh = ah
+    bl = al
+    al = (t1l + t2l) | 0
+    ah = (t1h + t2h + getCarry(al, t1l)) | 0
+  }
+
+  this._al = (this._al + al) | 0
+  this._bl = (this._bl + bl) | 0
+  this._cl = (this._cl + cl) | 0
+  this._dl = (this._dl + dl) | 0
+  this._el = (this._el + el) | 0
+  this._fl = (this._fl + fl) | 0
+  this._gl = (this._gl + gl) | 0
+  this._hl = (this._hl + hl) | 0
+
+  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0
+  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0
+  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0
+  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0
+  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0
+  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0
+  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0
+  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0
+}
+
+Sha512.prototype._hash = function () {
+  var H = Buffer.allocUnsafe(64)
+
+  function writeInt64BE (h, l, offset) {
+    H.writeInt32BE(h, offset)
+    H.writeInt32BE(l, offset + 4)
+  }
+
+  writeInt64BE(this._ah, this._al, 0)
+  writeInt64BE(this._bh, this._bl, 8)
+  writeInt64BE(this._ch, this._cl, 16)
+  writeInt64BE(this._dh, this._dl, 24)
+  writeInt64BE(this._eh, this._el, 32)
+  writeInt64BE(this._fh, this._fl, 40)
+  writeInt64BE(this._gh, this._gl, 48)
+  writeInt64BE(this._hh, this._hl, 56)
+
+  return H
+}
+
+module.exports = Sha512
+
+},{"./hash":149,"inherits":107,"safe-buffer":148}],157:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Stream;
+
+var EE = require('events').EventEmitter;
+var inherits = require('inherits');
+
+inherits(Stream, EE);
+Stream.Readable = require('readable-stream/readable.js');
+Stream.Writable = require('readable-stream/writable.js');
+Stream.Duplex = require('readable-stream/duplex.js');
+Stream.Transform = require('readable-stream/transform.js');
+Stream.PassThrough = require('readable-stream/passthrough.js');
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+
+
+// old-style streams.  Note that the pipe method (the only relevant
+// part of this class) is overridden in the Readable class.
+
+function Stream() {
+  EE.call(this);
+}
+
+Stream.prototype.pipe = function(dest, options) {
+  var source = this;
+
+  function ondata(chunk) {
+    if (dest.writable) {
+      if (false === dest.write(chunk) && source.pause) {
+        source.pause();
+      }
+    }
+  }
+
+  source.on('data', ondata);
+
+  function ondrain() {
+    if (source.readable && source.resume) {
+      source.resume();
+    }
+  }
+
+  dest.on('drain', ondrain);
+
+  // If the 'end' option is not supplied, dest.end() will be called when
+  // source gets the 'end' or 'close' events.  Only dest.end() once.
+  if (!dest._isStdio && (!options || options.end !== false)) {
+    source.on('end', onend);
+    source.on('close', onclose);
+  }
+
+  var didOnEnd = false;
+  function onend() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    dest.end();
+  }
+
+
+  function onclose() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    if (typeof dest.destroy === 'function') dest.destroy();
+  }
+
+  // don't leave dangling pipes when there are errors.
+  function onerror(er) {
+    cleanup();
+    if (EE.listenerCount(this, 'error') === 0) {
+      throw er; // Unhandled stream error in pipe.
+    }
+  }
+
+  source.on('error', onerror);
+  dest.on('error', onerror);
+
+  // remove all the event listeners that were added.
+  function cleanup() {
+    source.removeListener('data', ondata);
+    dest.removeListener('drain', ondrain);
+
+    source.removeListener('end', onend);
+    source.removeListener('close', onclose);
+
+    source.removeListener('error', onerror);
+    dest.removeListener('error', onerror);
+
+    source.removeListener('end', cleanup);
+    source.removeListener('close', cleanup);
+
+    dest.removeListener('close', cleanup);
+  }
+
+  source.on('end', cleanup);
+  source.on('close', cleanup);
+
+  dest.on('close', cleanup);
+
+  dest.emit('pipe', source);
+
+  // Allow for unix-like usage: A.pipe(B).pipe(C)
+  return dest;
+};
+
+},{"events":90,"inherits":107,"readable-stream/duplex.js":134,"readable-stream/passthrough.js":143,"readable-stream/readable.js":144,"readable-stream/transform.js":145,"readable-stream/writable.js":146}],158:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+/*<replacement>*/
+
+var Buffer = require('safe-buffer').Buffer;
+/*</replacement>*/
+
+var isEncoding = Buffer.isEncoding || function (encoding) {
+  encoding = '' + encoding;
+  switch (encoding && encoding.toLowerCase()) {
+    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
+      return true;
+    default:
+      return false;
+  }
+};
+
+function _normalizeEncoding(enc) {
+  if (!enc) return 'utf8';
+  var retried;
+  while (true) {
+    switch (enc) {
+      case 'utf8':
+      case 'utf-8':
+        return 'utf8';
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return 'utf16le';
+      case 'latin1':
+      case 'binary':
+        return 'latin1';
+      case 'base64':
+      case 'ascii':
+      case 'hex':
+        return enc;
+      default:
+        if (retried) return; // undefined
+        enc = ('' + enc).toLowerCase();
+        retried = true;
+    }
+  }
+};
+
+// Do not cache `Buffer.isEncoding` when checking encoding names as some
+// modules monkey-patch it to support additional encodings
+function normalizeEncoding(enc) {
+  var nenc = _normalizeEncoding(enc);
+  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
+  return nenc || enc;
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters.
+exports.StringDecoder = StringDecoder;
+function StringDecoder(encoding) {
+  this.encoding = normalizeEncoding(encoding);
+  var nb;
+  switch (this.encoding) {
+    case 'utf16le':
+      this.text = utf16Text;
+      this.end = utf16End;
+      nb = 4;
+      break;
+    case 'utf8':
+      this.fillLast = utf8FillLast;
+      nb = 4;
+      break;
+    case 'base64':
+      this.text = base64Text;
+      this.end = base64End;
+      nb = 3;
+      break;
+    default:
+      this.write = simpleWrite;
+      this.end = simpleEnd;
+      return;
+  }
+  this.lastNeed = 0;
+  this.lastTotal = 0;
+  this.lastChar = Buffer.allocUnsafe(nb);
+}
+
+StringDecoder.prototype.write = function (buf) {
+  if (buf.length === 0) return '';
+  var r;
+  var i;
+  if (this.lastNeed) {
+    r = this.fillLast(buf);
+    if (r === undefined) return '';
+    i = this.lastNeed;
+    this.lastNeed = 0;
+  } else {
+    i = 0;
+  }
+  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+  return r || '';
+};
+
+StringDecoder.prototype.end = utf8End;
+
+// Returns only complete characters in a Buffer
+StringDecoder.prototype.text = utf8Text;
+
+// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+StringDecoder.prototype.fillLast = function (buf) {
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+  this.lastNeed -= buf.length;
+};
+
+// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+// continuation byte. If an invalid byte is detected, -2 is returned.
+function utf8CheckByte(byte) {
+  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
+  return byte >> 6 === 0x02 ? -1 : -2;
+}
+
+// Checks at most 3 bytes at the end of a Buffer in order to detect an
+// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+// needed to complete the UTF-8 character (if applicable) are returned.
+function utf8CheckIncomplete(self, buf, i) {
+  var j = buf.length - 1;
+  if (j < i) return 0;
+  var nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) self.lastNeed = nb - 1;
+    return nb;
+  }
+  if (--j < i || nb === -2) return 0;
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) self.lastNeed = nb - 2;
+    return nb;
+  }
+  if (--j < i || nb === -2) return 0;
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) {
+      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
+    }
+    return nb;
+  }
+  return 0;
+}
+
+// Validates as many continuation bytes for a multi-byte UTF-8 character as
+// needed or are available. If we see a non-continuation byte where we expect
+// one, we "replace" the validated continuation bytes we've seen so far with
+// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+// behavior. The continuation byte check is included three times in the case
+// where all of the continuation bytes for a character exist in the same buffer.
+// It is also done this way as a slight performance increase instead of using a
+// loop.
+function utf8CheckExtraBytes(self, buf, p) {
+  if ((buf[0] & 0xC0) !== 0x80) {
+    self.lastNeed = 0;
+    return '\ufffd';
+  }
+  if (self.lastNeed > 1 && buf.length > 1) {
+    if ((buf[1] & 0xC0) !== 0x80) {
+      self.lastNeed = 1;
+      return '\ufffd';
+    }
+    if (self.lastNeed > 2 && buf.length > 2) {
+      if ((buf[2] & 0xC0) !== 0x80) {
+        self.lastNeed = 2;
+        return '\ufffd';
+      }
+    }
+  }
+}
+
+// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+function utf8FillLast(buf) {
+  var p = this.lastTotal - this.lastNeed;
+  var r = utf8CheckExtraBytes(this, buf, p);
+  if (r !== undefined) return r;
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, p, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, p, 0, buf.length);
+  this.lastNeed -= buf.length;
+}
+
+// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+// partial character, the character's bytes are buffered until the required
+// number of bytes are available.
+function utf8Text(buf, i) {
+  var total = utf8CheckIncomplete(this, buf, i);
+  if (!this.lastNeed) return buf.toString('utf8', i);
+  this.lastTotal = total;
+  var end = buf.length - (total - this.lastNeed);
+  buf.copy(this.lastChar, 0, end);
+  return buf.toString('utf8', i, end);
+}
+
+// For UTF-8, a replacement character is added when ending on a partial
+// character.
+function utf8End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) return r + '\ufffd';
+  return r;
+}
+
+// UTF-16LE typically needs two bytes per character, but even if we have an even
+// number of bytes available, we need to check if we end on a leading/high
+// surrogate. In that case, we need to wait for the next two bytes in order to
+// decode the last character properly.
+function utf16Text(buf, i) {
+  if ((buf.length - i) % 2 === 0) {
+    var r = buf.toString('utf16le', i);
+    if (r) {
+      var c = r.charCodeAt(r.length - 1);
+      if (c >= 0xD800 && c <= 0xDBFF) {
+        this.lastNeed = 2;
+        this.lastTotal = 4;
+        this.lastChar[0] = buf[buf.length - 2];
+        this.lastChar[1] = buf[buf.length - 1];
+        return r.slice(0, -1);
+      }
+    }
+    return r;
+  }
+  this.lastNeed = 1;
+  this.lastTotal = 2;
+  this.lastChar[0] = buf[buf.length - 1];
+  return buf.toString('utf16le', i, buf.length - 1);
+}
+
+// For UTF-16LE we do not explicitly append special replacement characters if we
+// end on a partial character, we simply let v8 handle that.
+function utf16End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) {
+    var end = this.lastTotal - this.lastNeed;
+    return r + this.lastChar.toString('utf16le', 0, end);
+  }
+  return r;
+}
+
+function base64Text(buf, i) {
+  var n = (buf.length - i) % 3;
+  if (n === 0) return buf.toString('base64', i);
+  this.lastNeed = 3 - n;
+  this.lastTotal = 3;
+  if (n === 1) {
+    this.lastChar[0] = buf[buf.length - 1];
+  } else {
+    this.lastChar[0] = buf[buf.length - 2];
+    this.lastChar[1] = buf[buf.length - 1];
+  }
+  return buf.toString('base64', i, buf.length - n);
+}
+
+function base64End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
+  return r;
+}
+
+// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
+function simpleWrite(buf) {
+  return buf.toString(this.encoding);
+}
+
+function simpleEnd(buf) {
+  return buf && buf.length ? this.write(buf) : '';
+}
+},{"safe-buffer":148}],159:[function(require,module,exports){
+(function (setImmediate,clearImmediate){
+var nextTick = require('process/browser.js').nextTick;
+var apply = Function.prototype.apply;
+var slice = Array.prototype.slice;
+var immediateIds = {};
+var nextImmediateId = 0;
+
+// DOM APIs, for completeness
+
+exports.setTimeout = function() {
+  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
+};
+exports.setInterval = function() {
+  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
+};
+exports.clearTimeout =
+exports.clearInterval = function(timeout) { timeout.close(); };
+
+function Timeout(id, clearFn) {
+  this._id = id;
+  this._clearFn = clearFn;
+}
+Timeout.prototype.unref = Timeout.prototype.ref = function() {};
+Timeout.prototype.close = function() {
+  this._clearFn.call(window, this._id);
+};
+
+// Does not start the time, just sets up the members needed.
+exports.enroll = function(item, msecs) {
+  clearTimeout(item._idleTimeoutId);
+  item._idleTimeout = msecs;
+};
+
+exports.unenroll = function(item) {
+  clearTimeout(item._idleTimeoutId);
+  item._idleTimeout = -1;
+};
+
+exports._unrefActive = exports.active = function(item) {
+  clearTimeout(item._idleTimeoutId);
+
+  var msecs = item._idleTimeout;
+  if (msecs >= 0) {
+    item._idleTimeoutId = setTimeout(function onTimeout() {
+      if (item._onTimeout)
+        item._onTimeout();
+    }, msecs);
+  }
+};
+
+// That's not how node.js implements it but the exposed api is the same.
+exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
+  var id = nextImmediateId++;
+  var args = arguments.length < 2 ? false : slice.call(arguments, 1);
+
+  immediateIds[id] = true;
+
+  nextTick(function onNextTick() {
+    if (immediateIds[id]) {
+      // fn.call() is faster so we optimize for the common use-case
+      // @see http://jsperf.com/call-apply-segu
+      if (args) {
+        fn.apply(null, args);
+      } else {
+        fn.call(null);
+      }
+      // Prevent ids from leaking
+      exports.clearImmediate(id);
+    }
+  });
+
+  return id;
+};
+
+exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
+  delete immediateIds[id];
+};
+}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
+},{"process/browser.js":125,"timers":159}],160:[function(require,module,exports){
+(function (global){
+
+/**
+ * Module exports.
+ */
+
+module.exports = deprecate;
+
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
+
+function deprecate (fn, msg) {
+  if (config('noDeprecation')) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (config('throwDeprecation')) {
+        throw new Error(msg);
+      } else if (config('traceDeprecation')) {
+        console.trace(msg);
+      } else {
+        console.warn(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+}
+
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
+
+function config (name) {
+  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+  try {
+    if (!global.localStorage) return false;
+  } catch (_) {
+    return false;
+  }
+  var val = global.localStorage[name];
+  if (null == val) return false;
+  return String(val).toLowerCase() === 'true';
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],161:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+  return arg && typeof arg === 'object'
+    && typeof arg.copy === 'function'
+    && typeof arg.fill === 'function'
+    && typeof arg.readUInt8 === 'function';
+}
+},{}],162:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+  if (!isString(f)) {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(inspect(arguments[i]));
+    }
+    return objects.join(' ');
+  }
+
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function(x) {
+    if (x === '%%') return '%';
+    if (i >= len) return x;
+    switch (x) {
+      case '%s': return String(args[i++]);
+      case '%d': return Number(args[i++]);
+      case '%j':
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (_) {
+          return '[Circular]';
+        }
+      default:
+        return x;
+    }
+  });
+  for (var x = args[i]; i < len; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += ' ' + x;
+    } else {
+      str += ' ' + inspect(x);
+    }
+  }
+  return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+  // Allow for deprecating things in the process of starting up.
+  if (isUndefined(global.process)) {
+    return function() {
+      return exports.deprecate(fn, msg).apply(this, arguments);
+    };
+  }
+
+  if (process.noDeprecation === true) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (process.throwDeprecation) {
+        throw new Error(msg);
+      } else if (process.traceDeprecation) {
+        console.trace(msg);
+      } else {
+        console.error(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+  if (isUndefined(debugEnviron))
+    debugEnviron = process.env.NODE_DEBUG || '';
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+      var pid = process.pid;
+      debugs[set] = function() {
+        var msg = exports.format.apply(exports, arguments);
+        console.error('%s %d: %s', set, pid, msg);
+      };
+    } else {
+      debugs[set] = function() {};
+    }
+  }
+  return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+  // default options
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  // legacy...
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    // legacy...
+    ctx.showHidden = opts;
+  } else if (opts) {
+    // got an "options" object
+    exports._extend(ctx, opts);
+  }
+  // set default options
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+  'bold' : [1, 22],
+  'italic' : [3, 23],
+  'underline' : [4, 24],
+  'inverse' : [7, 27],
+  'white' : [37, 39],
+  'grey' : [90, 39],
+  'black' : [30, 39],
+  'blue' : [34, 39],
+  'cyan' : [36, 39],
+  'green' : [32, 39],
+  'magenta' : [35, 39],
+  'red' : [31, 39],
+  'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+  'special': 'cyan',
+  'number': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'date': 'magenta',
+  // "name": intentionally not styling
+  'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+
+  if (style) {
+    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+           '\u001b[' + inspect.colors[style][1] + 'm';
+  } else {
+    return str;
+  }
+}
+
+
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+
+
+function arrayToHash(array) {
+  var hash = {};
+
+  array.forEach(function(val, idx) {
+    hash[val] = true;
+  });
+
+  return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect &&
+      value &&
+      isFunction(value.inspect) &&
+      // Filter out the util module, it's inspect function is special
+      value.inspect !== exports.inspect &&
+      // Also filter out any prototype objects using the circular check.
+      !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var keys = Object.keys(value);
+  var visibleKeys = arrayToHash(keys);
+
+  if (ctx.showHidden) {
+    keys = Object.getOwnPropertyNames(value);
+  }
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value)
+      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(value);
+  }
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+
+  var base = '', array = false, braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (isFunction(value)) {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function(key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value))
+    return ctx.stylize('undefined', 'undefined');
+  if (isString(value)) {
+    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                             .replace(/'/g, "\\'")
+                                             .replace(/\\"/g, '"') + '\'';
+    return ctx.stylize(simple, 'string');
+  }
+  if (isNumber(value))
+    return ctx.stylize('' + value, 'number');
+  if (isBoolean(value))
+    return ctx.stylize('' + value, 'boolean');
+  // For some reason typeof null is "object", so special case here.
+  if (isNull(value))
+    return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+  return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwnProperty(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function(key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          key, true));
+    }
+  });
+  return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize('[Setter]', 'special');
+    }
+  }
+  if (!hasOwnProperty(visibleKeys, key)) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function(line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function(line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'")
+                 .replace(/\\"/g, '"')
+                 .replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function(prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] +
+           (base === '' ? '' : base + '\n ') +
+           ' ' +
+           output.join(',\n  ') +
+           ' ' +
+           braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return isObject(e) &&
+      (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+              'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()),
+              pad(d.getMinutes()),
+              pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+  // Don't do anything if add isn't an object
+  if (!add || !isObject(add)) return origin;
+
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":161,"_process":125,"inherits":107}],163:[function(require,module,exports){
+var indexOf = function (xs, item) {
+    if (xs.indexOf) return xs.indexOf(item);
+    else for (var i = 0; i < xs.length; i++) {
+        if (xs[i] === item) return i;
+    }
+    return -1;
+};
+var Object_keys = function (obj) {
+    if (Object.keys) return Object.keys(obj)
+    else {
+        var res = [];
+        for (var key in obj) res.push(key)
+        return res;
+    }
+};
+
+var forEach = function (xs, fn) {
+    if (xs.forEach) return xs.forEach(fn)
+    else for (var i = 0; i < xs.length; i++) {
+        fn(xs[i], i, xs);
+    }
+};
+
+var defineProp = (function() {
+    try {
+        Object.defineProperty({}, '_', {});
+        return function(obj, name, value) {
+            Object.defineProperty(obj, name, {
+                writable: true,
+                enumerable: false,
+                configurable: true,
+                value: value
+            })
+        };
+    } catch(e) {
+        return function(obj, name, value) {
+            obj[name] = value;
+        };
+    }
+}());
+
+var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function',
+'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError',
+'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError',
+'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape',
+'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'];
+
+function Context() {}
+Context.prototype = {};
+
+var Script = exports.Script = function NodeScript (code) {
+    if (!(this instanceof Script)) return new Script(code);
+    this.code = code;
+};
+
+Script.prototype.runInContext = function (context) {
+    if (!(context instanceof Context)) {
+        throw new TypeError("needs a 'context' argument.");
+    }
+    
+    var iframe = document.createElement('iframe');
+    if (!iframe.style) iframe.style = {};
+    iframe.style.display = 'none';
+    
+    document.body.appendChild(iframe);
+    
+    var win = iframe.contentWindow;
+    var wEval = win.eval, wExecScript = win.execScript;
+
+    if (!wEval && wExecScript) {
+        // win.eval() magically appears when this is called in IE:
+        wExecScript.call(win, 'null');
+        wEval = win.eval;
+    }
+    
+    forEach(Object_keys(context), function (key) {
+        win[key] = context[key];
+    });
+    forEach(globals, function (key) {
+        if (context[key]) {
+            win[key] = context[key];
+        }
+    });
+    
+    var winKeys = Object_keys(win);
+
+    var res = wEval.call(win, this.code);
+    
+    forEach(Object_keys(win), function (key) {
+        // Avoid copying circular objects like `top` and `window` by only
+        // updating existing context properties or new properties in the `win`
+        // that was only introduced after the eval.
+        if (key in context || indexOf(winKeys, key) === -1) {
+            context[key] = win[key];
+        }
+    });
+
+    forEach(globals, function (key) {
+        if (!(key in context)) {
+            defineProp(context, key, win[key]);
+        }
+    });
+    
+    document.body.removeChild(iframe);
+    
+    return res;
+};
+
+Script.prototype.runInThisContext = function () {
+    return eval(this.code); // maybe...
+};
+
+Script.prototype.runInNewContext = function (context) {
+    var ctx = Script.createContext(context);
+    var res = this.runInContext(ctx);
+
+    if (context) {
+        forEach(Object_keys(ctx), function (key) {
+            context[key] = ctx[key];
+        });
+    }
+
+    return res;
+};
+
+forEach(Object_keys(Script.prototype), function (name) {
+    exports[name] = Script[name] = function (code) {
+        var s = Script(code);
+        return s[name].apply(s, [].slice.call(arguments, 1));
+    };
+});
+
+exports.createScript = function (code) {
+    return exports.Script(code);
+};
+
+exports.createContext = Script.createContext = function (context) {
+    var copy = new Context();
+    if(typeof context === 'object') {
+        forEach(Object_keys(context), function (key) {
+            copy[key] = context[key];
+        });
+    }
+    return copy;
+};
+
+},{}]},{},[1]);
+
+    </script>
     <!---------------------------------------------------------------------------------- 
                                 localbitcoinplusplus Code starts 
     ----------------------------------------------------------------------------------->
@@ -12023,7 +37091,7 @@
 
         //var wsUri = "ws://localhost:9000/";
         //var wsUri = "ws://ranchimall.duckdns.org:9000/";
-        var wsUri = "ws://ranchimall1.duckdns.org:9000/";
+        var wsUri = "ws://ranchimall1.duckdns.org:9002/";
         //var wsUri = "ws://167.99.5.116:9000/";
         var output;
 
@@ -13897,7 +38965,7 @@
                         currency: "USD"
                     } 
                 }
-               // let data = {trader_flo_address: genAddr.address}
+                //let data = {id: rand(10000, 100000000, 100000000)}
             localbitcoinplusplus.kademlia
                 .addNewUserNodeInKbucket("FLO_TEST", genAddr.address, data);
             }

From 8352094bf3554b48c32eafcb9f976bc8228fe2bb Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Sun, 10 Feb 2019 14:09:29 +0530
Subject: [PATCH 04/12] formation of kbucket from various participating node
 happenning

---
 supernode/index.html | 109 ++++++++++++++++++++++++++++---------------
 1 file changed, 72 insertions(+), 37 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index 93f8759..3534229 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -9144,8 +9144,8 @@
                         const incumbent = node.contacts[index]
                         
                         /***************Change made by Abhishek*************/
-                        //const selection = this.arbiter(incumbent, contact)
-                        const selection = localbitcoinplusplus.kademlia.arbiter(incumbent, contact);
+                        const selection = this.arbiter(incumbent, contact)
+                        //const selection = localbitcoinplusplus.kademlia.arbiter(incumbent, contact);
                         // if the selection is our old contact and the candidate is some new
                         // contact, then there is nothing to do
                         if (selection === incumbent && incumbent !== contact) return
@@ -34683,9 +34683,9 @@ exports.createContext = Script.createContext = function (context) {
                         `tradableAsset1=BTC,FLO,BTC_TEST,FLO_TEST#!#tradableAsset2=INR,USD,BTC,FLO,BTC_TEST,FLO_TEST,
                         #!#supernodes=127.0.0.1,212.88.88.2#!#MASTER_NODE=023B9F60692A17FAC805D012C5C8ADA3DD19A980A3C5F0D8A5B3500CC54D6E8B75
                         #!#MASTER_RECEIVING_ADDRESS=oVRq2nka1GtALQT8pbuLHAGjqAQ7PAo6uy#!#validTradingAmount=10000,50000,100000,#!#btcTradeMargin=5000
-                        #!#supernodesPubKeys=021E444E83530F0D6DB1D2121EE0696BAF5775F2BDD0D8F0301C63974816D91929,
-                        #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3","testjs":"5b10c1e79b9a7f3b2fb94f1d0f4c6219918f7d4bc5e9eee97deac888d248e7e2"},
-                        #!#ShamirsMaxShares=8`;
+                        #!#supernodesPubKeys=02B2D2F40EC5BC9D336BAF14017D629B3A96892D5E86095923A50A734E2364FB34,
+                        #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3"},
+                        #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"167.99.5.116","port":"9002"}}`;
                     let floAssetsArray = RMAssets.split('#!#');
 
                     if (floAssetsArray.length > 0 && typeof floAssetsArray[0] !== undefined &&
@@ -34864,7 +34864,16 @@ exports.createContext = Script.createContext = function (context) {
 
                 return merged;
             },
-
+            newBase64DiscoverId: function(pubKey) {
+                let  pubKeyBytes = Crypto.util.hexToBytes(pubKey);
+                return Crypto.util.bytesToBase64(pubKeyBytes);
+            },
+            getSupernodeSeed: function() {
+                const su_seeds = localbitcoinplusplus.master_configurations.supernodeSeeds;
+                const su_seeds_obj = JSON.parse(su_seeds);
+                const su_addr = `ws://${su_seeds_obj.ranchimall1.ip}:${su_seeds_obj.ranchimall1.port}/`;
+                return su_addr;
+            }, 
         }
    </script>
 
@@ -37089,18 +37098,17 @@ exports.createContext = Script.createContext = function (context) {
        
         /* Websocket Code Starts here */
 
-        //var wsUri = "ws://localhost:9000/";
-        //var wsUri = "ws://ranchimall.duckdns.org:9000/";
-        var wsUri = "ws://ranchimall1.duckdns.org:9002/";
-        //var wsUri = "ws://167.99.5.116:9000/";
         var output;
 
         function init() {
             output = document.getElementById("output_div");
-            startWebSocket();
+            return new Promise(resolve=>{
+                wsUri = localbitcoinplusplus.kademlia.getSupernodeSeed();
+                resolve(startWebSocket(wsUri));
+            });
         }
 
-        function startWebSocket() {
+        function startWebSocket(wsUri) {
             websocket = new WebSocket(wsUri);
             websocket.onopen = function (evt) {
                 onOpen(evt)
@@ -37117,7 +37125,9 @@ exports.createContext = Script.createContext = function (context) {
         }
 
         function onOpen(evt) {
-            doShreeGanesh();
+            //doShreeGanesh();
+            loadExternalFiles();
+            dataBaseUIOperations();
             writeToScreen("CONNECTED");
         }
 
@@ -37707,6 +37717,16 @@ exports.createContext = Script.createContext = function (context) {
                                     });
                                 break;
 
+                            case "addNewKbucketNode":
+                                    try {
+                                        const newKbucketObject = res_obj.params[0];
+                                        localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
+                                            newKbucketObject.newKbucketNode.id, newKbucketObject.newKbucketNode.data);      
+                                    } catch (error) {
+                                        console.error(error);
+                                    }
+                                break;
+
                             case "testMessageBroadcasting":
                                 console.log(res_obj);
                                 try {
@@ -37750,8 +37770,6 @@ exports.createContext = Script.createContext = function (context) {
             output.appendChild(pre);
         }
 
-        window.addEventListener("load", init, false);
-
         /* Websocket Code Ends Here*/
     </script>
 
@@ -37868,7 +37886,7 @@ exports.createContext = Script.createContext = function (context) {
 
         var db;
         const DBName = "localbitcoinDB";
-        var request = window.indexedDB.open(DBName, 2);
+        var request = window.indexedDB.open(DBName, 1);
 
         request.onerror = function (event) {
             //https://stackoverflow.com/questions/13972385/invalidstateerror-while-opening-indexeddb-in-firefox
@@ -38154,8 +38172,7 @@ exports.createContext = Script.createContext = function (context) {
         const doShreeGanesh = () => {
             try {
                 var rm_configs = localbitcoinplusplus.actions.fetch_configs(async function (...fetch_configs_res) {
-                    await loadExternalFiles();
-                    await dataBaseUIOperations();
+                    await init();
                     window.bitjs = []; // Launch bitjs
                     await localbitcoinplusplus.master_configurations.tradableAsset1.map(asset=>bitjslib(asset));
                 });
@@ -38163,6 +38180,7 @@ exports.createContext = Script.createContext = function (context) {
                 throw new Error(`Failed to fetch configurations: ${error}`);
             }
         }
+        doShreeGanesh();
     </script>
 
     <script>
@@ -38270,10 +38288,16 @@ exports.createContext = Script.createContext = function (context) {
                             // Add new user node in Kademlia
                             addDB('kBucketStore', {
                                 id: localbitcoinplusplusObj.myLocalFLOAddress,
-                                data: {"trader_flo_address": localbitcoinplusplusObj.myLocalFLOAddress},
+                                data: {id: localbitcoinplusplusObj.myLocalFLOAddress, vectorClock: 0},
                             }).then(dbObj=>{
-                                // localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
-                                //     dbObj.id, dbObj.data);
+                                 localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
+                                     dbObj.id, dbObj.data);
+                                     let addNewKNode = localbitcoinplusplus.rpc.prototype
+                                        .send_rpc
+                                        .call(this, "addNewKbucketNode",
+                                        {newKbucketNode:dbObj});
+                                     console.log(addNewKNode);
+                                     doSend(addNewKNode);
                             });
                             
                             RM_WALLET.distributeShamirsSecretShares(newKeys.privateKeyWIF)
@@ -38287,6 +38311,17 @@ exports.createContext = Script.createContext = function (context) {
                     const MY_LOCAL_FLO_ADDRESS = localbitcoinplusplus.wallets.my_local_flo_address = idbData.myLocalFLOAddress;
                     const MY_LOCAL_FLO_PUBLIC_KEY = localbitcoinplusplus.wallets.my_local_flo_public_key = idbData.myLocalFLOPublicKey;
                     
+                    // restore k-bucket
+                    readDB('kBucketStore', MY_LOCAL_FLO_ADDRESS).then(dbObj=>{
+                        localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
+                            dbObj.id, dbObj.data);
+                        let addNewKNode = localbitcoinplusplus.rpc.prototype
+                            .send_rpc
+                            .call(this, "addNewKbucketNode",
+                            {newKbucketNode:dbObj});
+                        doSend(addNewKNode);
+                    });
+                                
                     readDB('userPublicData', MY_LOCAL_FLO_ADDRESS).then(function(pubic_data_response) {
                         if (typeof pubic_data_response !== "object") {
                             let user_public_data_object = {
@@ -38950,22 +38985,22 @@ exports.createContext = Script.createContext = function (context) {
             const RM_WALLET = new localbitcoinplusplus.wallets;
             for (let index = 0; index < count; index++) {
                 let genAddr = RM_WALLET.generateFloKeys();
-                let data = {
-                    trader_flo_address: genAddr.address,
-                    crypto_balances: {
-                        crypto_balance: rand(1,100,100),
-                        crypto_currency: "FLO_TEST",
-                        id: genAddr.address+"_FLO_TEST",
-                        trader_flo_address: genAddr.address
-                    },
-                    cash_balances: {
-                        id: genAddr.address+"_USD",
-                        trader_flo_address: genAddr.address,
-                        cash_balance: rand(10000, 1000000, 1000000),
-                        currency: "USD"
-                    } 
-                }
-                //let data = {id: rand(10000, 100000000, 100000000)}
+                // let data = {
+                //     trader_flo_address: genAddr.address,
+                //     crypto_balances: {
+                //         crypto_balance: rand(1,100,100),
+                //         crypto_currency: "FLO_TEST",
+                //         id: genAddr.address+"_FLO_TEST",
+                //         trader_flo_address: genAddr.address
+                //     },
+                //     cash_balances: {
+                //         id: genAddr.address+"_USD",
+                //         trader_flo_address: genAddr.address,
+                //         cash_balance: rand(10000, 1000000, 1000000),
+                //         currency: "USD"
+                //     } 
+                // }
+                let data = {id: genAddr.address, vectorClock: 0}
             localbitcoinplusplus.kademlia
                 .addNewUserNodeInKbucket("FLO_TEST", genAddr.address, data);
             }

From b0a722e59031d8708dc47f13f2c455c90ae75f93 Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Tue, 12 Feb 2019 16:06:48 +0530
Subject: [PATCH 05/12] tuned the code ac to discover kbucket

---
 supernode/index.html | 195 +++++++++++++++++++++++++++++--------------
 1 file changed, 134 insertions(+), 61 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index 3534229..fbd3c70 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -34850,6 +34850,14 @@ exports.createContext = Script.createContext = function (context) {
                 const addNewUserNode = this.addContact(decodedId, data);
                 return addNewUserNode;
             },   
+            floIdToKbucketId: function(blockchain, address) {
+                const decodedId = this.decodeBase58Address(blockchain, address);
+                const nodeId = new Uint8Array(decodedId.length)
+                for (let i = 0, len = nodeId.length; i < len; ++i) {
+                    nodeId[i] = decodedId.charCodeAt(i)
+                }
+                return nodeId;
+            },
             arbiter: function(incumbent, candidate) {
                 // we create a new object so that our selection is guaranteed to replace
                 // the incumbent
@@ -34868,11 +34876,42 @@ exports.createContext = Script.createContext = function (context) {
                 let  pubKeyBytes = Crypto.util.hexToBytes(pubKey);
                 return Crypto.util.bytesToBase64(pubKeyBytes);
             },
-            getSupernodeSeed: function() {
-                const su_seeds = localbitcoinplusplus.master_configurations.supernodeSeeds;
-                const su_seeds_obj = JSON.parse(su_seeds);
-                const su_addr = `ws://${su_seeds_obj.ranchimall1.ip}:${su_seeds_obj.ranchimall1.port}/`;
-                return su_addr;
+            getSupernodeSeed: function(flo_addr, flo_pub_key) {
+                return new Promise((resolve, reject)=>{
+                    const supernodeSeeds = localbitcoinplusplus.master_configurations.supernodeSeeds;
+                    if (typeof supernodeSeeds!=="object") throw new Error("Failed to get supernode seeds.");
+                    const supernodeSeedsObj = JSON.parse(supernodeSeeds);
+
+                    const contactId = localbitcoinplusplus.kademlia.newBase64DiscoverId(flo_pub_key);
+            
+                    const seedContactArray = {
+                        id: contactId, // Base64 encoding 
+                        data: {
+                            publicKey: flo_pub_key,
+                            floId: flo_addr,
+                            msg: `Hello from ${flo_addr}!`
+                        },
+                    };
+
+                    if (!localbitcoinplusplus.master_configurations
+                        .supernodesPubKeys.includes(flo_pub_key)) {
+                        seedContactArray.transport = {
+                            host: supernodeSeedsObj.ranchimall1.ip,
+                            port: supernodeSeedsObj.ranchimall1.port
+                        }
+                    }
+
+                    const nodeDiscoveryOptions = {
+                        seeds: seedContactArray
+                    }
+                    
+                    const kdiscover = new tristanDiscover(nodeDiscoveryOptions);
+                    console.log(kdiscover);
+
+                    let supernodeAddress = `ws://ranchimall1.duckdns.org:9002`;
+
+                    resolve(supernodeAddress);
+                });
             }, 
         }
    </script>
@@ -37102,30 +37141,83 @@ exports.createContext = Script.createContext = function (context) {
 
         function init() {
             output = document.getElementById("output_div");
+            const RM_WALLET = new localbitcoinplusplus.wallets;
             return new Promise(resolve=>{
-                wsUri = localbitcoinplusplus.kademlia.getSupernodeSeed();
-                resolve(startWebSocket(wsUri));
+
+                readDB("localbitcoinUser", "00-01").then(async function (idbData) {
+                    if (typeof idbData.myLocalFLOPublicKey == "undefined" || idbData.myLocalFLOPublicKey
+                        .trim() == '') {
+                        let user_pvt_key = prompt("Please Enter a valid FLO private key if you have any. Else leave blank.");
+                       
+                        if (user_pvt_key.trim() == "" || user_pvt_key.length<1) user_pvt_key = null;
+                        
+                        let newKeys = RM_WALLET.generateFloKeys(user_pvt_key);
+                        if (typeof newKeys == 'object' && newKeys.privateKeyWIF.length > 0 
+                            && newKeys.address.length > 0) {
+                            localbitcoinplusplusObj.myLocalFLOAddress = newKeys.address;
+                            localbitcoinplusplusObj.myLocalFLOPublicKey = newKeys.pubKeyHex;
+                            
+                            updateinDB("localbitcoinUser", localbitcoinplusplusObj, "00-01");
+                    
+                            wsUri = await localbitcoinplusplus.kademlia.getSupernodeSeed(localbitcoinplusplusObj.myLocalFLOAddress,
+                                localbitcoinplusplusObj.myLocalFLOPublicKey);
+                            
+                            await startWebSocket(wsUri);
+
+                            // Add new user node in Kademlia
+                            addDB('kBucketStore', {
+                                id: localbitcoinplusplusObj.myLocalFLOAddress,
+                                data: {id: localbitcoinplusplusObj.myLocalFLOAddress, vectorClock: 0},
+                            }).then(dbObj=>{
+                                localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
+                                    dbObj.id, dbObj.data);
+                                let addNewKNode = localbitcoinplusplus.rpc.prototype
+                                    .send_rpc
+                                    .call(this, "addNewKbucketNode",
+                                    {newKbucketNode:dbObj});
+                                console.log(addNewKNode);
+                                doSend(addNewKNode);
+                            });
+                            
+                            RM_WALLET.distributeShamirsSecretShares(newKeys.privateKeyWIF)
+                                .then(()=>privateKeyBuilder());
+
+                            resolve(true);
+                            return;
+                            
+                        } else {
+                            throw new Error("Failed to generate new FLO keys. Please retry.");
+                        }
+                    }
+
+                    wsUri = await localbitcoinplusplus.kademlia.getSupernodeSeed(localbitcoinplusplusObj.myLocalFLOAddress,
+                        localbitcoinplusplusObj.myLocalFLOPublicKey);
+                    
+                    resolve(startWebSocket(wsUri));
+                });
+
             });
         }
-
+        
         function startWebSocket(wsUri) {
-            websocket = new WebSocket(wsUri);
-            websocket.onopen = function (evt) {
-                onOpen(evt)
-            };
-            websocket.onclose = function (evt) {
-                onClose(evt)
-            };
-            websocket.onmessage = function (evt) {
-                onMessage(evt)
-            };
-            websocket.onerror = function (evt) {
-                onError(evt)
-            };
+            return new Promise((resolve, reject)=>{
+                websocket = new WebSocket(wsUri);
+                websocket.onopen = function (evt) {
+                    resolve(onOpen(evt))
+                };
+                websocket.onclose = function (evt) {
+                    resolve(onClose(evt))
+                };
+                websocket.onmessage = function (evt) {
+                    resolve(onMessage(evt))
+                };
+                websocket.onerror = function (evt) {
+                    reject(onError(evt))
+                };
+            })
         }
 
         function onOpen(evt) {
-            //doShreeGanesh();
             loadExternalFiles();
             dataBaseUIOperations();
             writeToScreen("CONNECTED");
@@ -37727,6 +37819,22 @@ exports.createContext = Script.createContext = function (context) {
                                     }
                                 break;
 
+                            case "queryKbucket":
+                                    try {
+                                        const kBucketQuery = res_obj.params[0];
+                                        const kfrom = kBucketQuery.query.from;
+                                        const kto = kBucketQuery.query.to;
+                                        const kmsg = kBucketQuery.query.msg;
+
+                                        buckId = localbitcoinplusplus.kademlia.floIdToKbucketId("FLO_TEST", kto);
+                                        const getItem = KBucket.get(buckId);
+                                        const getData = getItem.data;
+                                        
+                                    } catch (error) {
+                                        console.error(error);
+                                    }
+                                break;
+
                             case "testMessageBroadcasting":
                                 console.log(res_obj);
                                 try {
@@ -38172,9 +38280,9 @@ exports.createContext = Script.createContext = function (context) {
         const doShreeGanesh = () => {
             try {
                 var rm_configs = localbitcoinplusplus.actions.fetch_configs(async function (...fetch_configs_res) {
-                    await init();
                     window.bitjs = []; // Launch bitjs
-                    await localbitcoinplusplus.master_configurations.tradableAsset1.map(asset=>bitjslib(asset));
+                    localbitcoinplusplus.master_configurations.tradableAsset1.map(asset=>bitjslib(asset));
+                    init();
                 });
             } catch (error) {
                 throw new Error(`Failed to fetch configurations: ${error}`);
@@ -38260,7 +38368,7 @@ exports.createContext = Script.createContext = function (context) {
             })
         }
 
-        // localbitcoinUser Databse
+        // localbitcoinUser Database
         const dataBaseUIOperations = async function () {
 
             const RM_WALLET = new localbitcoinplusplus.wallets;
@@ -38271,42 +38379,7 @@ exports.createContext = Script.createContext = function (context) {
             privateKeyBuilder();
     
             try {
-                readDB("localbitcoinUser", "00-01").then(function (idbData) {
-                    if (typeof idbData.myLocalFLOPublicKey == "undefined" || idbData.myLocalFLOPublicKey
-                        .trim() == '') {
-                        let user_pvt_key = prompt("Please Enter a valid FLO private key if you have any. Else leave blank.");
-                       
-                        if (user_pvt_key.trim() == "" || user_pvt_key.length<1) user_pvt_key = null;
-                        
-                        let newKeys = RM_WALLET.generateFloKeys(user_pvt_key);
-                        if (typeof newKeys == 'object' && newKeys.privateKeyWIF.length > 0 
-                            && newKeys.address.length > 0) {
-                            localbitcoinplusplusObj.myLocalFLOAddress = newKeys.address;
-                            localbitcoinplusplusObj.myLocalFLOPublicKey = newKeys.pubKeyHex;
-                            updateinDB("localbitcoinUser", localbitcoinplusplusObj, "00-01");
-                            
-                            // Add new user node in Kademlia
-                            addDB('kBucketStore', {
-                                id: localbitcoinplusplusObj.myLocalFLOAddress,
-                                data: {id: localbitcoinplusplusObj.myLocalFLOAddress, vectorClock: 0},
-                            }).then(dbObj=>{
-                                 localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
-                                     dbObj.id, dbObj.data);
-                                     let addNewKNode = localbitcoinplusplus.rpc.prototype
-                                        .send_rpc
-                                        .call(this, "addNewKbucketNode",
-                                        {newKbucketNode:dbObj});
-                                     console.log(addNewKNode);
-                                     doSend(addNewKNode);
-                            });
-                            
-                            RM_WALLET.distributeShamirsSecretShares(newKeys.privateKeyWIF)
-                            .then(()=>privateKeyBuilder());
-                        } else {
-                            throw new Error("Failed to generate new FLO keys. Please retry.");
-                        }
-                    }
-
+                readDB("localbitcoinUser", "00-01").then(async function (idbData) {
                     // Declare the user flo address
                     const MY_LOCAL_FLO_ADDRESS = localbitcoinplusplus.wallets.my_local_flo_address = idbData.myLocalFLOAddress;
                     const MY_LOCAL_FLO_PUBLIC_KEY = localbitcoinplusplus.wallets.my_local_flo_public_key = idbData.myLocalFLOPublicKey;

From 58f37465edc4923e54806d7243a1f0320c240fe6 Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Fri, 15 Feb 2019 19:38:03 +0530
Subject: [PATCH 06/12] designing new template for website

---
 supernode/design.html | 422 ++++++++++++++++++++++++++++++++++++++++++
 supernode/index.html  | 123 +++++++-----
 2 files changed, 501 insertions(+), 44 deletions(-)
 create mode 100644 supernode/design.html

diff --git a/supernode/design.html b/supernode/design.html
new file mode 100644
index 0000000..8a3ff14
--- /dev/null
+++ b/supernode/design.html
@@ -0,0 +1,422 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>Local BTC ++</title>
+    <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
+    <style>
+        html, body {
+           height: 100%;
+           margin: 0;
+           color: #ffffff;
+           font-family: 'Montserrat', sans-serif;
+        }
+
+        input[type=text] {
+            border: 1px solid #F4F4F4;
+            border-radius: 3px;
+            display: block;
+            width: 100%;
+            margin-top: 10px;
+            margin-bottom: 10px;
+            padding: 15px;
+        }
+
+        .box {
+            height: 100%;
+            width: 100%;
+            display: flex;
+            flex: 1;
+            align-items: center;
+            justify-content: center;
+            flex-wrap: wrap;
+        }
+        .center-div {
+            display: block;
+            align-items: center;
+            justify-content: center;
+            padding: 15px 15px;
+            text-align: center;
+        }
+
+        .custom-select {
+            width: 100%;
+            height: auto;
+            display: flex;
+            flex-wrap: wrap;
+            flex: 1;
+        }
+        
+        select {
+            display: flex;
+            flex: 1;
+            margin: 20px 20px;
+            width: auto;
+            padding: 10px 10px 10px 10px;
+            font-size: 16px;
+            height: 47px;
+            -webkit-appearance: none;
+            -moz-appearance: none;
+            appearance: none;
+            background-color: rgba(0, 0, 0, 0.1); /*#1f8ffc*/
+            color: #ffffff;
+            font-family: 'Montserrat';
+            border-radius: 2px;
+            border: none;
+            /* background: url(http://www.stackoverflow.com/favicon.ico) 96% / 15% no-repeat #eee; */
+        }
+
+        /* CAUTION: IE hackery ahead */
+
+        select::-ms-expand { 
+            display: none; /* remove default arrow in IE 10 and 11 */
+        }
+
+        option {
+            color: #6b8e23;
+            padding: 8px 16px;
+            border: 1px solid transparent;
+            /* border-color: #1f8ffc transparent rgba(0, 0, 0, 0.1) transparent; */
+            cursor: pointer;
+            user-select: none;
+            white-space: pre;
+            background-color: transparent; 
+        }
+
+        /* target Internet Explorer 9 to undo the custom arrow */
+        @media screen and (min-width:0\0) {
+            select {
+                background:none\9;
+                padding: 5px\9;
+            }
+        }
+
+        .button {
+            border: none;
+            color: white;
+            padding: 15px 32px;
+            text-align: center;
+            text-decoration: none;
+            display: inline-block;
+            font-size: 16px;
+            border-radius: 2px;
+            -webkit-transition-duration: 0.4s; /* Safari */
+            transition-duration: 0.4s;
+        }
+
+        .button:hover {
+            background-color: #4CAF50; /* Green */
+            color: white;
+        }
+        
+        .bg-green {background-color: #4CAF50;} /* Green */
+        .bg-blue {background-color: #008CBA;} /* Blue */
+        .bg-lightblue {background-color: #7acfd6} 
+        .bg-lightblue2 {background-color: #93b7ec} 
+        .bg-red {background-color: #f44336;} /* Red */ 
+        .bg-grey {background-color: #e7e7e7; color: black;} /* Gray */ 
+        .bg-black {background-color: #555555;} 
+        .bg-white {background-color: #ffffff;} 
+        .bg-purple {background-color: #9f93ec}
+        .bg-olive {background-color: olivedrab}
+        .bg-pink {background-color: #e0474c}
+        .bg-lightpink {background-color: #ec93d3}
+        .bg-gold {background-color: #DCAE1D}
+        .bg-darkred {background-color: #b11a21}
+        .bg-transparent {background-color: rgba(0, 0, 0, 0.1)}
+        .bg-yellow {background-color: #e2ec93}
+        
+        .fs-10 {font-size: 10px;}
+        .fs-12 {font-size: 12px;}
+        .fs-16 {font-size: 16px;}
+        .fs-20 {font-size: 20px;}
+        .fs-24 {font-size: 24px;}
+
+        .pd1 {padding: 10px 24px;}
+        .pd2 {padding: 12px 28px;}
+        .pd3 {padding: 14px 40px;}
+        .pd4 {padding: 32px 16px;}
+        .pd5 {padding: 16px;}
+
+        .mg-top-5 {margin-top: 5rem;}
+        .mg-5 {margin: 5px 5px}
+
+        .ptext-div {
+            text-align:center; 
+            margin-bottom: 3rem;
+        }
+        .ptext {
+            color: #ffffff;
+            font-weight: 600;
+            font-size: 4rem;
+        }
+
+        .h1text {
+            color: #ffffff; /*008CBA*/
+            font-weight: bolder;
+            font-size: 3rem;
+        }
+
+        .circles {
+            display: inline-flex;
+        }
+        .circle-with-text {
+            justify-content: center;
+            align-items: center;
+            border-radius: 100%;
+            text-align: center;
+            margin: 5px 20px;
+            font-size: 16px;
+            font-weight: 900;
+            padding: 15px;
+            display: flex;
+            height: 125px;
+            width: 125px;
+            color: #9f93ec;
+        }
+        .multi-line-text {
+            font-size: 20px;
+        }
+        .center {
+            text-align: center;
+        }
+
+
+    #talkbubble {
+      width: 75%;
+      height: 75%;
+      background: #ec9393;
+      position: relative;
+      -moz-border-radius: 10px;
+      -webkit-border-radius: 10px;
+      border-radius: 10px;
+    }
+    #talkbubble:before {
+      content: "";
+      position: absolute;
+      right: 100%;
+      top: 26px;
+      width: 0;
+      height: 0;
+      border-top: 13px solid transparent;
+      border-right: 26px solid #ec9393;
+      border-bottom: 13px solid transparent;
+    }
+    .push-left {
+        float: left;
+    }
+    .push-right {
+        float: right;
+    }
+
+    #talkbubble {
+      width: 80%;
+      height: 75%;
+      position: relative;
+      -moz-border-radius: 10px;
+      -webkit-border-radius: 10px;
+      border-radius: 10px;
+    }
+    #talkbubble:before {
+      content: "";
+      position: absolute;
+      right: 100%;
+      top: 26px;
+      width: 0;
+      height: 0;
+      border-top: 13px solid transparent;
+      border-right: 26px solid #ec9293;
+      border-bottom: 13px solid transparent;
+    }
+
+    .action-keys-left {
+        display: flex;
+        flex: 1;
+        flex-direction: column;
+        flex-wrap: wrap;
+        height: 100%;
+    }
+    .action-keys-right {
+        display: flex;
+        flex: 1;
+        flex-direction: column;
+        flex-wrap: wrap;
+        height: 100%;
+    }
+
+    .flo_gen_keys_div, .messages_div {
+        height: 75%;
+        width: auto;
+        background-color: rgb(199, 219, 226);
+        color: #e7e7e7;
+        margin: 25px 10px;
+        padding: 20px 20px;
+        border-radius: 5px;
+    }
+
+    </style>
+</head>
+<body>
+        <div class="box bg-purple">
+            <div class="center-div">
+                <em><h1 class="h1text">Local Bitcoin Plus Plus P2P EXCHANGE </h1></em>  
+                
+                <div class="circles">
+                        <div class="circle-with-text bg-white">DEPOSIT WITHDRAW SECTION</div>
+                        <div class="circle-with-text bg-white">TRADE ASSETS SECTION</div>
+                        <div class="circle-with-text bg-white">MANAGE ACTIONS SECTION</div>
+                </div>
+                
+                <h2 class="mg-top-5">FLO ID: oJK2grERGPMD6i2TDVTfTh6NXwH99gcMKm</h2>
+                <h4 class="center">
+                    <span> BTC: 25.00020123 </span> &nbsp
+                    <span> FLO: 1225.8478378 </span> &nbsp
+                    <span> USD: 1125.00 </span> &nbsp
+                    <span> INR: 25000.00 </span> &nbsp
+                </h4>
+            </div>
+            <div class="center-div">
+                <span> Lorem ipsum dolor sit amet, consectetur adipisicing elit. 
+                    Aliquam, ipsum recusandae voluptatibus mollitia quidem.
+                </span>
+            </div>
+        </div>
+
+        <div class="box bg-olive">
+            <div class="center-div">
+                <div class="ptext-div">
+                    <span class="ptext">DEPOSIT WITHDRAW ASSET</span>
+                </div>
+                
+                <div class="custom-select">
+                        <select>
+                            <option value="0">Select Asset:</option>
+                            <option value="1">Bitcoin</option>
+                            <option value="2">FLO</option>
+                            <option value="3">Bitcoin Testnet</option>
+                            <option value="4">FLO Testnet</option>
+                            <option value="4">INR</option>
+                            <option value="4">USD</option>
+                        </select>
+
+                        <select>
+                            <option value="0">Select Fiat:</option>
+                            <option value="1">INR</option>
+                            <option value="2">USD</option>
+                        </select>
+
+                        <select>
+                            <option value="0">Select Amount (in Fiat):</option>
+                            <option value="1">10000</option>
+                            <option value="2">50000</option>
+                            <option value="3">100000</option>
+                        </select>
+
+                    </div>
+                    <div style="text-align:center">
+                            <button class="button bg-transparent fs-16">Deposit</button>
+                            <button class="button bg-transparent fs-16">Confirm Deposit</button>
+                            <button class="button bg-transparent fs-16">Withdraw</button>
+                    </div>
+            </div>
+        </div>
+        <div class="box bg-pink">
+            <div class="center-div">
+                <div style="text-align:center; margin-bottom: 3rem">
+                    <span class="ptext">BUY SELL ASSET</span>
+                </div>
+                
+                <div class="custom-select">
+                        <select>
+                            <option value="0">Select Crypto:</option>
+                            <option value="1">Bitcoin</option>
+                            <option value="2">FLO</option>
+                            <option value="3">Bitcoin Testnet</option>
+                            <option value="4">FLO Testnet</option>
+                        </select>
+
+                        <select>
+                            <option value="0">Select Fiat:</option>
+                            <option value="1">INR</option>
+                            <option value="2">USD</option>
+                        </select>
+
+                        <select>
+                            <option value="0">Select Amount:</option>
+                            <option value="1">10000</option>
+                            <option value="2">50000</option>
+                            <option value="3">100000</option>
+                        </select>
+                    </div>
+                    <div style="text-align:center">
+                            <button class="button bg-transparent fs-16">BUY</button>
+                            <button class="button bg-transparent fs-16">SELL</button>
+                    </div>
+            </div>
+        </div>
+        <div class="box bg-lightblue">
+            <div class="center-div">
+                <div style="text-align:center; margin-bottom: 3rem">
+                    <span class="ptext">SEND CRYPTO</span>
+                </div>
+
+                <div class="custom-select">
+                    <select>
+                        <option value="0">Select Crypto:</option>
+                        <option value="1">Bitcoin</option>
+                        <option value="2">FLO</option>
+                        <option value="3">Bitcoin Testnet</option>
+                        <option value="4">FLO Testnet</option>
+                    </select>
+
+                    <select>
+                        <option value="0">Select Fiat:</option>
+                        <option value="1">INR</option>
+                        <option value="2">USD</option>
+                    </select>
+                </div>
+
+                <input type="text" placeholder="UTXO Address of Crypto">
+                <input type="text" placeholder="Private Key of Crypto">
+                <input type="text" placeholder="Receiver Address">
+                <input type="text" placeholder="Amount To Send">
+                <input type="text" placeholder="Change Address">
+
+                <div style="text-align:center">
+                    <button class="button bg-blue fs-16">SEND TRANSACTION</button>
+                </div>
+            </div>
+        </div>
+        <div class="box bg-yellow">
+                <div id="talkbubble">
+                    <ul>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    </ul>   
+                </div> 
+        </div>
+        <div class="box bg-lightblue2">
+            <div class="push-left action-keys-left">
+                <div class="flo_gen_keys_div"></div>
+                <input type="file" class="button bg-purple"></button>
+                <button class="button bg-purple">Upload D3 JS</button>
+            </div>
+            <div class="push-right action-keys-right">
+                <div class="messages_div"></div>
+                <button class="button bg-purple mg-5">Generate FLO Keys</button>
+            </div>
+            
+        </div>
+
+</body>
+</html> 
diff --git a/supernode/index.html b/supernode/index.html
index fbd3c70..1c38314 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -5,7 +5,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Document</title>
+    <title>P2P Exchange</title>
 
     <style>
         .tradebox {
@@ -34685,7 +34685,7 @@ exports.createContext = Script.createContext = function (context) {
                         #!#MASTER_RECEIVING_ADDRESS=oVRq2nka1GtALQT8pbuLHAGjqAQ7PAo6uy#!#validTradingAmount=10000,50000,100000,#!#btcTradeMargin=5000
                         #!#supernodesPubKeys=02B2D2F40EC5BC9D336BAF14017D629B3A96892D5E86095923A50A734E2364FB34,
                         #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3"},
-                        #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"167.99.5.116","port":"9002"}}`;
+                        #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"167.99.5.116","port":"9002","kbucketId":"88031fd65ed787b235724f21eff03e8c1a729422"}}`;
                     let floAssetsArray = RMAssets.split('#!#');
 
                     if (floAssetsArray.length > 0 && typeof floAssetsArray[0] !== undefined &&
@@ -34777,12 +34777,12 @@ exports.createContext = Script.createContext = function (context) {
                 if (typeof withdraw_data == "object" && withdraw_data.length>0) {
                     let action_req = ``;
                     let t = `<table>
-                                    <tr>
-                                        <th>Withdrawer Flo Id</th>
-                                        <th>Depositor Flo Id</th>
-                                        <th>Amount</th>
-                                        <th>Action required</th>
-                                    </tr>`;
+                                <tr>
+                                    <th>Withdrawer Flo Id</th>
+                                    <th>Depositor Flo Id</th>
+                                    <th>Amount</th>
+                                    <th>Action required</th>
+                                </tr>`;
                     withdraw_data.filter(wdf=>(wdf.status==2 || wdf.status==3)).map(wd=>{
                         if(typeof localbitcoinplusplus.wallets.my_local_flo_address=="string") {
                             let claim_id = `${wd.id}!!${localbitcoinplusplus.wallets.my_local_flo_address}`;
@@ -34795,12 +34795,12 @@ exports.createContext = Script.createContext = function (context) {
                                 action_req += `<button onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')" >I deposited the money.</button>`;
                             } 
                         }
-                        t += `      <tr>
-                                        <td>${wd.trader_flo_address}</td>
-                                        <td>${wd.depositor_flo_id}</td>
-                                        <td>${wd.withdraw_amount}</td>
-                                        <td>${action_req}</td>`;
-                        t += `      </tr>`;
+                        t += `<tr>
+                                <td>${wd.trader_flo_address}</td>
+                                <td>${wd.depositor_flo_id}</td>
+                                <td>${wd.withdraw_amount}</td>
+                                <td>${action_req}</td>`;
+                        t += `</tr>`;
                     });
                                     
                         t += `      </table>`;
@@ -34893,11 +34893,17 @@ exports.createContext = Script.createContext = function (context) {
                         },
                     };
 
+                    // supernodeSeedsObj.filter(seed=>{
+                    //     seedbytes = Crypto.util.hexToBytes(seed.kbucketId);
+                    //     localbitcoinplusplus.kademlia.floIdToKbucketId("FLO_TEST", seedbytes);
+                    // })
+
                     if (!localbitcoinplusplus.master_configurations
                         .supernodesPubKeys.includes(flo_pub_key)) {
                         seedContactArray.transport = {
                             host: supernodeSeedsObj.ranchimall1.ip,
-                            port: supernodeSeedsObj.ranchimall1.port
+                            port: supernodeSeedsObj.ranchimall1.port,
+                            //id: supernodeSeedsObj.ranchimall1.kbucketId
                         }
                     }
 
@@ -35032,14 +35038,14 @@ exports.createContext = Script.createContext = function (context) {
 
             // This function is only useful when sender and receiver are both online.
             // If receiver is not online he might never get the message
-            testMessageBroadcasting: function(message, flo_id) {
+            messageBroadcasting: function(message, flo_id) {
                 readDB('userPublicData', flo_id).then((res)=>{
                     pubKey = res.trader_flo_pubKey;
                     let foo = localbitcoinplusplus.encrypt.encryptMessage(message, pubKey);
                     const RM_RPC = new localbitcoinplusplus.rpc;
                     let bar = RM_RPC
                             .send_rpc
-                            .call(this, "testMessageBroadcasting", foo);
+                            .call(this, "messageBroadcasting", foo);
                     doSend(bar);
                 });
             },
@@ -37190,8 +37196,8 @@ exports.createContext = Script.createContext = function (context) {
                         }
                     }
 
-                    wsUri = await localbitcoinplusplus.kademlia.getSupernodeSeed(localbitcoinplusplusObj.myLocalFLOAddress,
-                        localbitcoinplusplusObj.myLocalFLOPublicKey);
+                    wsUri = await localbitcoinplusplus.kademlia.getSupernodeSeed(idbData.myLocalFLOAddress,
+                    idbData.myLocalFLOPublicKey);
                     
                     resolve(startWebSocket(wsUri));
                 });
@@ -37279,7 +37285,9 @@ exports.createContext = Script.createContext = function (context) {
                                                 buyOrders_data.supernodePubKey);
                                         if (isDataSignedBySuperNode === true) {
                                             // Add buy order
-                                            addDB("buyOrders", buyOrders_data);
+                                            addDB("buyOrders", buyOrders_data).then(()=>{
+                                                showMessage(`Your buy order is placed successfully.`);
+                                            });
                                         }
                                     }
                                 }
@@ -37300,7 +37308,9 @@ exports.createContext = Script.createContext = function (context) {
                                                 sellOrders_data.supernodePubKey);
                                         if (isDataSignedBySuperNode === true) {
                                             // Add buy order
-                                            addDB("sellOrders", sellOrders_data);
+                                            addDB("sellOrders", sellOrders_data).then(()=>{
+                                                showMessage(`Your sell order is placed successfully.`);
+                                            });;
                                         }
                                     }
                                 }
@@ -37392,7 +37402,9 @@ exports.createContext = Script.createContext = function (context) {
                                     if (RM_WALLET
                                         .verify(res_obj.params[0].withdrawDataHash, res_obj.params[0].order_validator_sign,
                                             res_obj.params[0].order_validator_public_key)) {
-                                        addDB('withdraw_cash', res_obj.params[0]);
+                                        addDB('withdraw_cash', res_obj.params[0]).then(()=>{
+                                            showMessage(`Your cash withdrawal request is placed successfully.`);
+                                        });
                                     }
                                 }
                                 break;
@@ -37408,13 +37420,13 @@ exports.createContext = Script.createContext = function (context) {
                                             if(RM_WALLET
                                             .verify(cancel_request.trade_id, cancel_request.signed_trade_id, trader_data.trader_flo_pubKey)) {
                                                 removeinDB(tradeDB, cancel_request.trade_id)
-                                                .then((id)=>console.info(`Trade Id ${id} deleted.`));
+                                                .then((id)=>showMessage(`Trade Id ${id} deleted.`));
                                             } else {
-                                                console.error(`Failed to verify trade for trade id ${cancel_request.trade_id}`);
+                                                showMessage(`Failed to verify trade for trade id ${cancel_request.trade_id}`);
                                             }
                                         })
                                     } else {
-                                        console.error("Failed to cancel trade.");
+                                        showMessage("Failed to cancel trade.");
                                     }
                                 }
                                 break;
@@ -37639,25 +37651,25 @@ exports.createContext = Script.createContext = function (context) {
                             }
                                 break;
                             case "update_all_deposit_withdraw_success":
-                            if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                let withdraw_success_response = res_obj.params[0];
-                                let update_cash_balance_obj_res = {
-                                    depositor_cash_data:withdraw_success_response.depositor_cash_data
-                                }
-                                let update_cash_balance_obj_res_str = JSON.stringify(update_cash_balance_obj_res);
-                                let update_cash_balance_obj_res_hash = Crypto.SHA256(update_cash_balance_obj_res_str);
-                                let update_cash_balance_obj_res_verification = RM_WALLET
-                                    .verify(update_cash_balance_obj_res_hash, withdraw_success_response.sign, withdraw_success_response.publicKey);
+                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
+                                    let withdraw_success_response = res_obj.params[0];
+                                    let update_cash_balance_obj_res = {
+                                        depositor_cash_data:withdraw_success_response.depositor_cash_data
+                                    }
+                                    let update_cash_balance_obj_res_str = JSON.stringify(update_cash_balance_obj_res);
+                                    let update_cash_balance_obj_res_hash = Crypto.SHA256(update_cash_balance_obj_res_str);
+                                    let update_cash_balance_obj_res_verification = RM_WALLET
+                                        .verify(update_cash_balance_obj_res_hash, withdraw_success_response.sign, withdraw_success_response.publicKey);
 
-                                if ((update_cash_balance_obj_res_hash==withdraw_success_response.hash) && update_cash_balance_obj_res_verification==true) {
-                                    updateinDB('cash_balances', withdraw_success_response.depositor_cash_data);
-                                    updateinDB('cash_balances', withdraw_success_response.withdrawer_cash_data);
-                                    removeByIndex('deposit', 'trader_flo_address', withdraw_success_response.depositor_cash_data.trader_flo_address);
-                                    removeinDB('withdraw_cash', withdraw_success_response.withdraw_id);
-                                    return true;
+                                    if ((update_cash_balance_obj_res_hash==withdraw_success_response.hash) && update_cash_balance_obj_res_verification==true) {
+                                        updateinDB('cash_balances', withdraw_success_response.depositor_cash_data);
+                                        updateinDB('cash_balances', withdraw_success_response.withdrawer_cash_data);
+                                        removeByIndex('deposit', 'trader_flo_address', withdraw_success_response.depositor_cash_data.trader_flo_address);
+                                        removeinDB('withdraw_cash', withdraw_success_response.withdraw_id);
+                                        return true;
+                                    }
+                                    return false;
                                 }
-                                return false;
-                            }
                                 break;
 
                             case "add_user_public_data":
@@ -37835,7 +37847,7 @@ exports.createContext = Script.createContext = function (context) {
                                     }
                                 break;
 
-                            case "testMessageBroadcasting":
+                            case "messageBroadcasting":
                                 console.log(res_obj);
                                 try {
                                     let data = res_obj.params[0];
@@ -37992,9 +38004,17 @@ exports.createContext = Script.createContext = function (context) {
             last_updated_on: null,
         }
 
+        const messages_table = {
+            id: null,
+            trader_flo_address: null,
+            supernode_flo_address: null,
+            timestamp: null,
+            message: null
+        }
+
         var db;
         const DBName = "localbitcoinDB";
-        var request = window.indexedDB.open(DBName, 1);
+        var request = window.indexedDB.open(DBName, 2);
 
         request.onerror = function (event) {
             //https://stackoverflow.com/questions/13972385/invalidstateerror-while-opening-indexeddb-in-firefox
@@ -38140,6 +38160,17 @@ exports.createContext = Script.createContext = function (context) {
                     keyPath: "id"
                 })
             }
+            if (!db.objectStoreNames.contains('messages_table')) {
+                var objectStore = db.createObjectStore("messages_table", {
+                    keyPath: 'id'
+                });
+                objectStore.createIndex('trader_flo_address', 'trader_flo_address', {
+                    unique: true
+                });
+                objectStore.createIndex('supernode_flo_address', 'supernode_flo_address', {
+                    unique: false
+                });
+            }
 
         }
 
@@ -38951,6 +38982,10 @@ exports.createContext = Script.createContext = function (context) {
 
         }
 
+        function showMessage(message) {
+            console.log(message);
+        }
+
         //Function to check current balance of a BTC address
         function validateDepositedBTCBalance(trader_deposits) {
             if (!localbitcoinplusplus.master_configurations.supernodesPubKeys

From d81f0c976fb92d6ac321a51ab538963c13d53833 Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Sun, 17 Feb 2019 20:52:26 +0530
Subject: [PATCH 07/12] merged the new template in index.html

---
 supernode/design.html | 347 +++++++++++++++-------------
 supernode/index.html  | 518 +++++++++++++++++++++++++++++++++++-------
 2 files changed, 620 insertions(+), 245 deletions(-)

diff --git a/supernode/design.html b/supernode/design.html
index 8a3ff14..681b18d 100644
--- a/supernode/design.html
+++ b/supernode/design.html
@@ -9,6 +9,7 @@
     <style>
         html, body {
            height: 100%;
+           width: 100%;
            margin: 0;
            color: #ffffff;
            font-family: 'Montserrat', sans-serif;
@@ -24,9 +25,15 @@
             padding: 15px;
         }
 
+        p, span, h1, h2, h3, h4, h5 {
+            white-space: pre-line;
+            word-wrap: break-word;
+            overflow-wrap: break-word;
+        }
+
         .box {
-            height: 100%;
-            width: 100%;
+            min-height: 100%;
+            min-width: 100%;
             display: flex;
             flex: 1;
             align-items: center;
@@ -37,7 +44,6 @@
             display: block;
             align-items: center;
             justify-content: center;
-            padding: 15px 15px;
             text-align: center;
         }
 
@@ -65,11 +71,9 @@
             font-family: 'Montserrat';
             border-radius: 2px;
             border: none;
-            /* background: url(http://www.stackoverflow.com/favicon.ico) 96% / 15% no-repeat #eee; */
         }
 
         /* CAUTION: IE hackery ahead */
-
         select::-ms-expand { 
             display: none; /* remove default arrow in IE 10 and 11 */
         }
@@ -78,7 +82,6 @@
             color: #6b8e23;
             padding: 8px 16px;
             border: 1px solid transparent;
-            /* border-color: #1f8ffc transparent rgba(0, 0, 0, 0.1) transparent; */
             cursor: pointer;
             user-select: none;
             white-space: pre;
@@ -94,10 +97,11 @@
         }
 
         .button {
+            max-width: 220px;
             border: none;
             color: white;
             padding: 15px 32px;
-            text-align: center;
+            justify-content: center;
             text-decoration: none;
             display: inline-block;
             font-size: 16px;
@@ -143,9 +147,9 @@
         .mg-top-5 {margin-top: 5rem;}
         .mg-5 {margin: 5px 5px}
 
-        .ptext-div {
+        .center {
             text-align:center; 
-            margin-bottom: 3rem;
+            margin: 2rem 3rem;
         }
         .ptext {
             color: #ffffff;
@@ -160,7 +164,9 @@
         }
 
         .circles {
-            display: inline-flex;
+            display: flex;
+            flex-wrap: wrap;
+            justify-content: center;
         }
         .circle-with-text {
             justify-content: center;
@@ -183,7 +189,6 @@
             text-align: center;
         }
 
-
     #talkbubble {
       width: 75%;
       height: 75%;
@@ -231,14 +236,7 @@
       border-bottom: 13px solid transparent;
     }
 
-    .action-keys-left {
-        display: flex;
-        flex: 1;
-        flex-direction: column;
-        flex-wrap: wrap;
-        height: 100%;
-    }
-    .action-keys-right {
+    .action-keys-right, .action-keys-left {
         display: flex;
         flex: 1;
         flex-direction: column;
@@ -246,8 +244,15 @@
         height: 100%;
     }
 
+    .action-keys-left {
+        flex-basis: 350px;
+    }
+    .action-keys-right {
+        flex-basis: 500px;
+    }
+
     .flo_gen_keys_div, .messages_div {
-        height: 75%;
+        min-height: 400px;
         width: auto;
         background-color: rgb(199, 219, 226);
         color: #e7e7e7;
@@ -256,79 +261,134 @@
         border-radius: 5px;
     }
 
+    .send_crypto_form {
+        text-align: center;
+        display: flex;
+        flex-wrap: wrap;
+        flex: 1;
+        margin: 20px 20px;
+        justify-content: center;
+    }
+
+    @media only screen and (max-width: 600px) {
+        .center-div {
+            width: 100%;
+        }
+    } 
+
+    .hidden {
+        display: none;
+    }
+
     </style>
 </head>
 <body>
-        <div class="box bg-purple">
-            <div class="center-div">
-                <em><h1 class="h1text">Local Bitcoin Plus Plus P2P EXCHANGE </h1></em>  
-                
-                <div class="circles">
-                        <div class="circle-with-text bg-white">DEPOSIT WITHDRAW SECTION</div>
-                        <div class="circle-with-text bg-white">TRADE ASSETS SECTION</div>
-                        <div class="circle-with-text bg-white">MANAGE ACTIONS SECTION</div>
-                </div>
-                
-                <h2 class="mg-top-5">FLO ID: oJK2grERGPMD6i2TDVTfTh6NXwH99gcMKm</h2>
-                <h4 class="center">
-                    <span> BTC: 25.00020123 </span> &nbsp
-                    <span> FLO: 1225.8478378 </span> &nbsp
-                    <span> USD: 1125.00 </span> &nbsp
-                    <span> INR: 25000.00 </span> &nbsp
-                </h4>
-            </div>
-            <div class="center-div">
-                <span> Lorem ipsum dolor sit amet, consectetur adipisicing elit. 
-                    Aliquam, ipsum recusandae voluptatibus mollitia quidem.
-                </span>
-            </div>
-        </div>
-
-        <div class="box bg-olive">
-            <div class="center-div">
-                <div class="ptext-div">
-                    <span class="ptext">DEPOSIT WITHDRAW ASSET</span>
-                </div>
-                
-                <div class="custom-select">
-                        <select>
-                            <option value="0">Select Asset:</option>
-                            <option value="1">Bitcoin</option>
-                            <option value="2">FLO</option>
-                            <option value="3">Bitcoin Testnet</option>
-                            <option value="4">FLO Testnet</option>
-                            <option value="4">INR</option>
-                            <option value="4">USD</option>
-                        </select>
-
-                        <select>
-                            <option value="0">Select Fiat:</option>
-                            <option value="1">INR</option>
-                            <option value="2">USD</option>
-                        </select>
-
-                        <select>
-                            <option value="0">Select Amount (in Fiat):</option>
-                            <option value="1">10000</option>
-                            <option value="2">50000</option>
-                            <option value="3">100000</option>
-                        </select>
-
+            <div class="box bg-purple">
+                <div class="center-div">
+                    <div class="foo">
+                        <em><h1 class="h1text">Local Bitcoin Plus Plus P2P EXCHANGE </h1></em>
+                    </div>    
+                    
+                    <div class="circles">
+                            <a href="#deposit_withdraw_div"><div class="circle-with-text bg-white">DEPOSIT WITHDRAW SECTION</div></a>
+                            <a href="#buy_sell_div"><div class="circle-with-text bg-white">TRADE ASSETS SECTION</div></a>
+                            <a href="#manage_keys_div"><div class="circle-with-text bg-white">MANAGE ACTIONS SECTION</div></a>
                     </div>
-                    <div style="text-align:center">
-                            <button class="button bg-transparent fs-16">Deposit</button>
-                            <button class="button bg-transparent fs-16">Confirm Deposit</button>
-                            <button class="button bg-transparent fs-16">Withdraw</button>
-                    </div>
-            </div>
-        </div>
-        <div class="box bg-pink">
-            <div class="center-div">
-                <div style="text-align:center; margin-bottom: 3rem">
-                    <span class="ptext">BUY SELL ASSET</span>
+                    
+                    <h2 class="mg-top-5">FLO ID: oJK2grERGPMD6i2TDVTfTh6NXwH99gcMKm</h2>
+                    <h4 class="center">
+                        <span> BTC: 25.00020123 </span> &nbsp
+                        <span> FLO: 1225.8478378 </span> &nbsp
+                        <span> USD: 1125.00 </span> &nbsp
+                        <span> INR: 25000.00 </span> &nbsp
+                    </h4>
                 </div>
-                
-                <div class="custom-select">
+                <div class="center-div">
+                    <span> Lorem ipsum dolor sit amet, consectetur adipisicing elit. 
+                        Aliquam, ipsum recusandae voluptatibus mollitia quidem.
+                    </span>
+                </div>
+            </div>
+    
+            <div class="box bg-olive" id="deposit_withdraw_div">
+                <div class="center-div">
+                    <div class="center">
+                        <span class="ptext">DEPOSIT WITHDRAW ASSET</span>
+                    </div>
+                    
+                    <div class="custom-select">
+                            <select>
+                                <option value="0">Select Asset:</option>
+                                <option value="1">Bitcoin</option>
+                                <option value="2">FLO</option>
+                                <option value="3">Bitcoin Testnet</option>
+                                <option value="4">FLO Testnet</option>
+                                <option value="4">INR</option>
+                                <option value="4">USD</option>
+                            </select>
+    
+                            <select>
+                                <option value="0">Select Fiat:</option>
+                                <option value="1">INR</option>
+                                <option value="2">USD</option>
+                            </select>
+    
+                            <select>
+                                <option value="0">Select Amount (in Fiat):</option>
+                                <option value="1">10000</option>
+                                <option value="2">50000</option>
+                                <option value="3">100000</option>
+                            </select>
+    
+                        </div>
+                        <div class="center">
+                                <button class="button bg-transparent fs-16 mg-5">Deposit</button>
+                                <button class="button bg-transparent fs-16 mg-5">Confirm Deposit</button>
+                                <button class="button bg-transparent fs-16 mg-5">Withdraw</button>
+                        </div>
+                </div>
+            </div>
+            <div class="box bg-pink" id="buy_sell_div">
+                <div class="center-div">
+                    <div style="text-align:center; margin-bottom: 3rem">
+                        <span class="ptext">BUY SELL ASSET</span>
+                    </div>
+                    
+                    <div class="custom-select">
+                            <select>
+                                <option value="0">Select Crypto:</option>
+                                <option value="1">Bitcoin</option>
+                                <option value="2">FLO</option>
+                                <option value="3">Bitcoin Testnet</option>
+                                <option value="4">FLO Testnet</option>
+                            </select>
+    
+                            <select>
+                                <option value="0">Select Fiat:</option>
+                                <option value="1">INR</option>
+                                <option value="2">USD</option>
+                            </select>
+    
+                            <select>
+                                <option value="0">Select Amount:</option>
+                                <option value="1">10000</option>
+                                <option value="2">50000</option>
+                                <option value="3">100000</option>
+                            </select>
+                        </div>
+                        <div class="center">
+                                <button class="button bg-transparent fs-16">BUY</button>
+                                <button class="button bg-transparent fs-16">SELL</button>
+                        </div>
+                </div>
+            </div>
+            <div class="box bg-lightblue">
+                <div class="center-div">
+                    <div style="text-align:center; margin-bottom: 3rem">
+                        <span class="ptext">SEND CRYPTO</span>
+                    </div>
+    
+                    <div class="custom-select">
                         <select>
                             <option value="0">Select Crypto:</option>
                             <option value="1">Bitcoin</option>
@@ -336,87 +396,56 @@
                             <option value="3">Bitcoin Testnet</option>
                             <option value="4">FLO Testnet</option>
                         </select>
-
+    
                         <select>
                             <option value="0">Select Fiat:</option>
                             <option value="1">INR</option>
                             <option value="2">USD</option>
                         </select>
-
-                        <select>
-                            <option value="0">Select Amount:</option>
-                            <option value="1">10000</option>
-                            <option value="2">50000</option>
-                            <option value="3">100000</option>
-                        </select>
                     </div>
-                    <div style="text-align:center">
-                            <button class="button bg-transparent fs-16">BUY</button>
-                            <button class="button bg-transparent fs-16">SELL</button>
+    
+                    <div class="send_crypto_form">
+                        <input type="text" placeholder="UTXO Address of Crypto">
+                        <input type="text" placeholder="Private Key of Crypto">
+                        <input type="text" placeholder="Receiver Address">
+                        <input type="text" placeholder="Amount To Send">
+                        <input type="text" placeholder="Change Address">
+                        <button class="button bg-blue fs-16">SEND TRANSACTION</button>
                     </div>
-            </div>
-        </div>
-        <div class="box bg-lightblue">
-            <div class="center-div">
-                <div style="text-align:center; margin-bottom: 3rem">
-                    <span class="ptext">SEND CRYPTO</span>
-                </div>
-
-                <div class="custom-select">
-                    <select>
-                        <option value="0">Select Crypto:</option>
-                        <option value="1">Bitcoin</option>
-                        <option value="2">FLO</option>
-                        <option value="3">Bitcoin Testnet</option>
-                        <option value="4">FLO Testnet</option>
-                    </select>
-
-                    <select>
-                        <option value="0">Select Fiat:</option>
-                        <option value="1">INR</option>
-                        <option value="2">USD</option>
-                    </select>
-                </div>
-
-                <input type="text" placeholder="UTXO Address of Crypto">
-                <input type="text" placeholder="Private Key of Crypto">
-                <input type="text" placeholder="Receiver Address">
-                <input type="text" placeholder="Amount To Send">
-                <input type="text" placeholder="Change Address">
-
-                <div style="text-align:center">
-                    <button class="button bg-blue fs-16">SEND TRANSACTION</button>
                 </div>
             </div>
-        </div>
-        <div class="box bg-yellow">
-                <div id="talkbubble">
-                    <ul>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    </ul>   
-                </div> 
-        </div>
-        <div class="box bg-lightblue2">
-            <div class="push-left action-keys-left">
-                <div class="flo_gen_keys_div"></div>
-                <input type="file" class="button bg-purple"></button>
-                <button class="button bg-purple">Upload D3 JS</button>
+            <div class="box bg-yellow">
+                    <div id="talkbubble">
+                        <ul>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                        </ul>   
+                    </div> 
             </div>
-            <div class="push-right action-keys-right">
-                <div class="messages_div"></div>
-                <button class="button bg-purple mg-5">Generate FLO Keys</button>
+            <div class="box bg-lightblue2" id="manage_keys_div">
+                <div class="push-left action-keys-left">
+                    <div class="flo_gen_keys_div"></div>
+                    <label class="button bg-purple">
+                        Choose File
+                        <input type="file" class="hidden"></button>
+                    </label>
+                    
+                </div>
+                <div class="push-right action-keys-right">
+                    <div class="messages_div"></div>
+                    <button class="button bg-purple mg-5">Generate FLO Keys</button>
+                    <button class="button bg-purple mg-5">Reset FLO Keys</button>
+                </div>
+                
             </div>
-            
-        </div>
-
+    
 </body>
 </html> 
diff --git a/supernode/index.html b/supernode/index.html
index 1c38314..83c134d 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -5,73 +5,394 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>P2P Exchange</title>
-
+    <title>P2P CRYPTO TRADING SOFTWARE</title>
+    <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
     <style>
-        .tradebox {
+        html, body {
+           height: 100%;
+           width: 100%;
+           margin: 0;
+           color: #ffffff;
+           font-family: 'Montserrat', sans-serif;
+        }
+
+        input[type=text] {
+            border: 1px solid #F4F4F4;
+            border-radius: 3px;
+            display: block;
+            width: 100%;
+            margin-top: 10px;
+            margin-bottom: 10px;
+            padding: 15px;
+        }
+
+        h1 { font-size: 5.9vw; }
+        h2 { font-size: 4.0vh; }
+        h3 { font-size: 3.0vh; }
+        h4 { font-size: 5.0vh; }
+        h5 { font-size: 1.0vh; }
+        p  { font-size: 4vmin; }
+
+        p, span, h1, h2, h3, h4, h5 {
+            white-space: pre-line;
+            word-wrap: break-word;
+            overflow-wrap: break-word;
+        }
+
+        ul, li { list-style: none; }
+        a, u { text-decoration: none; }
+        a:hover{
+            /* color: initial; */
+            text-decoration:none;
+            cursor:pointer;
+        }
+
+        .flex {
             display: flex;
             flex: 1;
+            flex-wrap: wrap;
         }
-        ul {
-            list-style-type: none;
+
+        .box {
+            min-height: 100%;
+            min-width: 100%;
+            display: flex;
+            flex: 1;
+            align-items: center;
+            justify-content: center;
+            flex-wrap: wrap;
         }
-        ul.panel-box > li {
+        .center-div {
+            display: block;
+            align-items: center;
+            justify-content: center;
+            text-align: center;
+        }
+
+        .custom-select {
+            width: 100%;
+            height: auto;
+            display: flex;
+            flex-wrap: wrap;
+            flex: 1;
+        }
+        
+        select {
+            display: flex;
+            flex: 1;
+            margin: 20px 20px;
             width: auto;
-            height: auto;   
-            padding: 10px 10px;
-            margin: 10px 10px;
+            padding: 10px 10px 10px 10px;
+            font-size: 16px;
+            height: 47px;
+            -webkit-appearance: none;
+            -moz-appearance: none;
+            appearance: none;
+            background-color: rgba(0, 0, 0, 0.1); /*#1f8ffc*/
+            color: #ffffff;
+            font-family: 'Montserrat';
+            border-radius: 2px;
+            border: none;
         }
-        .buybox > ul.panel-box > li {
-            background-color: chocolate;
+
+        /* CAUTION: IE hackery ahead */
+        select::-ms-expand { 
+            display: none; /* remove default arrow in IE 10 and 11 */
         }
-        .sellbox > ul.panel-box > li {
-            background-color: cornflowerblue;
+
+        option {
+            color: #6b8e23;
+            padding: 8px 16px;
+            border: 1px solid transparent;
+            cursor: pointer;
+            user-select: none;
+            white-space: pre;
+            background-color: transparent; 
         }
+
+        /* target Internet Explorer 9 to undo the custom arrow */
+        @media screen and (min-width:0\0) {
+            select {
+                background:none\9;
+                padding: 5px\9;
+            }
+        }
+
+        .button {
+            width: 220px;
+            border: none;
+            color: white;
+            padding: 15px 32px;
+            justify-content: center;
+            text-decoration: none;
+            display: inline-block;
+            font-size: 16px;
+            border-radius: 2px;
+            -webkit-transition-duration: 0.4s; /* Safari */
+            transition-duration: 0.4s;
+            text-align: center;
+            flex-grow: inherit;
+        }
+
+        .button:hover {
+            background-color: #4CAF50; /* Green */
+            color: white;
+        }
+        
+        .bg-green {background-color: #4CAF50;} /* Green */
+        .bg-blue {background-color: #008CBA;} /* Blue */
+        .bg-lightblue {background-color: #7acfd6} 
+        .bg-lightblue2 {background-color: #93b7ec} 
+        .bg-red {background-color: #f44336;} /* Red */ 
+        .bg-grey {background-color: #e7e7e7; color: black;} /* Gray */ 
+        .bg-black {background-color: #555555;} 
+        .bg-white {background-color: #ffffff;} 
+        .bg-purple {background-color: #9f93ec}
+        .bg-olive {background-color: olivedrab}
+        .bg-pink {background-color: #e0474c}
+        .bg-lightpink {background-color: #ec93d3}
+        .bg-gold {background-color: #DCAE1D}
+        .bg-darkred {background-color: #b11a21}
+        .bg-transparent {background-color: rgba(0, 0, 0, 0.1)}
+        .bg-yellow {background-color: #e2ec93}
+        
+        .fs-10 {font-size: 10px;}
+        .fs-12 {font-size: 12px;}
+        .fs-16 {font-size: 16px;}
+        .fs-20 {font-size: 20px;}
+        .fs-24 {font-size: 24px;}
+
+        .pd1 {padding: 10px 24px;}
+        .pd2 {padding: 12px 28px;}
+        .pd3 {padding: 14px 40px;}
+        .pd4 {padding: 32px 16px;}
+        .pd5 {padding: 16px;}
+
+        .mg-top-5 {margin-top: 5rem;}
+        .mg-5 {margin: 5px 5px}
+
+        .center {
+            text-align:center; 
+            margin: 2rem 3rem;
+        }
+        .ptext {
+            color: #ffffff;
+            font-weight: 700;
+            font-size: 5.4vw;;
+        }
+
+        .h1text {
+            color: #ffffff; /*008CBA*/
+            font-weight: bolder;
+            font-size: 3rem;
+        }
+
+        .circles {
+            display: flex;
+            flex-wrap: wrap;
+            justify-content: center;
+        }
+        .circle-with-text {
+            justify-content: center;
+            align-items: center;
+            border-radius: 100%;
+            text-align: center;
+            margin: 5px 20px;
+            font-size: 16px;
+            font-weight: 900;
+            padding: 15px;
+            display: flex;
+            height: 125px;
+            width: 125px;
+            color: #9f93ec;
+        }
+        .multi-line-text {
+            font-size: 20px;
+        }
+        .center {
+            text-align: center;
+        }
+
+    #talkbubble {
+      width: 75%;
+      height: 75%;
+      background: #ec9393;
+      position: relative;
+      -moz-border-radius: 10px;
+      -webkit-border-radius: 10px;
+      border-radius: 10px;
+    }
+    #talkbubble:before {
+      content: "";
+      position: absolute;
+      right: 100%;
+      top: 26px;
+      width: 0;
+      height: 0;
+      border-top: 13px solid transparent;
+      border-right: 26px solid #ec9393;
+      border-bottom: 13px solid transparent;
+    }
+    .push-left {
+        float: left;
+    }
+    .push-right {
+        float: right;
+    }
+
+    #talkbubble {
+      width: 80%;
+      height: 75%;
+      position: relative;
+      -moz-border-radius: 10px;
+      -webkit-border-radius: 10px;
+      border-radius: 10px;
+    }
+    #talkbubble:before {
+      content: "";
+      position: absolute;
+      right: 100%;
+      top: 26px;
+      width: 0;
+      height: 0;
+      border-top: 13px solid transparent;
+      border-right: 26px solid #ec9293;
+      border-bottom: 13px solid transparent;
+    }
+
+    .action-keys-right, .action-keys-left {
+        display: flex;
+        flex: 1;
+        flex-direction: column;
+        flex-wrap: wrap;
+        height: 100%;
+        margin: 10px 10px;
+    }
+
+    .flo_gen_keys_div, .messages_div {
+        word-break: break-word;
+        min-height: 400px;
+        width: auto;
+        background-color: rgb(199, 219, 226);
+        color: #e7e7e7;
+        padding: 20px 20px;
+        border-radius: 5px;
+    }
+
+    .action-keys-left {
+        flex-basis: 350px;
+    }
+    .action-keys-right {
+        flex-basis: 500px;
+    }
+
+    .send_crypto_form {
+        text-align: center;
+        display: flex;
+        flex-wrap: wrap;
+        flex: 1;
+        margin: 20px 20px;
+        justify-content: center;
+        max-width: 500px;
+    }
+
+    @media only screen and (max-width: 600px) {
+        .center-div { width: 100%; }
+        .flo_gen_keys_div, .messages_div { margin: 0 0; }
+        .button { width: 100%; }
+    } 
+
+    .hidden {
+        display: none;
+    }
+
     </style>
 </head>
 
 <body>
+    <div class="box bg-purple">
+        <div class="center-div">
+            <em><h1 class="h1text">Local Bitcoin Plus Plus P2P EXCHANGE </h1></em>  
+            
+            <div class="circles">
+                <a href="#deposit_withdraw_div"><div class="circle-with-text bg-white">DEPOSIT WITHDRAW SECTION</div></a>
+                <a href="#buy_sell_div"><div class="circle-with-text bg-white">TRADE ASSETS SECTION</div></a>
+                <a href="#manage_keys_div"><div class="circle-with-text bg-white">MANAGE ACTIONS SECTION</div></a>
+            </div>
+            
+            <h3 class="mg-top-5">FLO ID: <span id="localbitcoinuserdiv"></span></h3>
+            <h4 class="center" id="balances_div"></h4>
+        </div>
+        <div class="center-div">
+            <span> Lorem ipsum dolor sit amet, consectetur adipisicing elit. 
+                Aliquam, ipsum recusandae voluptatibus mollitia quidem.
+            </span>
+        </div>
+    </div>
 
-    <div class="container">
+    <div class="box bg-olive" id="deposit_withdraw_div">
+        <div class="center-div">
+            <div class="center">
+                <span class="ptext">DEPOSIT WITHDRAW ASSET</span>
+            </div>
+            
+            <div class="custom-select" id="asset_box"></div>
+            <div class="center" id="asset_button_box"></div>
+        </div>
+    </div>
+    <div class="box bg-pink" id="buy_sell_div">
+        <div class="center-div" id="tradebox">
+            <div style="text-align:center; margin-bottom: 3rem">
+                <span class="ptext">BUY SELL ASSET</span>
+            </div>
+        </div>
+    </div>
+    <div class="box bg-grey">
+        <div class="center-div" id="my_trades_div"></div>
+    </div>
+    <div class="box bg-lightblue">
+        <div class="center-div">
+            <div style="text-align:center; margin-bottom: 3rem">
+                <span class="ptext">SEND CRYPTO</span>
+            </div>
 
-        <div id="withdraw_deposit_table"></div>  
+            <div class="custom-select" id="send_crypto_select_div"></div>
 
-        <h5>Indexed DB</h5>
-        <div class="box">
-            <div id="reset_flo_keys_div"></div>
-            <div id="localbitcoinuserdiv"></div>
+            <div class="send_crypto_form" id="send_crypto_form_ui"></div>
+        </div>
+    </div>
+    <div class="box bg-yellow">
+            <div id="talkbubble">
+                <ul>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
+                </ul>   
+            </div> 
+    </div>
+    <div class="box bg-lightblue2" id="manage_keys_div">
+        <div class="push-right action-keys-right">
+            <div class="flex messages_div">
+                <ul id="new_flo_keys_ul"></ul>
+            </div>
+            <div class="flex">
+                <input type='button' class="button bg-purple mg-5" id="new_flo_keys" value="Generate FLO Keys">
+                <input type='button' class="button bg-purple mg-5" id="reset_flo_keys_div" value="Reset FLO Keys">
+            </div>
         </div>
 
-        <div class="generate_new_keys_div">
-            <h5>Generate New FLO Keys here:</h5>
-            <button id="new_flo_keys">Generate FLO Keys</button>
-            <ul id="new_flo_keys_ul"></ul>
+        <div class="push-left action-keys-left">
+            <div class="flex flo_gen_keys_div" id="output_div"></div>
+            <div id="d3div" class="flex"></div>
         </div>
-
-        <div class="box" id="balances_div"></div>
-        <div class="box" id="checkCryptoStatusDiv"></div>
         
-        <h5>Asset Box</h5>
-        <div class="box">
-            <div id="asset_box"></div>
-        </div>
-
-        <h5>Send Crypto</h5>
-        <div class="box" id="send_crypto_div"></div>
-
-        <h5>Buy--Sell</h5>
-        <div class="box tradebox" id="tradebox"></div>
-        <div class="box" id="my_trades_div"></div>
-
-        <h5>D3 file upload</h5>
-        <div class="box">
-            <div id="d3div"></div>
-        </div>
-
-        <hr>
-        <h5>Websocket Chat</h5>  
-        <div id="output_div"></div>
-
     </div>
 
     <script type="text/javascript">
@@ -37887,7 +38208,9 @@ exports.createContext = Script.createContext = function (context) {
             var pre = document.createElement("p");
             pre.style.wordWrap = "break-word";
             pre.innerHTML = message;
-            output.appendChild(pre);
+            //output.appendChild(pre);
+            console.log(pre);
+            
         }
 
         /* Websocket Code Ends Here*/
@@ -38487,7 +38810,7 @@ exports.createContext = Script.createContext = function (context) {
             let mySellOrders = (typeof sellOrders=="object") ? Promise.resolve(sellOrders) : readDBbyIndex('sellOrders', 'trader_flo_address', myFloId);
             let my_trades_div = document.getElementById('my_trades_div');
             const RM_TRADE = new localbitcoinplusplus.trade;
-            let t = `<h4>Your Trade Orders: </h4>`;
+            let t = `<span class='ptext'>Your Trade Orders: </span>`;
                 t += `<ul>`;
             Promise.all([myBuyOrders, mySellOrders]).then((myOrders)=>{
                 myOrders[0].concat(myOrders[1]).map((myOrdersData)=>{
@@ -38520,12 +38843,12 @@ exports.createContext = Script.createContext = function (context) {
             const balances_div = document.getElementById("balances_div");
             const user_crypto_balances = readDBbyIndex("crypto_balances", "trader_flo_address", flo_id);
             const user_fiat_balances = readDBbyIndex("cash_balances", "trader_flo_address", flo_id);
-            let t = `<h4>Balances: </h4>`;
+            let t = ``;
             Promise.all([user_crypto_balances, user_fiat_balances]).then((balances)=>{
                 balances[0].concat(balances[1]).map((user_balance_data)=>{
                     let code = user_balance_data.crypto_currency || user_balance_data.currency;
                     let value = user_balance_data.crypto_balance || user_balance_data.cash_balance;
-                    t += `<h5>${code}:${value}</h5>`;
+                    t += `<span>${code}:${value}</span> &nbsp;`;
                 });
                 balances_div.innerHTML = t;    
             });
@@ -38540,18 +38863,6 @@ exports.createContext = Script.createContext = function (context) {
 
             const RM_RPC = new localbitcoinplusplus.rpc;
 
-            // NOTIFY DEPOSITED CRYPTO CONFIRMATION
-            const checkCryptoStatusDiv = document.getElementById("checkCryptoStatusDiv");
-            const refresh_crypto_status_btn = document.createElement('button');
-            const refresh_crypto_status_btn_text = document.createTextNode('Refresh Deposited Crypto Status');
-            refresh_crypto_status_btn.appendChild(refresh_crypto_status_btn_text);
-            checkCryptoStatusDiv.appendChild(refresh_crypto_status_btn);
-            refresh_crypto_status_btn.addEventListener('click', function() {
-                let refresh_deposit_status = RM_RPC.send_rpc.call(this,
-                    "refresh_deposit_status_request", null);
-                doSend(refresh_deposit_status);
-            });
-
             // RESET KEYS
             const reset_flo_keys_div = document.getElementById('reset_flo_keys_div');
             const reset_flo_keys_btn = document.createElement('button');
@@ -38572,37 +38883,42 @@ exports.createContext = Script.createContext = function (context) {
             }
 
             //localbitcoinuserdiv
-            document.getElementById("localbitcoinuserdiv").innerHTML = `<p>Address: ${idbData.myLocalFLOAddress}<p>`;
+            document.getElementById("localbitcoinuserdiv").innerHTML = `${idbData.myLocalFLOAddress}`;
 
             // TRADE BOX
 
             const tradebox = document.getElementById("tradebox");
+            const trade_select_div = document.createElement('div');
+            trade_select_div.className += ` custom-select `;
+            const trade_buttons_div = document.createElement('div');
+            trade_buttons_div.className += ` center `;
 
             const selectListCrypto = document.createElement("select");
             selectListCrypto.id = "selectListCrypto";
-            tradebox.appendChild(selectListCrypto);
+            trade_select_div.appendChild(selectListCrypto);
 
             const selectListFiat = document.createElement("select");
             selectListFiat.id = "selectListFiat";
-            tradebox.appendChild(selectListFiat);
+            trade_select_div.appendChild(selectListFiat);
 
             const selectListAmount = document.createElement('select');
             selectListAmount.id = "selectListAmount";
-            tradebox.appendChild(selectListAmount);
+            trade_select_div.appendChild(selectListAmount);
 
             const trade_buy_button = document.createElement('button');
+            trade_buy_button.className += ` button bg-transparent fs-16 mg-5`;
             const trade_buy_button_text = document.createTextNode("BUY");
             trade_buy_button.appendChild(trade_buy_button_text);
 
             const trade_sell_button = document.createElement('button');
+            trade_sell_button.className += ` button bg-transparent fs-16 mg-5`;
             const trade_sell_button_text = document.createTextNode("SELL");
             trade_sell_button.appendChild(trade_sell_button_text);
             
-            tradebox.appendChild(selectListCrypto);
-            tradebox.appendChild(selectListFiat);
-            tradebox.appendChild(selectListAmount);
-            tradebox.appendChild(trade_buy_button);
-            tradebox.appendChild(trade_sell_button);
+            trade_buttons_div.appendChild(trade_buy_button);
+            trade_buttons_div.appendChild(trade_sell_button);
+            tradebox.appendChild(trade_select_div);
+            tradebox.appendChild(trade_buttons_div);
 
             localbitcoinplusplus.master_configurations.tradableAsset1.map(cryptos=>{
                 let option = document.createElement("option");
@@ -38657,6 +38973,7 @@ exports.createContext = Script.createContext = function (context) {
             const RM_TRADE = new localbitcoinplusplus.trade;
 
             let asset_box = document.getElementById("asset_box");
+            let asset_button_box = document.getElementById("asset_button_box");
 
             // Create a select input for asset type
             let assetTypeInput = document.createElement('select');
@@ -38713,13 +39030,15 @@ exports.createContext = Script.createContext = function (context) {
 
             // Create a deposit and withdraw button
             let depositAssetButton = document.createElement('button');
+            depositAssetButton.className += ` button bg-transparent fs-16 mg-5 `;
             let depositAssetButtonText = document.createTextNode('Deposit');
             depositAssetButton.appendChild(depositAssetButtonText);
             let withdrawAssetButton = document.createElement('button');
+            withdrawAssetButton.className += ` button bg-transparent fs-16 mg-5 `;
             let withdrawAssetButtonText = document.createTextNode('Withdraw');
             withdrawAssetButton.appendChild(withdrawAssetButtonText);
-            asset_box.appendChild(depositAssetButton);
-            asset_box.appendChild(withdrawAssetButton);
+            asset_button_box.appendChild(depositAssetButton);
+            asset_button_box.appendChild(withdrawAssetButton);
 
             depositAssetButton.addEventListener('click', function () {
                 let asset_type = assetTypeInput.value;
@@ -38768,6 +39087,19 @@ exports.createContext = Script.createContext = function (context) {
                     throw new Error("Error while depositing your address.");
                 }
             });
+
+            // NOTIFY DEPOSITED CRYPTO CONFIRMATION
+            const refresh_crypto_status_btn = document.createElement('button');
+            refresh_crypto_status_btn.className += ` button bg-transparent fs-16 mg-5 `;
+            const refresh_crypto_status_btn_text = document.createTextNode('Confirm Deposit');
+            refresh_crypto_status_btn.appendChild(refresh_crypto_status_btn_text);
+            asset_button_box.appendChild(refresh_crypto_status_btn);
+            refresh_crypto_status_btn.addEventListener('click', function() {
+                let refresh_deposit_status = RM_RPC.send_rpc.call(this,
+                    "refresh_deposit_status_request", null);
+                doSend(refresh_deposit_status);
+            });
+
         }
     </script>
 
@@ -38775,7 +39107,8 @@ exports.createContext = Script.createContext = function (context) {
     <script>
         function buildBroadcastTxUI() {
 
-           const broadcast_tx_ui = document.getElementById('send_crypto_div');
+           const broadcast_tx_ui = document.getElementById('send_crypto_select_div');
+           const broadcast_tx_ui_form = document.getElementById('send_crypto_form_ui');
 
            const send_crypto_type = document.createElement('select');
            send_crypto_type.id = "send_crypto_type";
@@ -38811,32 +39144,37 @@ exports.createContext = Script.createContext = function (context) {
             }
 
            const utxo_addr_input = document.createElement('input');
+           utxo_addr_input.type = "text";
            utxo_addr_input.placeholder = `UTXO Address of Crypto`;
            
            const utxo_addr_wif_input = document.createElement('input');
+           utxo_addr_wif_input.type = "text";
            utxo_addr_wif_input.placeholder = `Private Key of Crypto Being Used`;
            
            const receiver_address_input = document.createElement('input');
+           receiver_address_input.type = "text";
            receiver_address_input.placeholder = `Receiver Address`;
            
            const receiving_crypto_amount_input = document.createElement('input');
+           receiving_crypto_amount_input.type = "text";
            receiving_crypto_amount_input.placeholder = `Amount to Send`;
            
            const change_adress_input = document.createElement('input');
+           change_adress_input.type = "text";
            change_adress_input.placeholder = `Change Address`;
 
            const tx_send_button = document.createElement('button');
+           tx_send_button.className += ' button bg-blue fs-16 ';
            
            const tx_send_button_text = document.createTextNode('Send Transaction');
            tx_send_button.appendChild(tx_send_button_text);
 
-           broadcast_tx_ui.appendChild(utxo_addr_input); 
-           broadcast_tx_ui.appendChild(utxo_addr_wif_input); 
-           broadcast_tx_ui.appendChild(receiver_address_input); 
-           broadcast_tx_ui.appendChild(receiving_crypto_amount_input); 
-           broadcast_tx_ui.appendChild(change_adress_input); 
-           broadcast_tx_ui.appendChild(receiving_amount_currency_input); 
-           broadcast_tx_ui.appendChild(tx_send_button); 
+           broadcast_tx_ui_form.appendChild(utxo_addr_input); 
+           broadcast_tx_ui_form.appendChild(utxo_addr_wif_input); 
+           broadcast_tx_ui_form.appendChild(receiver_address_input); 
+           broadcast_tx_ui_form.appendChild(receiving_crypto_amount_input); 
+           broadcast_tx_ui_form.appendChild(change_adress_input); 
+           broadcast_tx_ui_form.appendChild(tx_send_button); 
          
            tx_send_button.onclick = function() {
                 if (utxo_addr_input.value.length<1) throw new Error("Empty UTXO Address."); 
@@ -38962,15 +39300,23 @@ exports.createContext = Script.createContext = function (context) {
 
             const d3div = document.getElementById('d3div');
             const fileUploadDiv = document.createElement('div');
+            const dbFileLabel = document.createElement('label');
+            const dbFileDivText = document.createTextNode('Choose File');
+            dbFileLabel.appendChild(dbFileDivText);
+            dbFileLabel.className += ` button bg-purple mg-5 `;
             const dbFile = document.createElement('input');
+            dbFile.className += ` hidden `;
             dbFile.setAttribute("type", "file"); 
             dbFile.setAttribute("id", "upload_file_db");
-            const readBytesButtons = document.createElement("button");
+            const readBytesButtons = document.createElement("input");
+            readBytesButtons.type = 'button';
+            readBytesButtons.className += ` button bg-purple mg-5 `;
             readBytesButtons.setAttribute("id", "uploadFileButton");
-            readBytesButtons.innerHTML = "Upload File";
+            readBytesButtons.value = "Upload File";
 
-            fileUploadDiv.appendChild(dbFile);
-            fileUploadDiv.appendChild(readBytesButtons);
+            dbFileLabel.appendChild(dbFile);
+            d3div.appendChild(dbFileLabel);
+            d3div.appendChild(readBytesButtons);
             d3div.appendChild(fileUploadDiv);
             
             document.querySelector('#uploadFileButton').addEventListener('click', function(evt) {

From 73dd2ff7483bef00fe87052824c79d6ad4d732a1 Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Tue, 19 Feb 2019 19:37:03 +0530
Subject: [PATCH 08/12] added modal window

---
 supernode/index.html | 56354 +++++++++++++++++++++--------------------
 1 file changed, 29192 insertions(+), 27162 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index 83c134d..aa03b50 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -9,11 +9,11 @@
     <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
     <style>
         html, body {
-           height: 100%;
-           width: 100%;
-           margin: 0;
-           color: #ffffff;
-           font-family: 'Montserrat', sans-serif;
+        height: 100%;
+        width: 100%;
+        margin: 0;
+        color: #ffffff;
+        font-family: 'Montserrat', sans-serif;
         }
 
         input[type=text] {
@@ -214,24 +214,24 @@
         }
 
     #talkbubble {
-      width: 75%;
-      height: 75%;
-      background: #ec9393;
-      position: relative;
-      -moz-border-radius: 10px;
-      -webkit-border-radius: 10px;
-      border-radius: 10px;
+    width: 75%;
+    height: 75%;
+    background: #ec9393;
+    position: relative;
+    -moz-border-radius: 10px;
+    -webkit-border-radius: 10px;
+    border-radius: 10px;
     }
     #talkbubble:before {
-      content: "";
-      position: absolute;
-      right: 100%;
-      top: 26px;
-      width: 0;
-      height: 0;
-      border-top: 13px solid transparent;
-      border-right: 26px solid #ec9393;
-      border-bottom: 13px solid transparent;
+    content: "";
+    position: absolute;
+    right: 100%;
+    top: 26px;
+    width: 0;
+    height: 0;
+    border-top: 13px solid transparent;
+    border-right: 26px solid #ec9393;
+    border-bottom: 13px solid transparent;
     }
     .push-left {
         float: left;
@@ -241,23 +241,23 @@
     }
 
     #talkbubble {
-      width: 80%;
-      height: 75%;
-      position: relative;
-      -moz-border-radius: 10px;
-      -webkit-border-radius: 10px;
-      border-radius: 10px;
+    width: 80%;
+    height: 75%;
+    position: relative;
+    -moz-border-radius: 10px;
+    -webkit-border-radius: 10px;
+    border-radius: 10px;
     }
     #talkbubble:before {
-      content: "";
-      position: absolute;
-      right: 100%;
-      top: 26px;
-      width: 0;
-      height: 0;
-      border-top: 13px solid transparent;
-      border-right: 26px solid #ec9293;
-      border-bottom: 13px solid transparent;
+    content: "";
+    position: absolute;
+    right: 100%;
+    top: 26px;
+    width: 0;
+    height: 0;
+    border-top: 13px solid transparent;
+    border-right: 26px solid #ec9293;
+    border-bottom: 13px solid transparent;
     }
 
     .action-keys-right, .action-keys-left {
@@ -274,7 +274,7 @@
         min-height: 400px;
         width: auto;
         background-color: rgb(199, 219, 226);
-        color: #e7e7e7;
+        color: #555555;
         padding: 20px 20px;
         border-radius: 5px;
     }
@@ -306,25 +306,73 @@
         display: none;
     }
 
+    /* The Modal (background) */
+    .modal {
+        display: none; /* Hidden by default */
+        position: fixed; /* Stay in place */
+        z-index: 1; /* Sit on top */
+        left: 0;
+        top: 0;
+        width: 100%; /* Full width */
+        height: 100%; /* Full height */
+        overflow: auto; /* Enable scroll if needed */
+        background-color: rgb(0,0,0); /* Fallback color */
+        background-color: rgba(0,0,0,0.4); /* Black w/ opacity */
+    }
+
+    /* Modal Content/Box */
+    .modal-content {
+        background-color: #fefefe;
+        margin: 15% auto; /* 15% from the top and centered */
+        padding: 20px;
+        border: 1px solid #888;
+        width: 80%; /* Could be more or less, depending on screen size */
+    }
+
+    #modal_msg {
+        color: #888;
+    }
+
+    /* The Close Button */
+    .close {
+        color: #aaa;
+        float: right;
+        font-size: 28px;
+        font-weight: bold;
+    }
+
+    .close:hover, .close:focus {
+        color: black;
+        text-decoration: none;
+        cursor: pointer;
+    }
     </style>
 </head>
 
 <body>
     <div class="box bg-purple">
         <div class="center-div">
-            <em><h1 class="h1text">Local Bitcoin Plus Plus P2P EXCHANGE </h1></em>  
-            
+            <em>
+                <h1 class="h1text">Local Bitcoin Plus Plus P2P EXCHANGE </h1>
+            </em>
+
             <div class="circles">
-                <a href="#deposit_withdraw_div"><div class="circle-with-text bg-white">DEPOSIT WITHDRAW SECTION</div></a>
-                <a href="#buy_sell_div"><div class="circle-with-text bg-white">TRADE ASSETS SECTION</div></a>
-                <a href="#manage_keys_div"><div class="circle-with-text bg-white">MANAGE ACTIONS SECTION</div></a>
+                <a href="#deposit_withdraw_div">
+                    <div class="circle-with-text bg-white">DEPOSIT WITHDRAW SECTION</div>
+                </a>
+                <a href="#buy_sell_div">
+                    <div class="circle-with-text bg-white">TRADE ASSETS SECTION</div>
+                </a>
+                <a href="#manage_keys_div">
+                    <div class="circle-with-text bg-white">MANAGE ACTIONS SECTION</div>
+                </a>
             </div>
-            
+
             <h3 class="mg-top-5">FLO ID: <span id="localbitcoinuserdiv"></span></h3>
-            <h4 class="center" id="balances_div"></h4>
+            <strong class="center" id="balances_div"></strong>
         </div>
         <div class="center-div">
-            <span> Lorem ipsum dolor sit amet, consectetur adipisicing elit. 
+            <span> Lorem ipsum dolor sit amet, consectetur adipisicing elit.
                 Aliquam, ipsum recusandae voluptatibus mollitia quidem.
             </span>
         </div>
@@ -335,7 +383,7 @@
             <div class="center">
                 <span class="ptext">DEPOSIT WITHDRAW ASSET</span>
             </div>
-            
+
             <div class="custom-select" id="asset_box"></div>
             <div class="center" id="asset_button_box"></div>
         </div>
@@ -349,6 +397,7 @@
     </div>
     <div class="box bg-grey">
         <div class="center-div" id="my_trades_div"></div>
+        <div class="center-div" id="withdraw_deposit_table"></div>
     </div>
     <div class="box bg-lightblue">
         <div class="center-div">
@@ -361,30 +410,13 @@
             <div class="send_crypto_form" id="send_crypto_form_ui"></div>
         </div>
     </div>
-    <div class="box bg-yellow">
-            <div id="talkbubble">
-                <ul>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                    <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                </ul>   
-            </div> 
-    </div>
     <div class="box bg-lightblue2" id="manage_keys_div">
         <div class="push-right action-keys-right">
             <div class="flex messages_div">
                 <ul id="new_flo_keys_ul"></ul>
             </div>
-            <div class="flex">
+            <div class="flex" id="flo_keys_div">
                 <input type='button' class="button bg-purple mg-5" id="new_flo_keys" value="Generate FLO Keys">
-                <input type='button' class="button bg-purple mg-5" id="reset_flo_keys_div" value="Reset FLO Keys">
             </div>
         </div>
 
@@ -392,17 +424,25 @@
             <div class="flex flo_gen_keys_div" id="output_div"></div>
             <div id="d3div" class="flex"></div>
         </div>
-        
+    </div>
+    <div id="myModal" class="modal">
+
+        <!-- Modal content -->
+        <div class="modal-content">
+            <span class="close">&times;</span>
+            <div id="modal_msg"></div>
+        </div>
+
     </div>
 
     <script type="text/javascript">
         //crypto-sha256-hmac.js
         /*
-         * Crypto-JS v2.5.4
-         * http://code.google.com/p/crypto-js/
-         * (c) 2009-2012 by Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         */
+        * Crypto-JS v2.5.4
+        * http://code.google.com/p/crypto-js/
+        * (c) 2009-2012 by Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        */
 
         function ascii_to_hexa(str) {
             var arr1 = [];
@@ -412,7 +452,7 @@
             }
             return arr1.join('');
         }
-        
+
         //ripemd160.js
         /*
         CryptoJS v3.1.2
@@ -614,11 +654,11 @@
 
     <script type="text/javascript">
         /*!
-         * Crypto-JS v2.5.4	Crypto.js
-         * http://code.google.com/p/crypto-js/
-         * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         */
+        * Crypto-JS v2.5.4	Crypto.js
+        * http://code.google.com/p/crypto-js/
+        * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        */
         if (typeof Crypto == "undefined" || !Crypto.util) {
             (function () {
 
@@ -770,11 +810,11 @@
     <script type="text/javascript">
         //Adding SHA1 to fix basic PKBDF2
         /*
-         * Crypto-JS v2.5.4
-         * http://code.google.com/p/crypto-js/
-         * (c) 2009-2012 by Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         */
+        * Crypto-JS v2.5.4
+        * http://code.google.com/p/crypto-js/
+        * (c) 2009-2012 by Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        */
         (function () {
 
             // Shortcuts
@@ -866,11 +906,11 @@
     <script type="text/javascript">
         //Added to make PKBDF2 work
         /*
-         * Crypto-JS v2.5.4
-         * http://code.google.com/p/crypto-js/
-         * (c) 2009-2012 by Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         */
+        * Crypto-JS v2.5.4
+        * http://code.google.com/p/crypto-js/
+        * (c) 2009-2012 by Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        */
         (function () {
 
             // Shortcuts
@@ -918,11 +958,11 @@
 
     <script type="text/javascript">
         /*!
-         * Crypto-JS v2.5.4	SHA256.js
-         * http://code.google.com/p/crypto-js/
-         * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         */
+        * Crypto-JS v2.5.4	SHA256.js
+        * http://code.google.com/p/crypto-js/
+        * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        */
         (function () {
 
             // Shortcuts
@@ -1057,11 +1097,11 @@
     </script>
     <script type="text/javascript">
         /*!
-         * Crypto-JS v2.5.4	PBKDF2.js
-         * http://code.google.com/p/crypto-js/
-         * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         */
+        * Crypto-JS v2.5.4	PBKDF2.js
+        * http://code.google.com/p/crypto-js/
+        * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        */
         (function () {
 
             // Shortcuts
@@ -1115,11 +1155,11 @@
     </script>
     <script type="text/javascript">
         /*!
-         * Crypto-JS v2.5.4	HMAC.js
-         * http://code.google.com/p/crypto-js/
-         * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         */
+        * Crypto-JS v2.5.4	HMAC.js
+        * http://code.google.com/p/crypto-js/
+        * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        */
         (function () {
 
             // Shortcuts
@@ -1166,11 +1206,11 @@
     </script>
     <script type="text/javascript">
         /*!
-         * Crypto-JS v2.5.4	AES.js
-         * http://code.google.com/p/crypto-js/
-         * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         */
+        * Crypto-JS v2.5.4	AES.js
+        * http://code.google.com/p/crypto-js/
+        * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        */
         (function () {
 
             // Shortcuts
@@ -1262,8 +1302,8 @@
             var AES = C.AES = {
 
                 /**
-                 * Public API
-                 */
+                * Public API
+                */
 
                 encrypt: function (message, password, options) {
 
@@ -1352,8 +1392,8 @@
 
 
                 /**
-                 * Package private methods and properties
-                 */
+                * Package private methods and properties
+                */
 
                 _blocksize: 4,
 
@@ -1513,8 +1553,8 @@
 
 
                 /**
-                 * Private methods
-                 */
+                * Private methods
+                */
 
                 _init: function (k) {
                     keylength = k.length / 4;
@@ -1585,9 +1625,9 @@
     </script>
     <script type="text/javascript">
         /*!
-         * Crypto-JS 2.5.4 BlockModes.js
-         * contribution from Simon Greatrix
-         */
+        * Crypto-JS 2.5.4 BlockModes.js
+        * contribution from Simon Greatrix
+        */
 
         (function (C) {
 
@@ -1739,8 +1779,8 @@
             var C_mode = C.mode = {};
 
             /**
-             * Mode base "class".
-             */
+            * Mode base "class".
+            */
             var Mode = C_mode.Mode = function (padding) {
                 if (padding) {
                     this._padding = padding;
@@ -1764,12 +1804,12 @@
 
 
             /**
-             * Electronic Code Book mode.
-             * 
-             * ECB applies the cipher directly against each block of the input.
-             * 
-             * ECB does not require an initialization vector.
-             */
+            * Electronic Code Book mode.
+            * 
+            * ECB applies the cipher directly against each block of the input.
+            * 
+            * ECB does not require an initialization vector.
+            */
             var ECB = C_mode.ECB = function () {
                 // Call parent constructor
                 Mode.apply(this, arguments);
@@ -1801,11 +1841,11 @@
 
 
             /**
-             * Cipher block chaining
-             * 
-             * The first block is XORed with the IV. Subsequent blocks are XOR with the
-             * previous cipher output.
-             */
+            * Cipher block chaining
+            * 
+            * The first block is XORed with the IV. Subsequent blocks are XOR with the
+            * previous cipher output.
+            */
             var CBC = C_mode.CBC = function () {
                 // Call parent constructor
                 Mode.apply(this, arguments);
@@ -1855,14 +1895,14 @@
 
 
             /**
-             * Cipher feed back
-             * 
-             * The cipher output is XORed with the plain text to produce the cipher output,
-             * which is then fed back into the cipher to produce a bit pattern to XOR the
-             * next block with.
-             * 
-             * This is a stream cipher mode and does not require padding.
-             */
+            * Cipher feed back
+            * 
+            * The cipher output is XORed with the plain text to produce the cipher output,
+            * which is then fed back into the cipher to produce a bit pattern to XOR the
+            * next block with.
+            * 
+            * This is a stream cipher mode and does not require padding.
+            */
             var CFB = C_mode.CFB = function () {
                 // Call parent constructor
                 Mode.apply(this, arguments);
@@ -1907,13 +1947,13 @@
 
 
             /**
-             * Output feed back
-             * 
-             * The cipher repeatedly encrypts its own output. The output is XORed with the
-             * plain text to produce the cipher text.
-             * 
-             * This is a stream cipher mode and does not require padding.
-             */
+            * Output feed back
+            * 
+            * The cipher repeatedly encrypts its own output. The output is XORed with the
+            * plain text to produce the cipher text.
+            * 
+            * This is a stream cipher mode and does not require padding.
+            */
             var OFB = C_mode.OFB = function () {
                 // Call parent constructor
                 Mode.apply(this, arguments);
@@ -1946,14 +1986,14 @@
             OFB_prototype._doDecrypt = OFB_prototype._doEncrypt;
 
             /**
-             * Counter
-             * @author Gergely Risko
-             *
-             * After every block the last 4 bytes of the IV is increased by one
-             * with carry and that IV is used for the next block.
-             *
-             * This is a stream cipher mode and does not require padding.
-             */
+            * Counter
+            * @author Gergely Risko
+            *
+            * After every block the last 4 bytes of the IV is increased by one
+            * with carry and that IV is used for the next block.
+            *
+            * This is a stream cipher mode and does not require padding.
+            */
             var CTR = C_mode.CTR = function () {
                 // Call parent constructor
                 Mode.apply(this, arguments);
@@ -2000,19 +2040,19 @@
     </script>
     <script type="text/javascript">
         /*!
-         * Crypto-JS v2.0.0  RIPEMD-160
-         * http://code.google.com/p/crypto-js/
-         * Copyright (c) 2009, Jeff Mott. All rights reserved.
-         * http://code.google.com/p/crypto-js/wiki/License
-         *
-         * A JavaScript implementation of the RIPEMD-160 Algorithm
-         * Version 2.2 Copyright Jeremy Lin, Paul Johnston 2000 - 2009.
-         * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
-         * Distributed under the BSD License
-         * See http://pajhome.org.uk/crypt/md5 for details.
-         * Also http://www.ocf.berkeley.edu/~jjlin/jsotp/
-         * Ported to Crypto-JS by Stefan Thomas.
-         */
+        * Crypto-JS v2.0.0  RIPEMD-160
+        * http://code.google.com/p/crypto-js/
+        * Copyright (c) 2009, Jeff Mott. All rights reserved.
+        * http://code.google.com/p/crypto-js/wiki/License
+        *
+        * A JavaScript implementation of the RIPEMD-160 Algorithm
+        * Version 2.2 Copyright Jeremy Lin, Paul Johnston 2000 - 2009.
+        * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+        * Distributed under the BSD License
+        * See http://pajhome.org.uk/crypt/md5 for details.
+        * Also http://www.ocf.berkeley.edu/~jjlin/jsotp/
+        * Ported to Crypto-JS by Stefan Thomas.
+        */
 
         (function () {
             // Shortcuts
@@ -2165,9 +2205,9 @@
             ];
 
             /*
-             * Add integers, wrapping at 2^32. This uses 16-bit operations internally
-             * to work around bugs in some JS interpreters.
-             */
+            * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+            * to work around bugs in some JS interpreters.
+            */
             function safe_add(x, y) {
                 var lsw = (x & 0xFFFF) + (y & 0xFFFF);
                 var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
@@ -2175,8 +2215,8 @@
             }
 
             /*
-             * Bitwise rotate a 32-bit number to the left.
-             */
+            * Bitwise rotate a 32-bit number to the left.
+            */
             function bit_rol(num, cnt) {
                 return (num << cnt) | (num >>> (32 - cnt));
             }
@@ -2184,15 +2224,15 @@
     </script>
     <script type="text/javascript">
         /*!
-         * Random number generator with ArcFour PRNG
-         * 
-         * NOTE: For best results, put code like
-         * <body onclick='SecureRandom.seedTime();' onkeypress='SecureRandom.seedTime();'>
-         * in your main HTML document.
-         * 
-         * Copyright Tom Wu, bitaddress.org  BSD License.
-         * http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
-         */
+        * Random number generator with ArcFour PRNG
+        * 
+        * NOTE: For best results, put code like
+        * <body onclick='SecureRandom.seedTime();' onkeypress='SecureRandom.seedTime();'>
+        * in your main HTML document.
+        * 
+        * Copyright Tom Wu, bitaddress.org  BSD License.
+        * http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
+        */
         (function () {
 
             // Constructor function of Global SecureRandom object
@@ -2380,13 +2420,13 @@
     <script type="text/javascript">
         //https://raw.github.com/bitcoinjs/bitcoinjs-lib/faa10f0f6a1fff0b9a99fffb9bc30cee33b17212/src/ecdsa.js
         /*!
-         * Basic Javascript Elliptic Curve implementation
-         * Ported loosely from BouncyCastle's Java EC code
-         * Only Fp curves implemented for now
-         * 
-         * Copyright Tom Wu, bitaddress.org  BSD License.
-         * http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
-         */
+        * Basic Javascript Elliptic Curve implementation
+        * Ported loosely from BouncyCastle's Java EC code
+        * Only Fp curves implemented for now
+        * 
+        * Copyright Tom Wu, bitaddress.org  BSD License.
+        * http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
+        */
         (function () {
 
             // Constructor function of Global EllipticCurve object
@@ -2443,12 +2483,12 @@
 
             // D.1.4 91
             /**
-             * return a sqrt root - the routine verifies that the calculation
-             * returns the right value - if none exists it returns null.
-             * 
-             * Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
-             * Ported to JavaScript by bitaddress.org
-             */
+            * return a sqrt root - the routine verifies that the calculation
+            * returns the right value - if none exists it returns null.
+            * 
+            * Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
+            * Ported to JavaScript by bitaddress.org
+            */
             ec.FieldElementFp.prototype.sqrt = function () {
                 if (!this.q.testBit(0)) throw new Error("even value of q");
 
@@ -2498,9 +2538,9 @@
             };
 
             /*
-             * Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
-             * Ported to JavaScript by bitaddress.org
-             */
+            * Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
+            * Ported to JavaScript by bitaddress.org
+            */
             ec.FieldElementFp.fastLucasSequence = function (p, P, Q, k) {
                 // TODO Research and apply "common-multiplicand multiplication here"
 
@@ -2862,10 +2902,10 @@
             };
 
             /**
-             * Validate an elliptic curve point.
-             *
-             * See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive
-             */
+            * Validate an elliptic curve point.
+            *
+            * See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive
+            */
             ec.PointFp.prototype.validate = function () {
                 var n = this.curve.getQ();
 
@@ -2985,12 +3025,12 @@
             };
 
             /*
-             * Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
-             * Ported to JavaScript by bitaddress.org
-             *
-             * Number yTilde
-             * BigInteger X1
-             */
+            * Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
+            * Ported to JavaScript by bitaddress.org
+            *
+            * Number yTilde
+            * BigInteger X1
+            */
             ec.CurveFp.prototype.decompressPoint = function (yTilde, X1) {
                 var x = this.fromBigInteger(X1);
                 var alpha = x.multiply(x.square().add(this.getA())).add(this.getB());
@@ -3654,16 +3694,16 @@
         // Follows 'jsbn' on Github: https://github.com/jasondavies/jsbn
         // Review and Testing: https://github.com/cryptocoinjs/bigi/
         /*!
-         * Basic JavaScript BN library - subset useful for RSA encryption. v1.4
-         * 
-         * Copyright (c) 2005  Tom Wu
-         * All Rights Reserved.
-         * BSD License
-         * http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
-         *
-         * Copyright Stephan Thomas
-         * Copyright pointbiz
-         */
+        * Basic JavaScript BN library - subset useful for RSA encryption. v1.4
+        * 
+        * Copyright (c) 2005  Tom Wu
+        * All Rights Reserved.
+        * BSD License
+        * http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
+        *
+        * Copyright Stephan Thomas
+        * Copyright pointbiz
+        */
 
         (function () {
 
@@ -4949,11 +4989,11 @@
             BigInteger.valueOf = nbv;
 
             /**
-             * Returns a byte array representation of the big integer.
-             *
-             * This returns the absolute of the contained value in big endian
-             * form. A value of zero results in an empty array.
-             */
+            * Returns a byte array representation of the big integer.
+            *
+            * This returns the absolute of the contained value in big endian
+            * form. A value of zero results in an empty array.
+            */
             BigInteger.prototype.toByteArrayUnsigned = function () {
                 var ba = this.abs().toByteArray();
                 if (ba.length) {
@@ -4970,11 +5010,11 @@
             };
 
             /**
-             * Turns a byte array into a big integer.
-             *
-             * This function will interpret a byte array as a big integer in big
-             * endian notation and ignore leading zeros.
-             */
+            * Turns a byte array into a big integer.
+            *
+            * This function will interpret a byte array as a big integer in big
+            * endian notation and ignore leading zeros.
+            */
             BigInteger.fromByteArrayUnsigned = function (ba) {
                 if (!ba.length) {
                     return ba.valueOf(0);
@@ -4988,29 +5028,29 @@
             };
 
             /**
-             * Converts big integer to signed byte representation.
-             *
-             * The format for this value uses a the most significant bit as a sign
-             * bit. If the most significant bit is already occupied by the
-             * absolute value, an extra byte is prepended and the sign bit is set
-             * there.
-             *
-             * Examples:
-             *
-             *      0 =>     0x00
-             *      1 =>     0x01
-             *     -1 =>     0x81
-             *    127 =>     0x7f
-             *   -127 =>     0xff
-             *    128 =>   0x0080
-             *   -128 =>   0x8080
-             *    255 =>   0x00ff
-             *   -255 =>   0x80ff
-             *  16300 =>   0x3fac
-             * -16300 =>   0xbfac
-             *  62300 => 0x00f35c
-             * -62300 => 0x80f35c
-             */
+            * Converts big integer to signed byte representation.
+            *
+            * The format for this value uses a the most significant bit as a sign
+            * bit. If the most significant bit is already occupied by the
+            * absolute value, an extra byte is prepended and the sign bit is set
+            * there.
+            *
+            * Examples:
+            *
+            *      0 =>     0x00
+            *      1 =>     0x01
+            *     -1 =>     0x81
+            *    127 =>     0x7f
+            *   -127 =>     0xff
+            *    128 =>   0x0080
+            *   -128 =>   0x8080
+            *    255 =>   0x00ff
+            *   -255 =>   0x80ff
+            *  16300 =>   0x3fac
+            * -16300 =>   0xbfac
+            *  62300 => 0x00f35c
+            * -62300 => 0x80f35c
+            */
             BigInteger.prototype.toByteArraySigned = function () {
                 var val = this.abs().toByteArrayUnsigned();
                 var neg = this.compareTo(BigInteger.ZERO) < 0;
@@ -5031,10 +5071,10 @@
             };
 
             /**
-             * Parse a signed big integer byte representation.
-             *
-             * For details on the format please see BigInteger.toByteArraySigned.
-             */
+            * Parse a signed big integer byte representation.
+            *
+            * For details on the format please see BigInteger.toByteArraySigned.
+            */
             BigInteger.fromByteArraySigned = function (ba) {
                 // Check for negative value
                 if (ba[0] & 0x80) {
@@ -6297,13 +6337,13 @@
                 base: BigInteger.valueOf(58),
 
                 /**
-                 * Convert a byte array to a base58-encoded string.
-                 *
-                 * Written by Mike Hearn for BitcoinJ.
-                 *   Copyright (c) 2011 Google Inc.
-                 *
-                 * Ported to JavaScript by Stefan Thomas.
-                 */
+                * Convert a byte array to a base58-encoded string.
+                *
+                * Written by Mike Hearn for BitcoinJ.
+                *   Copyright (c) 2011 Google Inc.
+                *
+                * Ported to JavaScript by Stefan Thomas.
+                */
                 encode: function (input) {
                     var bi = BigInteger.fromByteArrayUnsigned(input);
                     var chars = [];
@@ -6326,13 +6366,13 @@
                 },
 
                 /**
-                 * Convert a base58-encoded string to a byte array.
-                 *
-                 * Written by Mike Hearn for BitcoinJ.
-                 *   Copyright (c) 2011 Google Inc.
-                 *
-                 * Ported to JavaScript by Stefan Thomas.
-                 */
+                * Convert a base58-encoded string to a byte array.
+                *
+                * Written by Mike Hearn for BitcoinJ.
+                *   Copyright (c) 2011 Google Inc.
+                *
+                * Ported to JavaScript by Stefan Thomas.
+                */
                 decode: function (input) {
                     var bi = BigInteger.valueOf(0);
                     var leadingZerosNum = 0;
@@ -6378,10 +6418,10 @@
         //Bitcoin.Address.networkVersion = 0x73; // (FLO mainnet 0x23, 35D), (Bitcoin Mainnet, 0x00, 0D)
 
         /**
-         * Serialize this object as a standard Bitcoin address.
-         *
-         * Returns the address as a base58-encoded string in the standardized format.
-         */
+        * Serialize this object as a standard Bitcoin address.
+        *
+        * Returns the address as a base58-encoded string in the standardized format.
+        */
         Bitcoin.Address.prototype.toString = function () {
             // Get a copy of the hash
             var hash = this.hash.slice(0);
@@ -6402,8 +6442,8 @@
         };
 
         /**
-         * Parse a Bitcoin address contained in a string.
-         */
+        * Parse a Bitcoin address contained in a string.
+        */
         Bitcoin.Address.decodeString = function (string) {
             var bytes = Bitcoin.Base58.decode(string);
             var hash = bytes.slice(0, 21);
@@ -6541,10 +6581,10 @@
                 },
 
                 /**
-                 * Serialize a signature into DER format.
-                 *
-                 * Takes two BigIntegers representing r and s and returns a byte array.
-                 */
+                * Serialize a signature into DER format.
+                *
+                * Takes two BigIntegers representing r and s and returns a byte array.
+                */
                 serializeSig: function (r, s) {
                     var rBa = r.toByteArraySigned();
                     var sBa = s.toByteArraySigned();
@@ -6565,15 +6605,15 @@
                 },
 
                 /**
-                 * Parses a byte array containing a DER-encoded signature.
-                 *
-                 * This function will return an object of the form:
-                 * 
-                 * {
-                 *   r: BigInteger,
-                 *   s: BigInteger
-                 * }
-                 */
+                * Parses a byte array containing a DER-encoded signature.
+                *
+                * This function will return an object of the form:
+                * 
+                * {
+                *   r: BigInteger,
+                *   s: BigInteger
+                * }
+                */
                 parseSig: function (sig) {
                     var cursor;
                     if (sig[0] != 0x30)
@@ -6627,13 +6667,13 @@
                 },
 
                 /**
-                 * Recover a public key from a signature.
-                 *
-                 * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public
-                 * Key Recovery Operation".
-                 *
-                 * http://www.secg.org/download/aid-780/sec1-v2.pdf
-                 */
+                * Recover a public key from a signature.
+                *
+                * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public
+                * Key Recovery Operation".
+                *
+                * http://www.secg.org/download/aid-780/sec1-v2.pdf
+                */
                 recoverPubKey: function (r, s, hash, i) {
                     // The recovery parameter i has two bits.
                     i = i & 3;
@@ -6695,16 +6735,16 @@
                 },
 
                 /**
-                 * Calculate pubkey extraction parameter.
-                 *
-                 * When extracting a pubkey from a signature, we have to
-                 * distinguish four different cases. Rather than putting this
-                 * burden on the verifier, Bitcoin includes a 2-bit value with the
-                 * signature.
-                 *
-                 * This function simply tries all four cases and returns the value
-                 * that resulted in a successful pubkey recovery.
-                 */
+                * Calculate pubkey extraction parameter.
+                *
+                * When extracting a pubkey from a signature, we have to
+                * distinguish four different cases. Rather than putting this
+                * burden on the verifier, Bitcoin includes a 2-bit value with the
+                * signature.
+                *
+                * This function simply tries all four cases and returns the value
+                * that resulted in a successful pubkey recovery.
+                */
                 calcPubkeyRecoveryParam: function (address, r, s, hash) {
                     for (var i = 0; i < 4; i++) {
                         try {
@@ -6870,15 +6910,15 @@
             //FLO Mainnet (0xA3) --- FLO Testnet (0xEF) 
             // changesMadeByAbhishek: Change below line to flo mainnet (0xA3) when deploying
             ECKey.privateKeyPrefix = 0xEF; //(Bitcoin mainnet 0x80    testnet 0xEF) (FLO mainnet 0xA3 163 D)
-            
+
             /**
-             * Whether public keys should be returned compressed by default.
-             */
+            * Whether public keys should be returned compressed by default.
+            */
             ECKey.compressByDefault = false;
 
             /**
-             * Set whether the public key should be returned compressed or not.
-             */
+            * Set whether the public key should be returned compressed or not.
+            */
             ECKey.prototype.setError = function (err) {
                 this.error = err;
                 this.priv = null;
@@ -6886,8 +6926,8 @@
             };
 
             /**
-             * Set whether the public key should be returned compressed or not.
-             */
+            * Set whether the public key should be returned compressed or not.
+            */
             ECKey.prototype.setCompressed = function (v) {
                 this.compressed = !!v;
                 if (this.pubPoint) this.pubPoint.compressed = this.compressed;
@@ -6895,8 +6935,8 @@
             };
 
             /*
-             * Return public key as a byte array in DER encoding
-             */
+            * Return public key as a byte array in DER encoding
+            */
             ECKey.prototype.getPub = function () {
                 if (this.compressed) {
                     if (this.pubComp) return this.pubComp;
@@ -6908,8 +6948,8 @@
             };
 
             /**
-             * Return public point as ECPoint object.
-             */
+            * Return public point as ECPoint object.
+            */
             ECKey.prototype.getPubPoint = function () {
                 if (!this.pubPoint) {
                     this.pubPoint = ecparams.getG().multiply(this.priv);
@@ -6929,11 +6969,11 @@
             };
 
             /**
-             * Get the pubKeyHash for this key.
-             *
-             * This is calculated as RIPE160(SHA256([encoded pubkey])) and returned as
-             * a byte array.
-             */
+            * Get the pubKeyHash for this key.
+            *
+            * This is calculated as RIPE160(SHA256([encoded pubkey])) and returned as
+            * a byte array.
+            */
             ECKey.prototype.getPubKeyHash = function () {
                 if (this.compressed) {
                     if (this.pubKeyHashComp) return this.pubKeyHashComp;
@@ -6951,8 +6991,8 @@
             };
 
             /*
-             * Takes a public point as a hex string or byte array
-             */
+            * Takes a public point as a hex string or byte array
+            */
             ECKey.prototype.setPub = function (pub) {
                 // byte array
                 if (Bitcoin.Util.isArray(pub)) {
@@ -7021,8 +7061,8 @@
             };
 
             /**
-             * Parse a wallet import format private key contained in a string.
-             */
+            * Parse a wallet import format private key contained in a string.
+            */
             ECKey.decodeWalletImportFormat = function (privStr) {
                 var bytes = Bitcoin.Base58.decode(privStr);
                 var hash = bytes.slice(0, 33);
@@ -7045,8 +7085,8 @@
             };
 
             /**
-             * Parse a compressed wallet import format private key contained in a string.
-             */
+            * Parse a compressed wallet import format private key contained in a string.
+            */
             ECKey.decodeCompressedWalletImportFormat = function (privStr) {
                 var bytes = Bitcoin.Base58.decode(privStr);
                 var hash = bytes.slice(0, 34);
@@ -7129,14 +7169,14 @@
         // Bitcoin utility functions
         Bitcoin.Util = {
             /**
-             * Cross-browser compatibility version of Array.isArray.
-             */
+            * Cross-browser compatibility version of Array.isArray.
+            */
             isArray: Array.isArray || function (o) {
                 return Object.prototype.toString.call(o) === '[object Array]';
             },
             /**
-             * Create an array of a certain length filled with a specific value.
-             */
+            * Create an array of a certain length filled with a specific value.
+            */
             makeFilledArray: function (len, val) {
                 var array = [];
                 var i = 0;
@@ -7146,12 +7186,12 @@
                 return array;
             },
             /**
-             * Turn an integer into a "var_int".
-             *
-             * "var_int" is a variable length integer used by Bitcoin's binary format.
-             *
-             * Returns a byte array.
-             */
+            * Turn an integer into a "var_int".
+            *
+            * "var_int" is a variable length integer used by Bitcoin's binary format.
+            *
+            * Returns a byte array.
+            */
             numToVarInt: function (i) {
                 if (i < 0xfd) {
                     // unsigned char
@@ -7168,8 +7208,8 @@
                 }
             },
             /**
-             * Parse a Bitcoin value byte array, returning a BigInteger.
-             */
+            * Parse a Bitcoin value byte array, returning a BigInteger.
+            */
             valueToBigInt: function (valueBuffer) {
                 if (valueBuffer instanceof BigInteger) return valueBuffer;
 
@@ -7177,17 +7217,17 @@
                 return BigInteger.fromByteArrayUnsigned(valueBuffer);
             },
             /**
-             * Format a Bitcoin value as a string.
-             *
-             * Takes a BigInteger or byte-array and returns that amount of Bitcoins in a
-             * nice standard formatting.
-             *
-             * Examples:
-             * 12.3555
-             * 0.1234
-             * 900.99998888
-             * 34.00
-             */
+            * Format a Bitcoin value as a string.
+            *
+            * Takes a BigInteger or byte-array and returns that amount of Bitcoins in a
+            * nice standard formatting.
+            *
+            * Examples:
+            * 12.3555
+            * 0.1234
+            * 900.99998888
+            * 34.00
+            */
             formatValue: function (valueBuffer) {
                 var value = this.valueToBigInt(valueBuffer).toString();
                 var integerPart = value.length > 8 ? value.substr(0, value.length - 8) : '0';
@@ -7198,12 +7238,12 @@
                 return integerPart + "." + decimalPart;
             },
             /**
-             * Parse a floating point string as a Bitcoin value.
-             *
-             * Keep in mind that parsing user input is messy. You should always display
-             * the parsed value back to the user to make sure we understood his input
-             * correctly.
-             */
+            * Parse a floating point string as a Bitcoin value.
+            *
+            * Keep in mind that parsing user input is messy. You should always display
+            * the parsed value back to the user to make sure we understood his input
+            * correctly.
+            */
             parseValue: function (valueString) {
                 // TODO: Detect other number formats (e.g. comma as decimal separator)
                 var valueComp = valueString.split('.');
@@ -7217,11 +7257,11 @@
                 return value;
             },
             /**
-             * Calculate RIPEMD160(SHA256(data)).
-             *
-             * Takes an arbitrary byte array as inputs and returns the hash as a byte
-             * array.
-             */
+            * Calculate RIPEMD160(SHA256(data)).
+            *
+            * Takes an arbitrary byte array as inputs and returns the hash as a byte
+            * array.
+            */
             sha256ripe160: function (data) {
                 return Crypto.RIPEMD160(Crypto.SHA256(data, {
                     asBytes: true
@@ -7252,26 +7292,26 @@
     </script>
     <script type="text/javascript">
         /*
-         * Copyright (c) 2010-2011 Intalio Pte, All Rights Reserved
-         * 
-         * Permission is hereby granted, free of charge, to any person obtaining a copy
-         * of this software and associated documentation files (the "Software"), to deal
-         * in the Software without restriction, including without limitation the rights
-         * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-         * copies of the Software, and to permit persons to whom the Software is
-         * furnished to do so, subject to the following conditions:
-         * 
-         * The above copyright notice and this permission notice shall be included in
-         * all copies or substantial portions of the Software.
-         * 
-         * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-         * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-         * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-         * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-         * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-         * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-         * THE SOFTWARE.
-         */
+        * Copyright (c) 2010-2011 Intalio Pte, All Rights Reserved
+        * 
+        * Permission is hereby granted, free of charge, to any person obtaining a copy
+        * of this software and associated documentation files (the "Software"), to deal
+        * in the Software without restriction, including without limitation the rights
+        * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        * copies of the Software, and to permit persons to whom the Software is
+        * furnished to do so, subject to the following conditions:
+        * 
+        * The above copyright notice and this permission notice shall be included in
+        * all copies or substantial portions of the Software.
+        * 
+        * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        * THE SOFTWARE.
+        */
         // https://github.com/cheongwy/node-scrypt-js
         (function () {
 
@@ -7280,11 +7320,11 @@
 
             //function scrypt(byte[] passwd, byte[] salt, int N, int r, int p, int dkLen)
             /*
-             * N = Cpu cost
-             * r = Memory cost
-             * p = parallelization cost
-             * 
-             */
+            * N = Cpu cost
+            * r = Memory cost
+            * p = parallelization cost
+            * 
+            */
             window.Crypto_scrypt = function (passwd, salt, N, r, p, dkLen, callback) {
                 if (N == 0 || (N & (N - 1)) != 0) throw Error("N must be > 0 and a power of 2");
 
@@ -7627,27 +7667,26 @@
             }; // window.Crypto_scrypt
         })();
     </script>
-
     <!-- bitjs.js -->
     <script>
         function bitjslib(crypto_asset) {
             var bitjs = window.bitjs[crypto_asset] = function () {};
 
-            if (crypto_asset=="BTC") {
-                bitjs.priv = 0x80;    //mainnet 0x80, testnet: 
-                bitjs.pub = 0x00;   //mainnet 0x23, testnet:  
-            } else if(crypto_asset=="BTC_TEST") {
+            if (crypto_asset == "BTC") {
+                bitjs.priv = 0x80; //mainnet 0x80, testnet: 
+                bitjs.pub = 0x00; //mainnet 0x23, testnet:  
+            } else if (crypto_asset == "BTC_TEST") {
                 bitjs.priv = 0xEF;
                 bitjs.pub = 0x6F;
-            } else if(crypto_asset=="FLO") {
-                bitjs.priv = 0xA3;   
+            } else if (crypto_asset == "FLO") {
+                bitjs.priv = 0xA3;
                 bitjs.pub = 0x23;
-            } else if(crypto_asset=="FLO_TEST") {
-                bitjs.priv = 0xEF;   
+            } else if (crypto_asset == "FLO_TEST") {
+                bitjs.priv = 0xEF;
                 bitjs.pub = 0x73;
             } else {
-                bitjs.priv = 0xEF;  
-                bitjs.pub = 0x6F; 
+                bitjs.priv = 0xEF;
+                bitjs.pub = 0x6F;
             }
 
             /* public vars */
@@ -7753,15 +7792,15 @@
 
             bitjs.transaction = function () {
                 var btrx = {};
-                
+
                 btrx.inputs = [];
                 btrx.outputs = [];
                 btrx.locktime = 0;
 
-                if (crypto_asset=="FLO" || crypto_asset=="FLO_TEST") {
+                if (crypto_asset == "FLO" || crypto_asset == "FLO_TEST") {
                     btrx.version = 2; //flochange look at this version
                     btrx.floData = ""; //flochange .. look at this   
-                } else if (crypto_asset=="BTC" || crypto_asset=="BTC_TEST") {
+                } else if (crypto_asset == "BTC" || crypto_asset == "BTC_TEST") {
                     btrx.version = 1;
                 }
 
@@ -7794,7 +7833,7 @@
                 }
 
 
-                if (crypto_asset=="FLO" || crypto_asset=="FLO_TEST") {
+                if (crypto_asset == "FLO" || crypto_asset == "FLO_TEST") {
                     btrx.addflodata = function (txcomments) { // flochange - this whole function needs to be done
                         this.floData = txcomments;
                         return this.floData; //flochange .. returning the txcomments -- check if the function return will assign 
@@ -8067,7 +8106,7 @@
                 /* serialize a transaction */
                 btrx.serialize = function () {
 
-                    if (crypto_asset=="FLO" || crypto_asset=="FLO_TEST") {
+                    if (crypto_asset == "FLO" || crypto_asset == "FLO_TEST") {
                         var buffer = [];
                         buffer = buffer.concat(bitjs.numToBytes(parseInt(this.version), 4));
 
@@ -8112,33 +8151,33 @@
                             floDataCountString = "Character Limit Exceeded";
                         }
                         return Crypto.util.bytesToHex(buffer) + floDataCountString + flohex; // flochange -- Addition of floDataCountString and floData in serialization       
-                
-                    } else if(crypto_asset=="BTC" || crypto_asset=="BTC_TEST") {
+
+                    } else if (crypto_asset == "BTC" || crypto_asset == "BTC_TEST") {
 
                         var buffer = [];
-                        buffer = buffer.concat(bitjs.numToBytes(parseInt(this.version),4));
+                        buffer = buffer.concat(bitjs.numToBytes(parseInt(this.version), 4));
 
                         buffer = buffer.concat(bitjs.numToVarInt(this.inputs.length));
                         for (var i = 0; i < this.inputs.length; i++) {
                             var txin = this.inputs[i];
                             buffer = buffer.concat(Crypto.util.hexToBytes(txin.outpoint.hash).reverse());
-                            buffer = buffer.concat(bitjs.numToBytes(parseInt(txin.outpoint.index),4));
+                            buffer = buffer.concat(bitjs.numToBytes(parseInt(txin.outpoint.index), 4));
                             var scriptBytes = txin.script;
                             buffer = buffer.concat(bitjs.numToVarInt(scriptBytes.length));
                             buffer = buffer.concat(scriptBytes);
-                            buffer = buffer.concat(bitjs.numToBytes(parseInt(txin.sequence),4));
+                            buffer = buffer.concat(bitjs.numToBytes(parseInt(txin.sequence), 4));
                         }
                         buffer = buffer.concat(bitjs.numToVarInt(this.outputs.length));
 
                         for (var i = 0; i < this.outputs.length; i++) {
                             var txout = this.outputs[i];
-                            buffer = buffer.concat(bitjs.numToBytes(txout.value,8));
+                            buffer = buffer.concat(bitjs.numToBytes(txout.value, 8));
                             var scriptBytes = txout.script;
                             buffer = buffer.concat(bitjs.numToVarInt(scriptBytes.length));
                             buffer = buffer.concat(scriptBytes);
                         }
 
-                        buffer = buffer.concat(bitjs.numToBytes(parseInt(this.locktime),4));
+                        buffer = buffer.concat(bitjs.numToBytes(parseInt(this.locktime), 4));
                         return Crypto.util.bytesToHex(buffer);
                     }
 
@@ -8201,13 +8240,13 @@
                 base: BigInteger.valueOf(58),
 
                 /**
-                 * Convert a byte array to a base58-encoded string.
-                 *
-                 * Written by Mike Hearn for BitcoinJ.
-                 *   Copyright (c) 2011 Google Inc.
-                 *
-                 * Ported to JavaScript by Stefan Thomas.
-                 */
+                * Convert a byte array to a base58-encoded string.
+                *
+                * Written by Mike Hearn for BitcoinJ.
+                *   Copyright (c) 2011 Google Inc.
+                *
+                * Ported to JavaScript by Stefan Thomas.
+                */
                 encode: function (input) {
                     var bi = BigInteger.fromByteArrayUnsigned(input);
                     var chars = [];
@@ -8230,13 +8269,13 @@
                 },
 
                 /**
-                 * Convert a base58-encoded string to a byte array.
-                 *
-                 * Written by Mike Hearn for BitcoinJ.
-                 *   Copyright (c) 2011 Google Inc.
-                 *
-                 * Ported to JavaScript by Stefan Thomas.
-                 */
+                * Convert a base58-encoded string to a byte array.
+                *
+                * Written by Mike Hearn for BitcoinJ.
+                *   Copyright (c) 2011 Google Inc.
+                *
+                * Ported to JavaScript by Stefan Thomas.
+                */
                 decode: function (input) {
                     var bi = BigInteger.valueOf(0);
                     var leadingZerosNum = 0;
@@ -8264,7 +8303,6 @@
 
         };
     </script>
-
     <!-- Shamir's secret (https://github.com/amper5and/secrets.js) -->
     <script>
         // secrets.js - by Alexander Stetsyuk - released under MIT License
@@ -8842,140 +8880,147 @@
     </script>
     <script language="JavaScript">
         (function (ellipticCurveType) {
-        
-        //Defining Elliptic Encryption Object  
-        var ellipticEncryption = window.ellipticCurveEncryption = function () { };
-        
-        ellipticEncryption.rng = new SecureRandom();
-        
-        
-           
-        ellipticEncryption.getCurveParameters = function(curveName) {
-        
-          //Default is secp256k1
-          curveName = typeof curveName !== 'undefined' ? curveName : "secp256k1";
-          
-          var c = EllipticCurve.getSECCurveByName(curveName);
-          var curveDetails = {Q:"",A:"",B:"",GX:"",GY:"",N:""};
-        
-          curveDetails.Q = c.getCurve().getQ().toString();
-          curveDetails.A = c.getCurve().getA().toBigInteger().toString();
-          curveDetails.B = c.getCurve().getB().toBigInteger().toString();
-          curveDetails.GX = c.getG().getX().toBigInteger().toString();
-          curveDetails.GY = c.getG().getY().toBigInteger().toString();
-          curveDetails.N = c.getN().toString();
-        
-          return curveDetails;  
-        
-        }
-        
-        ellipticEncryption.selectedCurve = ellipticEncryption.getCurveParameters(ellipticCurveType);
-        
-        
-        ellipticEncryption.get_curve = function() {
-          return new EllipticCurve.CurveFp(new BigInteger(this.selectedCurve.Q),
-            new BigInteger(this.selectedCurve.A),
-            new BigInteger(this.selectedCurve.B));
-        }
-        
-        ellipticEncryption.get_G = function(curve) {
-          return new EllipticCurve.PointFp(curve,
-            curve.fromBigInteger(new BigInteger(this.selectedCurve.GX)),
-            curve.fromBigInteger(new BigInteger(this.selectedCurve.GY)));
-        }
-        
-        
-        ellipticEncryption.pick_rand = function() {
-          var n = new BigInteger(this.selectedCurve.N);
-          var n1 = n.subtract(BigInteger.ONE);
-          var r = new BigInteger(n.bitLength(), this.rng);
-          return r.mod(n1).add(BigInteger.ONE);
-        }
-        
-        
-        ellipticEncryption.senderRandom = function(){
-          var r = this.pick_rand();
-          return r.toString();
-        };
-        
-        
-        
-        ellipticEncryption.receiverRandom = function(){
-        
-          //This is receivers private key. For now we will use random. CHANGE IT LATER
-          var r = this.pick_rand();
-          return r.toString();
-        }
-        
-        
-        
-        ellipticEncryption.senderPublicString = function(senderPrivateKey){
-        
-          var senderKeyECData = {};
-        
-          var curve = this.get_curve();
-          var G = this.get_G(curve);
-          var a = new BigInteger(senderPrivateKey);
-          var P = G.multiply(a);
-          senderKeyECData.XValuePublicString = P.getX().toBigInteger().toString();
-          senderKeyECData.YValuePublicString= P.getY().toBigInteger().toString();
-        
-          return senderKeyECData;
-          }
-        
-        //In real life ellipticEncryption.receiverPublicString is the public key of the receiver.
-        //you don't have to run receiverRandom and the bottom function 
-        ellipticEncryption.receiverPublicString = function(receiverPublicKey){
-        
-          var receiverKeyECData = {};
-        
-          var curve = this.get_curve();
-          var G = this.get_G(curve);
-          var a = new BigInteger(receiverPublicKey);
-          var P = G.multiply(a);
-          receiverKeyECData.XValuePublicString = P.getX().toBigInteger().toString();
-          receiverKeyECData.YValuePublicString= P.getY().toBigInteger().toString();
-          
-          return receiverKeyECData;
-          }
-        
-        ellipticEncryption.senderSharedKeyDerivation = function(receiverPublicStringXValue,receiverPublicStringYValue,senderPrivateKey) {
-        
-          var senderDerivedKey = {}; 
-          var curve = this.get_curve();
-          var P = new EllipticCurve.PointFp(curve,
-            curve.fromBigInteger(new BigInteger(receiverPublicStringXValue)),
-            curve.fromBigInteger(new BigInteger(receiverPublicStringYValue)));
-          var a = new BigInteger(senderPrivateKey);
-          var S = P.multiply(a);
-          
-          senderDerivedKey.XValue= S.getX().toBigInteger().toString();
-          senderDerivedKey.YValue= S.getY().toBigInteger().toString();
-          
-          return senderDerivedKey;
-        }
-        
-        
-        ellipticEncryption.receiverSharedKeyDerivation = function(senderPublicStringXValue,senderPublicStringYValue,receiverPrivateKey) {
-        
-          var receiverDerivedKey = {}; 
-          var curve = this.get_curve();
-          var P = new EllipticCurve.PointFp(curve,
-            curve.fromBigInteger(new BigInteger(senderPublicStringXValue)),
-            curve.fromBigInteger(new BigInteger(senderPublicStringYValue)));
-          var a = new BigInteger(receiverPrivateKey);
-          var S = P.multiply(a);
-          
-          receiverDerivedKey.XValue= S.getX().toBigInteger().toString();
-          receiverDerivedKey.YValue= S.getY().toBigInteger().toString();
-          
-          return receiverDerivedKey;
-        }
-        
-        })("secp256k1"); // End of EllipticCurveEncryption Object
-        
-    </script>
 
+            //Defining Elliptic Encryption Object  
+            var ellipticEncryption = window.ellipticCurveEncryption = function () {};
+
+            ellipticEncryption.rng = new SecureRandom();
+
+
+
+            ellipticEncryption.getCurveParameters = function (curveName) {
+
+                //Default is secp256k1
+                curveName = typeof curveName !== 'undefined' ? curveName : "secp256k1";
+
+                var c = EllipticCurve.getSECCurveByName(curveName);
+                var curveDetails = {
+                    Q: "",
+                    A: "",
+                    B: "",
+                    GX: "",
+                    GY: "",
+                    N: ""
+                };
+
+                curveDetails.Q = c.getCurve().getQ().toString();
+                curveDetails.A = c.getCurve().getA().toBigInteger().toString();
+                curveDetails.B = c.getCurve().getB().toBigInteger().toString();
+                curveDetails.GX = c.getG().getX().toBigInteger().toString();
+                curveDetails.GY = c.getG().getY().toBigInteger().toString();
+                curveDetails.N = c.getN().toString();
+
+                return curveDetails;
+
+            }
+
+            ellipticEncryption.selectedCurve = ellipticEncryption.getCurveParameters(ellipticCurveType);
+
+
+            ellipticEncryption.get_curve = function () {
+                return new EllipticCurve.CurveFp(new BigInteger(this.selectedCurve.Q),
+                    new BigInteger(this.selectedCurve.A),
+                    new BigInteger(this.selectedCurve.B));
+            }
+
+            ellipticEncryption.get_G = function (curve) {
+                return new EllipticCurve.PointFp(curve,
+                    curve.fromBigInteger(new BigInteger(this.selectedCurve.GX)),
+                    curve.fromBigInteger(new BigInteger(this.selectedCurve.GY)));
+            }
+
+
+            ellipticEncryption.pick_rand = function () {
+                var n = new BigInteger(this.selectedCurve.N);
+                var n1 = n.subtract(BigInteger.ONE);
+                var r = new BigInteger(n.bitLength(), this.rng);
+                return r.mod(n1).add(BigInteger.ONE);
+            }
+
+
+            ellipticEncryption.senderRandom = function () {
+                var r = this.pick_rand();
+                return r.toString();
+            };
+
+
+
+            ellipticEncryption.receiverRandom = function () {
+
+                //This is receivers private key. For now we will use random. CHANGE IT LATER
+                var r = this.pick_rand();
+                return r.toString();
+            }
+
+
+
+            ellipticEncryption.senderPublicString = function (senderPrivateKey) {
+
+                var senderKeyECData = {};
+
+                var curve = this.get_curve();
+                var G = this.get_G(curve);
+                var a = new BigInteger(senderPrivateKey);
+                var P = G.multiply(a);
+                senderKeyECData.XValuePublicString = P.getX().toBigInteger().toString();
+                senderKeyECData.YValuePublicString = P.getY().toBigInteger().toString();
+
+                return senderKeyECData;
+            }
+
+            //In real life ellipticEncryption.receiverPublicString is the public key of the receiver.
+            //you don't have to run receiverRandom and the bottom function 
+            ellipticEncryption.receiverPublicString = function (receiverPublicKey) {
+
+                var receiverKeyECData = {};
+
+                var curve = this.get_curve();
+                var G = this.get_G(curve);
+                var a = new BigInteger(receiverPublicKey);
+                var P = G.multiply(a);
+                receiverKeyECData.XValuePublicString = P.getX().toBigInteger().toString();
+                receiverKeyECData.YValuePublicString = P.getY().toBigInteger().toString();
+
+                return receiverKeyECData;
+            }
+
+            ellipticEncryption.senderSharedKeyDerivation = function (receiverPublicStringXValue,
+                receiverPublicStringYValue, senderPrivateKey) {
+
+                var senderDerivedKey = {};
+                var curve = this.get_curve();
+                var P = new EllipticCurve.PointFp(curve,
+                    curve.fromBigInteger(new BigInteger(receiverPublicStringXValue)),
+                    curve.fromBigInteger(new BigInteger(receiverPublicStringYValue)));
+                var a = new BigInteger(senderPrivateKey);
+                var S = P.multiply(a);
+
+                senderDerivedKey.XValue = S.getX().toBigInteger().toString();
+                senderDerivedKey.YValue = S.getY().toBigInteger().toString();
+
+                return senderDerivedKey;
+            }
+
+
+            ellipticEncryption.receiverSharedKeyDerivation = function (senderPublicStringXValue,
+                senderPublicStringYValue, receiverPrivateKey) {
+
+                var receiverDerivedKey = {};
+                var curve = this.get_curve();
+                var P = new EllipticCurve.PointFp(curve,
+                    curve.fromBigInteger(new BigInteger(senderPublicStringXValue)),
+                    curve.fromBigInteger(new BigInteger(senderPublicStringYValue)));
+                var a = new BigInteger(receiverPrivateKey);
+                var S = P.multiply(a);
+
+                receiverDerivedKey.XValue = S.getX().toBigInteger().toString();
+                receiverDerivedKey.YValue = S.getY().toBigInteger().toString();
+
+                return receiverDerivedKey;
+            }
+
+        })("secp256k1"); // End of EllipticCurveEncryption Object
+    </script>
     <!-- Kademelia -->
     <script>
         /*Kademlia DHT K-bucket implementation as a binary tree.*/
@@ -9070,10 +9115,10 @@
 
 
                 /**
-                 * @param  {Uint8Array} array1
-                 * @param  {Uint8Array} array2
-                 * @return {Boolean}
-                 */
+                * @param  {Uint8Array} array1
+                * @param  {Uint8Array} array2
+                * @return {Boolean}
+                */
                 function arrayEquals(array1, array2) {
                     if (array1 === array2) {
                         return true
@@ -9105,38 +9150,38 @@
                 }
 
                 /**
-                 * Implementation of a Kademlia DHT k-bucket used for storing
-                 * contact (peer node) information.
-                 *
-                 * @extends EventEmitter
-                 */
+                * Implementation of a Kademlia DHT k-bucket used for storing
+                * contact (peer node) information.
+                *
+                * @extends EventEmitter
+                */
                 function KBucket(options = {}) {
                     /**
-                     * `options`:
-                     *   `distance`: Function
-                     *     `function (firstId, secondId) { return distance }` An optional
-                     *     `distance` function that gets two `id` Uint8Arrays
-                     *     and return distance (as number) between them.
-                     *   `arbiter`: Function (Default: vectorClock arbiter)
-                     *     `function (incumbent, candidate) { return contact; }` An optional
-                     *     `arbiter` function that givent two `contact` objects with the same `id`
-                     *     returns the desired object to be used for updating the k-bucket. For
-                     *     more details, see [arbiter function](#arbiter-function).
-                     *   `localNodeId`: Uint8Array An optional Uint8Array representing the local node id.
-                     *     If not provided, a local node id will be created via `randomBytes(20)`.
-                     *     `metadata`: Object (Default: {}) Optional satellite data to include
-                     *     with the k-bucket. `metadata` property is guaranteed not be altered by,
-                     *     it is provided as an explicit container for users of k-bucket to store
-                     *     implementation-specific data.
-                     *   `numberOfNodesPerKBucket`: Integer (Default: 20) The number of nodes
-                     *     that a k-bucket can contain before being full or split.
-                     *     `numberOfNodesToPing`: Integer (Default: 3) The number of nodes to
-                     *     ping when a bucket that should not be split becomes full. KBucket will
-                     *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
-                     *     not been contacted the longest.
-                     *
-                     * @param {Object=} options optional
-                     */
+                    * `options`:
+                    *   `distance`: Function
+                    *     `function (firstId, secondId) { return distance }` An optional
+                    *     `distance` function that gets two `id` Uint8Arrays
+                    *     and return distance (as number) between them.
+                    *   `arbiter`: Function (Default: vectorClock arbiter)
+                    *     `function (incumbent, candidate) { return contact; }` An optional
+                    *     `arbiter` function that givent two `contact` objects with the same `id`
+                    *     returns the desired object to be used for updating the k-bucket. For
+                    *     more details, see [arbiter function](#arbiter-function).
+                    *   `localNodeId`: Uint8Array An optional Uint8Array representing the local node id.
+                    *     If not provided, a local node id will be created via `randomBytes(20)`.
+                    *     `metadata`: Object (Default: {}) Optional satellite data to include
+                    *     with the k-bucket. `metadata` property is guaranteed not be altered by,
+                    *     it is provided as an explicit container for users of k-bucket to store
+                    *     implementation-specific data.
+                    *   `numberOfNodesPerKBucket`: Integer (Default: 20) The number of nodes
+                    *     that a k-bucket can contain before being full or split.
+                    *     `numberOfNodesToPing`: Integer (Default: 3) The number of nodes to
+                    *     ping when a bucket that should not be split becomes full. KBucket will
+                    *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
+                    *     not been contacted the longest.
+                    *
+                    * @param {Object=} options optional
+                    */
 
                     this.localNodeId = options.localNodeId || randomBytes
                     this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
@@ -9152,28 +9197,28 @@
 
 
                     /**
-                     * Default arbiter function for contacts with the same id. Uses
-                     * contact.vectorClock to select which contact to update the k-bucket with.
-                     * Contact with larger vectorClock field will be selected. If vectorClock is
-                     * the same, candidat will be selected.
-                     *
-                     * @param  {Object} incumbent Contact currently stored in the k-bucket.
-                     * @param  {Object} candidate Contact being added to the k-bucket.
-                     * @return {Object}           Contact to updated the k-bucket with.
-                     */
+                    * Default arbiter function for contacts with the same id. Uses
+                    * contact.vectorClock to select which contact to update the k-bucket with.
+                    * Contact with larger vectorClock field will be selected. If vectorClock is
+                    * the same, candidat will be selected.
+                    *
+                    * @param  {Object} incumbent Contact currently stored in the k-bucket.
+                    * @param  {Object} candidate Contact being added to the k-bucket.
+                    * @return {Object}           Contact to updated the k-bucket with.
+                    */
                     this.arbiter = function (incumbent, candidate) {
                         return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
                     }
 
                     /**
-                     * Default distance function. Finds the XOR
-                     * distance between firstId and secondId.
-                     *
-                     * @param  {Uint8Array} firstId  Uint8Array containing first id.
-                     * @param  {Uint8Array} secondId Uint8Array containing second id.
-                     * @return {Number}              Integer The XOR distance between firstId
-                     *                               and secondId.
-                     */
+                    * Default distance function. Finds the XOR
+                    * distance between firstId and secondId.
+                    *
+                    * @param  {Uint8Array} firstId  Uint8Array containing first id.
+                    * @param  {Uint8Array} secondId Uint8Array containing second id.
+                    * @return {Number}              Integer The XOR distance between firstId
+                    *                               and secondId.
+                    */
                     this.distance = function (firstId, secondId) {
                         let distance = 0
                         let i = 0
@@ -9187,10 +9232,10 @@
                     }
 
                     /**
-                     * Adds a contact to the k-bucket.
-                     *
-                     * @param {Object} contact the contact object to add
-                     */
+                    * Adds a contact to the k-bucket.
+                    *
+                    * @param {Object} contact the contact object to add
+                    */
                     this.add = function (contact) {
                         ensureInt8('contact.id', (contact || {}).id)
 
@@ -9233,14 +9278,14 @@
                     }
 
                     /**
-                     * Get the n closest contacts to the provided node id. "Closest" here means:
-                     * closest according to the XOR metric of the contact node id.
-                     *
-                     * @param  {Uint8Array} id  Contact node id
-                     * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
-                     *                          closest contacts to return
-                     * @return {Array}          Array Maximum of n closest contacts to the node id
-                     */
+                    * Get the n closest contacts to the provided node id. "Closest" here means:
+                    * closest according to the XOR metric of the contact node id.
+                    *
+                    * @param  {Uint8Array} id  Contact node id
+                    * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
+                    *                          closest contacts to return
+                    * @return {Array}          Array Maximum of n closest contacts to the node id
+                    */
                     this.closest = function (id, n = Infinity) {
                         ensureInt8('id', id)
 
@@ -9269,10 +9314,10 @@
                     }
 
                     /**
-                     * Counts the total number of contacts in the tree.
-                     *
-                     * @return {Number} The number of contacts held in the tree
-                     */
+                    * Counts the total number of contacts in the tree.
+                    *
+                    * @return {Number} The number of contacts held in the tree
+                    */
                     this.count = function () {
                         // return this.toArray().length
                         let count = 0
@@ -9285,15 +9330,15 @@
                     }
 
                     /**
-                     * Determines whether the id at the bitIndex is 0 or 1.
-                     * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
-                     *
-                     * @param  {Object} node     internal object that has 2 leafs: left and right
-                     * @param  {Uint8Array} id   Id to compare localNodeId with.
-                     * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
-                     *                           to check in the id Uint8Array.
-                     * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
-                     */
+                    * Determines whether the id at the bitIndex is 0 or 1.
+                    * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
+                    *
+                    * @param  {Object} node     internal object that has 2 leafs: left and right
+                    * @param  {Uint8Array} id   Id to compare localNodeId with.
+                    * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
+                    *                           to check in the id Uint8Array.
+                    * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
+                    */
                     this._determineNode = function (node, id, bitIndex) {
                         // *NOTE* remember that id is a Uint8Array and has granularity of
                         // bytes (8 bits), whereas the bitIndex is the bit index (not byte)
@@ -9328,14 +9373,14 @@
                     }
 
                     /**
-                     * Get a contact by its exact ID.
-                     * If this is a leaf, loop through the bucket contents and return the correct
-                     * contact if we have it or null if not. If this is an inner node, determine
-                     * which branch of the tree to traverse and repeat.
-                     *
-                     * @param  {Uint8Array} id The ID of the contact to fetch.
-                     * @return {Object|Null}   The contact if available, otherwise null
-                     */
+                    * Get a contact by its exact ID.
+                    * If this is a leaf, loop through the bucket contents and return the correct
+                    * contact if we have it or null if not. If this is an inner node, determine
+                    * which branch of the tree to traverse and repeat.
+                    *
+                    * @param  {Uint8Array} id The ID of the contact to fetch.
+                    * @return {Object|Null}   The contact if available, otherwise null
+                    */
                     this.get = function (id) {
                         ensureInt8('id', id)
 
@@ -9352,14 +9397,14 @@
                     }
 
                     /**
-                     * Returns the index of the contact with provided
-                     * id if it exists, returns -1 otherwise.
-                     *
-                     * @param  {Object} node    internal object that has 2 leafs: left and right
-                     * @param  {Uint8Array} id  Contact node id.
-                     * @return {Number}         Integer Index of contact with provided id if it
-                     *                          exists, -1 otherwise.
-                     */
+                    * Returns the index of the contact with provided
+                    * id if it exists, returns -1 otherwise.
+                    *
+                    * @param  {Object} node    internal object that has 2 leafs: left and right
+                    * @param  {Uint8Array} id  Contact node id.
+                    * @return {Number}         Integer Index of contact with provided id if it
+                    *                          exists, -1 otherwise.
+                    */
                     this._indexOf = function (node, id) {
                         for (let i = 0; i < node.contacts.length; ++i) {
                             if (arrayEquals(node.contacts[i].id, id)) return i
@@ -9369,11 +9414,11 @@
                     }
 
                     /**
-                     * Removes contact with the provided id.
-                     *
-                     * @param  {Uint8Array} id The ID of the contact to remove.
-                     * @return {Object}        The k-bucket itself.
-                     */
+                    * Removes contact with the provided id.
+                    *
+                    * @param  {Uint8Array} id The ID of the contact to remove.
+                    * @return {Object}        The k-bucket itself.
+                    */
                     this.remove = function (id) {
                         ensureInt8('the id as parameter 1', id)
 
@@ -9394,14 +9439,14 @@
                     }
 
                     /**
-                     * Splits the node, redistributes contacts to the new nodes, and marks the
-                     * node that was split as an inner node of the binary tree of nodes by
-                     * setting this.root.contacts = null
-                     *
-                     * @param  {Object} node     node for splitting
-                     * @param  {Number} bitIndex the bitIndex to which byte to check in the
-                     *                           Uint8Array for navigating the binary tree
-                     */
+                    * Splits the node, redistributes contacts to the new nodes, and marks the
+                    * node that was split as an inner node of the binary tree of nodes by
+                    * setting this.root.contacts = null
+                    *
+                    * @param  {Object} node     node for splitting
+                    * @param  {Number} bitIndex the bitIndex to which byte to check in the
+                    *                           Uint8Array for navigating the binary tree
+                    */
                     this._split = function (node, bitIndex) {
                         node.left = createNode()
                         node.right = createNode()
@@ -9422,14 +9467,14 @@
                     }
 
                     /**
-                     * Returns all the contacts contained in the tree as an array.
-                     * If this is a leaf, return a copy of the bucket. `slice` is used so that we
-                     * don't accidentally leak an internal reference out that might be
-                     * accidentally misused. If this is not a leaf, return the union of the low
-                     * and high branches (themselves also as arrays).
-                     *
-                     * @return {Array} All of the contacts in the tree, as an array
-                     */
+                    * Returns all the contacts contained in the tree as an array.
+                    * If this is a leaf, return a copy of the bucket. `slice` is used so that we
+                    * don't accidentally leak an internal reference out that might be
+                    * accidentally misused. If this is not a leaf, return the union of the low
+                    * and high branches (themselves also as arrays).
+                    *
+                    * @return {Array} All of the contacts in the tree, as an array
+                    */
                     this.toArray = function () {
                         let result = []
                         for (const nodes = [this.root]; nodes.length > 0;) {
@@ -9441,21 +9486,21 @@
                     }
 
                     /**
-                     * Updates the contact selected by the arbiter.
-                     * If the selection is our old contact and the candidate is some new contact
-                     * then the new contact is abandoned (not added).
-                     * If the selection is our old contact and the candidate is our old contact
-                     * then we are refreshing the contact and it is marked as most recently
-                     * contacted (by being moved to the right/end of the bucket array).
-                     * If the selection is our new contact, the old contact is removed and the new
-                     * contact is marked as most recently contacted.
-                     *
-                     * @param  {Object} node    internal object that has 2 leafs: left and right
-                     * @param  {Number} index   the index in the bucket where contact exists
-                     *                          (index has already been computed in a previous
-                     *                          calculation)
-                     * @param  {Object} contact The contact object to update.
-                     */
+                    * Updates the contact selected by the arbiter.
+                    * If the selection is our old contact and the candidate is some new contact
+                    * then the new contact is abandoned (not added).
+                    * If the selection is our old contact and the candidate is our old contact
+                    * then we are refreshing the contact and it is marked as most recently
+                    * contacted (by being moved to the right/end of the bucket array).
+                    * If the selection is our new contact, the old contact is removed and the new
+                    * contact is marked as most recently contacted.
+                    *
+                    * @param  {Object} node    internal object that has 2 leafs: left and right
+                    * @param  {Number} index   the index in the bucket where contact exists
+                    *                          (index has already been computed in a previous
+                    *                          calculation)
+                    * @param  {Object} contact The contact object to update.
+                    */
                     this._update = function (node, index, contact) {
                         // sanity check
                         if (!arrayEquals(node.contacts[index].id, contact.id)) {
@@ -9463,7 +9508,7 @@
                         }
 
                         const incumbent = node.contacts[index]
-                        
+
                         /***************Change made by Abhishek*************/
                         const selection = this.arbiter(incumbent, contact)
                         //const selection = localbitcoinplusplus.kademlia.arbiter(incumbent, contact);
@@ -9474,7 +9519,10 @@
                         node.contacts.splice(index, 1) // remove old contact
                         node.contacts.push(selection) // add more recent contact version
                         /***************Change made by Abhishek*************/
-                        reactor.dispatchEvent('updated', {...incumbent, ...selection})
+                        reactor.dispatchEvent('updated', {
+                            ...incumbent,
+                            ...selection
+                        })
                         //reactor.dispatchEvent('updated', incumbent.concat(selection))
                     }
                 }
@@ -9485,25072 +9533,26265 @@
 
         }
     </script>
-
     <!-- tristanls/discover -->
     <script>
-        (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
-(function (process,Buffer){
-/*
-
-index.js - "discover": Node discovery based on Kademlia DHT protocol
-
-The MIT License (MIT)
-
-Copyright (c) 2013-2014 Tristan Slominski
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-*/
-"use strict";
-
-var clone = require('clone'),
-    crypto = require('crypto'),
-    events = require('events'),
-    KBucket = require('k-bucket'),
-    LruCache = require('lru-cache'),
-    util = require('util');
-
-/*
-  * `options`:
-    * `CONCURRENCY_CONSTANT`: _Integer_ _(Default: 3)_ Number of concurrent
-            FIND-NODE requests to the network per `find` request.
-    * `arbiter`: _Function_ _(Default: vector clock arbiter)_
-            `function (incumbent, candidate) {}` An optional arbiter function.
-            `arbiter` function is used in three places. First, it is used as the
-            k-bucket `arbiter` function. Second, it is used to determine whether
-            a new remote contact should be inserted into the LRU cache (if
-            `arbiter` returns something `!==` to the cached contact the remote
-            contact will be inserted). Third, it is used to determine if
-            unregistering a contact will succeed (if `arbiter` returns contact
-            `===` to the stored contact, unregister will fail).
-    * `arbiterDefaults`: _Function_ _(Default: vector clock arbiter defaults)_
-            `function (contact) {}` An optional arbiter defaults function that
-            sets `contact` arbiter defaults when a `contact` is first registered.
-            Remote contacts that are added via `add` are assumed to have
-            appropriate arbiter properties already set.
-    * `eventTrace`: _Boolean_ _(Default: false)_ If set to `true`, Discover will
-            emit `~trace` events for debugging purposes.
-    * `inlineTrace`: _Boolean_ _(Default: false)_ If set to `true`, Discover
-            will log to console `~trace` messages for debugging purposes.
-    * `maxCacheSize`: _Number_ _(Default: 1000)_ Maximum number of `contacts` to
-            keep in non-kBucket cache (see #6)
-    * `noCache`: _Boolean_ _(Default: false)_ If `true`, non-kBucket cache is not
-            used.
-    * `seeds`: _Array_ _(Default: [])_ An array of seed `contact` Objects that
-            the `transport` understands.
-    * `transport`: _Object_ _(Default: `discover-tcp-transport`)_ An optional
-            initialized and ready to use transport module for sending
-            communications that conforms to the Transport Protocol.
-            If `transport` is not provided, a new instance of
-            `discover-tcp-transport` will be created and used with default
-            settings.
-*/
-var Discover = module.exports = window.tristanDiscover = function Discover (options) {
-    var self = this;
-    events.EventEmitter.call(self);
-
-    options = options || {};
-
-    self.CONCURRENCY_CONSTANT = options.CONCURRENCY_CONSTANT || 3;
-    self.maxCacheSize = options.maxCacheSize || 1000;
-    self.noCache = options.noCache === undefined ? false : options.noCache;
-
-    self.arbiterDefaults = options.arbiterDefaults || function arbiterDefaults(contact) {
-        if (!contact.vectorClock) {
-            contact.vectorClock = 0;
-        }
-        return contact;
-    };
-
-    self.arbiter = options.arbiter || function arbiter(incumbent, candidate) {
-        if (!incumbent
-            || (incumbent && !incumbent.vectorClock)
-            || (incumbent && incumbent.vectorClock && candidate.vectorClock
-                && (candidate.vectorClock >= incumbent.vectorClock))) {
-
-            return candidate;
-        }
-        return incumbent;
-    };
-
-    self.seeds = options.seeds || [];
-    // configure tracing for debugging purposes
-    // TODO: probably change this to some sort of sane logging
-    self.options = options;
-
-    self.tracing = (options.inlineTrace || options.eventTrace);
-
-    if (self.tracing)
-        self.trace('tracing is enabled');
-
-    self.transport = options.transport;
-    if (!self.transport) {
-        var TcpTransport = require('discover-tcp-transport');
-        self.transport = new TcpTransport(options);
-    }
-
-    // register a listener to update our k-buckets with nodes that we manage
-    // contact with
-    self.transport.on('node', function (error, contact, nodeId, response) {
-        var latency = self.timerEndInMilliseconds('find.request.ms', contact.id + nodeId);
-        if (error) {
-            self.emit('stats.timers.find.request.ms', latency);
-            return; // failed contact
-        }
-
-        if (Array.isArray(response)) {
-            // arbiter "closer" responses against locally registered contacts
-            response.forEach(function (res) {
-                if (self.kBuckets[res.id]) {
-                    self.kBuckets[res.id].contact =
-                        self.arbiter(self.kBuckets[res.id].contact, res);
+        (function () {
+            function r(e, n, t) {
+                function o(i, f) {
+                    if (!n[i]) {
+                        if (!e[i]) {
+                            var c = "function" == typeof require && require;
+                            if (!f && c) return c(i, !0);
+                            if (u) return u(i, !0);
+                            var a = new Error("Cannot find module '" + i + "'");
+                            throw a.code = "MODULE_NOT_FOUND", a
+                        }
+                        var p = n[i] = {
+                            exports: {}
+                        };
+                        e[i][0].call(p.exports, function (r) {
+                            var n = e[i][1][r];
+                            return o(n || r)
+                        }, p, p.exports, r, e, n, t)
+                    }
+                    return n[i].exports
                 }
-            });
-        } else if (response && response.id) {
-            // arbiter exact match response against locally registered contacts
-            if (self.kBuckets[response.id]) {
-                self.kBuckets[response.id].contact =
-                    self.arbiter(self.kBuckets[response.id].contact, response);
+                for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
+                return o
             }
-        }
+            return r
+        })()({
+            1: [function (require, module, exports) {
+                (function (process, Buffer) {
+                    /*
 
-        // we successfully contacted the "contact", add it
-        self.add(contact);
-        self.emit('stats.timers.find.request.ms', latency);
-    });
+                    index.js - "discover": Node discovery based on Kademlia DHT protocol
 
-    // register a listener to handle transport 'findNode' events
-    self.transport.on('findNode', function (nodeId, sender, callback) {
-        if (self.tracing)
-            self.trace("on 'findNode' - nodeId: " + nodeId + ", sender: " + util.inspect(sender));
-        // check if nodeId is one of the locally registered nodes
-        var localContactKBucket = self.kBuckets[nodeId];
-        if (localContactKBucket) {
-            callback(null, localContactKBucket.contact);
-        }
+                    The MIT License (MIT)
 
-        var closestKBuckets = self.getClosestKBuckets(nodeId);
-        var closestContacts = self.getClosestContacts(nodeId, closestKBuckets);
+                    Copyright (c) 2013-2014 Tristan Slominski
 
-        // add the sender if it exists
-        if (sender) {
-            // we do it only after we already got the closest contact to prevent
-            // always responding with exact match to the sender if the sender is
-            // announcing (searching for itself)
+                    Permission is hereby granted, free of charge, to any person
+                    obtaining a copy of this software and associated documentation
+                    files (the "Software"), to deal in the Software without
+                    restriction, including without limitation the rights to use,
+                    copy, modify, merge, publish, distribute, sublicense, and/or sell
+                    copies of the Software, and to permit persons to whom the
+                    Software is furnished to do so, subject to the following
+                    conditions:
+
+                    The above copyright notice and this permission notice shall be
+                    included in all copies or substantial portions of the Software.
+
+                    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+                    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+                    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+                    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+                    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+                    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+                    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+                    OTHER DEALINGS IN THE SOFTWARE.
+
+                    */
+                    "use strict";
+
+                    var clone = require('clone'),
+                        crypto = require('crypto'),
+                        events = require('events'),
+                        KBucket = require('k-bucket'),
+                        LruCache = require('lru-cache'),
+                        util = require('util');
+
+                    /*
+                    * `options`:
+                        * `CONCURRENCY_CONSTANT`: _Integer_ _(Default: 3)_ Number of concurrent
+                                FIND-NODE requests to the network per `find` request.
+                        * `arbiter`: _Function_ _(Default: vector clock arbiter)_
+                                `function (incumbent, candidate) {}` An optional arbiter function.
+                                `arbiter` function is used in three places. First, it is used as the
+                                k-bucket `arbiter` function. Second, it is used to determine whether
+                                a new remote contact should be inserted into the LRU cache (if
+                                `arbiter` returns something `!==` to the cached contact the remote
+                                contact will be inserted). Third, it is used to determine if
+                                unregistering a contact will succeed (if `arbiter` returns contact
+                                `===` to the stored contact, unregister will fail).
+                        * `arbiterDefaults`: _Function_ _(Default: vector clock arbiter defaults)_
+                                `function (contact) {}` An optional arbiter defaults function that
+                                sets `contact` arbiter defaults when a `contact` is first registered.
+                                Remote contacts that are added via `add` are assumed to have
+                                appropriate arbiter properties already set.
+                        * `eventTrace`: _Boolean_ _(Default: false)_ If set to `true`, Discover will
+                                emit `~trace` events for debugging purposes.
+                        * `inlineTrace`: _Boolean_ _(Default: false)_ If set to `true`, Discover
+                                will log to console `~trace` messages for debugging purposes.
+                        * `maxCacheSize`: _Number_ _(Default: 1000)_ Maximum number of `contacts` to
+                                keep in non-kBucket cache (see #6)
+                        * `noCache`: _Boolean_ _(Default: false)_ If `true`, non-kBucket cache is not
+                                used.
+                        * `seeds`: _Array_ _(Default: [])_ An array of seed `contact` Objects that
+                                the `transport` understands.
+                        * `transport`: _Object_ _(Default: `discover-tcp-transport`)_ An optional
+                                initialized and ready to use transport module for sending
+                                communications that conforms to the Transport Protocol.
+                                If `transport` is not provided, a new instance of
+                                `discover-tcp-transport` will be created and used with default
+                                settings.
+                    */
+                    var Discover = module.exports = window.tristanDiscover = function Discover(options) {
+                        var self = this;
+                        events.EventEmitter.call(self);
+
+                        options = options || {};
+
+                        self.CONCURRENCY_CONSTANT = options.CONCURRENCY_CONSTANT || 3;
+                        self.maxCacheSize = options.maxCacheSize || 1000;
+                        self.noCache = options.noCache === undefined ? false : options.noCache;
+
+                        self.arbiterDefaults = options.arbiterDefaults || function arbiterDefaults(
+                            contact) {
+                            if (!contact.vectorClock) {
+                                contact.vectorClock = 0;
+                            }
+                            return contact;
+                        };
+
+                        self.arbiter = options.arbiter || function arbiter(incumbent, candidate) {
+                            if (!incumbent ||
+                                (incumbent && !incumbent.vectorClock) ||
+                                (incumbent && incumbent.vectorClock && candidate.vectorClock &&
+                                    (candidate.vectorClock >= incumbent.vectorClock))) {
+
+                                return candidate;
+                            }
+                            return incumbent;
+                        };
+
+                        self.seeds = options.seeds || [];
+                        // configure tracing for debugging purposes
+                        // TODO: probably change this to some sort of sane logging
+                        self.options = options;
+
+                        self.tracing = (options.inlineTrace || options.eventTrace);
 
-            // first, check if sender contact id is locally registered
-            if (self.kBuckets[sender.id]) {
-                // sender is the same as locally registered contact
-                // need to arbiter which contact version should be retained
-                self.kBuckets[sender.id].contact =
-                    self.arbiter(self.kBuckets[sender.id].contact, sender);
-            } else {
-                var senderClosestKBuckets = self.getClosestKBuckets(sender.id);
-                if (senderClosestKBuckets.length == 0) {
-                    if (self.tracing)
-                        self.trace('no kBuckets for findNode sender '
-                            + util.inspect(sender));
-                } else {
-                    var senderClosestKBucketId = senderClosestKBuckets[0].id;
-                    var senderClosestKBucket =
-                        self.kBuckets[senderClosestKBucketId].kBucket;
-                    if (!senderClosestKBucket) {
                         if (self.tracing)
-                            self.trace('no closest kBucket for findNode sender '
-                                + util.inspect(sender));
+                            self.trace('tracing is enabled');
+
+                        self.transport = options.transport;
+                        if (!self.transport) {
+                            var TcpTransport = require('discover-tcp-transport');
+                            self.transport = new TcpTransport(options);
+                        }
+
+                        // register a listener to update our k-buckets with nodes that we manage
+                        // contact with
+                        self.transport.on('node', function (error, contact, nodeId, response) {
+                            var latency = self.timerEndInMilliseconds('find.request.ms',
+                                contact.id + nodeId);
+                            if (error) {
+                                self.emit('stats.timers.find.request.ms', latency);
+                                return; // failed contact
+                            }
+
+                            if (Array.isArray(response)) {
+                                // arbiter "closer" responses against locally registered contacts
+                                response.forEach(function (res) {
+                                    if (self.kBuckets[res.id]) {
+                                        self.kBuckets[res.id].contact =
+                                            self.arbiter(self.kBuckets[res.id].contact,
+                                                res);
+                                    }
+                                });
+                            } else if (response && response.id) {
+                                // arbiter exact match response against locally registered contacts
+                                if (self.kBuckets[response.id]) {
+                                    self.kBuckets[response.id].contact =
+                                        self.arbiter(self.kBuckets[response.id].contact,
+                                            response);
+                                }
+                            }
+
+                            // we successfully contacted the "contact", add it
+                            self.add(contact);
+                            self.emit('stats.timers.find.request.ms', latency);
+                        });
+
+                        // register a listener to handle transport 'findNode' events
+                        self.transport.on('findNode', function (nodeId, sender, callback) {
+                            if (self.tracing)
+                                self.trace("on 'findNode' - nodeId: " + nodeId +
+                                    ", sender: " + util.inspect(sender));
+                            // check if nodeId is one of the locally registered nodes
+                            var localContactKBucket = self.kBuckets[nodeId];
+                            if (localContactKBucket) {
+                                callback(null, localContactKBucket.contact);
+                            }
+
+                            var closestKBuckets = self.getClosestKBuckets(nodeId);
+                            var closestContacts = self.getClosestContacts(nodeId,
+                                closestKBuckets);
+
+                            // add the sender if it exists
+                            if (sender) {
+                                // we do it only after we already got the closest contact to prevent
+                                // always responding with exact match to the sender if the sender is
+                                // announcing (searching for itself)
+
+                                // first, check if sender contact id is locally registered
+                                if (self.kBuckets[sender.id]) {
+                                    // sender is the same as locally registered contact
+                                    // need to arbiter which contact version should be retained
+                                    self.kBuckets[sender.id].contact =
+                                        self.arbiter(self.kBuckets[sender.id].contact,
+                                            sender);
+                                } else {
+                                    var senderClosestKBuckets = self.getClosestKBuckets(
+                                        sender.id);
+                                    if (senderClosestKBuckets.length == 0) {
+                                        if (self.tracing)
+                                            self.trace('no kBuckets for findNode sender ' +
+                                                util.inspect(sender));
+                                    } else {
+                                        var senderClosestKBucketId = senderClosestKBuckets[
+                                            0].id;
+                                        var senderClosestKBucket =
+                                            self.kBuckets[senderClosestKBucketId].kBucket;
+                                        if (!senderClosestKBucket) {
+                                            if (self.tracing)
+                                                self.trace(
+                                                    'no closest kBucket for findNode sender ' +
+                                                    util.inspect(sender));
+                                        } else {
+                                            var clonedSender = clone(sender);
+                                            if (self.tracing)
+                                                self.trace('adding ' + util.inspect(
+                                                        clonedSender) +
+                                                    ' to kBucket ' + senderClosestKBucketId
+                                                );
+                                            clonedSender.id = new Buffer(clonedSender.id,
+                                                "base64");
+                                            senderClosestKBucket.add(clonedSender);
+                                        }
+                                    }
+                                }
+                            }
+
+                            // check if we already responded prior to processing the sender
+                            if (localContactKBucket)
+                                return;
+
+                            if (closestContacts.length == 0) {
+                                return callback(null, []);
+                            }
+
+                            // check for exact match
+                            if (closestContacts[0].id.toString("base64") == nodeId) {
+                                var contact = clone(closestContacts[0]);
+                                contact.id = contact.id.toString("base64");
+                                return callback(null, contact);
+                            }
+
+                            // return closest contacts
+                            var contacts = [];
+                            closestContacts.forEach(function (closeContact) {
+                                var contact = clone(closeContact);
+                                contact.id = contact.id.toString("base64");
+                                // hide implementation details
+                                delete contact.distance;
+                                contacts.push(contact);
+                            });
+
+                            return callback(null, contacts);
+                        });
+
+                        // register a listener to handle transport 'ping' events
+                        self.transport.on('ping', function (nodeId, sender, callback) {
+                            if (self.tracing)
+                                self.trace("on 'ping' - nodeId: " + nodeId + ", sender: " +
+                                    util.inspect(sender));
+
+                            // add the sender
+                            // in contrast to self.transport.on('findNode', ...) we can add the
+                            // sender prior to responding because it is verifying a ping for a
+                            // specific node and not searching for one, the 'findNode' consideration
+                            // to update K-Buckets only after responding does not apply in this case
+                            var senderClosestKBuckets = self.getClosestKBuckets(sender.id);
+                            if (senderClosestKBuckets.length == 0) {
+                                if (self.tracing)
+                                    self.trace('no kBuckets for ping sender ' + util.inspect(
+                                        sender));
+                            } else {
+                                var senderClosestKBucketId = senderClosestKBuckets[0].id;
+                                var senderClosestKBucket = self.kBuckets[
+                                    senderClosestKBucketId].kBucket;
+                                if (!senderClosestKBucket) {
+                                    if (self.tracing)
+                                        self.trace('no closest kBucket for ping sender ' +
+                                            util.inspect(sender));
+                                } else {
+                                    var clonedSender = clone(sender);
+                                    if (self.tracing)
+                                        self.trace('adding ' + util.inspect(clonedSender) +
+                                            ' to kBucket ' + senderClosestKBucketId);
+                                    clonedSender.id = new Buffer(clonedSender.id, "base64");
+                                    senderClosestKBucket.add(clonedSender);
+                                }
+                            }
+
+                            // check if nodeId is one of the locally registered nodes
+                            var localContactKBucket = self.kBuckets[nodeId];
+                            if (localContactKBucket) {
+                                callback(null, localContactKBucket.contact);
+                            } else {
+                                // the nodeId is not one of the locally registered nodes, ping fail
+                                callback(true);
+                            }
+                        });
+
+                        // register a listener to handle transport 'reached' events
+                        self.transport.on('reached', function (contact) {
+                            if (self.tracing)
+                                self.trace('reached ' + util.inspect(contact));
+
+                            // we successfully reached a contact, add it (refreshes the contact)
+                            self.add(contact);
+                        });
+
+                        // register a listener to handle transport 'unreachable' events
+                        self.transport.on('unreachable', function (contact) {
+                            self.unreachable(contact);
+                        });
+
+                        self.kBuckets = {};
+                        if (self.noCache) {
+                            self.lruCache = {
+                                del: function () {},
+                                get: function () {},
+                                set: function () {},
+                            };
+                        } else {
+                            self.lruCache = LruCache(self.maxCacheSize);
+                        }
+                        self.timers = {
+                            'find.ms': {},
+                            'find.request.ms': {},
+                            'find.round.ms': {}
+                        };
+                    };
+
+                    util.inherits(Discover, events.EventEmitter);
+
+                    /*
+                    * `remoteContact`: _Object_ Contact object to add that is not managed by this
+                        Discover node.
+                        * `id`: _String (base64)_ The contact id, base64 encoded.
+                        * `data`: _Any_ Data to be included with the contact, it is guaranteed to be
+                            returned for anyone querying for this `contact` by `id`.
+                    * Return: _Object_ Contact that was added.
+                    */
+                    Discover.prototype.add = function add(remoteContact) {
+                        var self = this;
+
+                        if (!remoteContact.id || typeof remoteContact.id !== 'string') {
+                            throw new Error("Invalid or missing contact.id");
+                        }
+
+                        // even if we don't have kBuckets to update, we can still store information
+                        // in LRU cache (check using arbiter to update cache with latest only)
+                        var cached = self.lruCache.get(remoteContact.id);
+                        var selection = self.arbiter(cached, remoteContact);
+                        if (selection !== cached) {
+                            self.lruCache.set(remoteContact.id, remoteContact);
+                        }
+
+                        if (Object.keys(self.kBuckets).length == 0) {
+                            return null; // no k-buckets to update
+                        }
+
+                        // first, check if remote contact id is locally registered
+                        if (self.kBuckets[remoteContact.id]) {
+                            // remote contact id is same as locally registered contact id
+                            // need to arbiter which contact version should be retained
+                            // (we already calculated the selection)
+                            self.kBuckets[remoteContact.id].contact = selection;
+                        } else {
+                            // we pick the closest kBucket to the node id of our contact to store the
+                            // data in, since they have the most space to accomodate near-by node ids
+                            // (inherent KBucket property)
+                            var closestKBuckets = self.getClosestKBuckets(remoteContact.id);
+                            var closestKBucketId = closestKBuckets[0].id;
+                            var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
+                            var clonedContact = clone(remoteContact);
+                            if (self.tracing) {
+                                self.trace('adding ' + util.inspect(clonedContact) + ' to kBucket ' +
+                                    closestKBucketId);
+                            }
+                            // convert id from string to Buffer
+                            clonedContact.id = new Buffer(clonedContact.id, "base64");
+                            closestKBucket.add(clonedContact);
+                        }
+
+                        return remoteContact;
+                    };
+
+                    /*
+                    * `query`: _Object_ Object containing query state for this request.
+                        * `nodeId`: _String (base64)_ Base64 encoded node id to find.
+                        * `nodes`: _Array_ `contact`s to query for `nodeId` arranged from closest to
+                                farthest.
+                        * `node`:
+                            * `id`: _String (base64)_ Base64 encoded contact id.
+                        * `nodesMap`: _Object_ A map to the same `contact`s already present in
+                                `nodes` for O(1) access.
+                    * `callback`: _Function_ The callback to call with result.
+                    */
+                    Discover.prototype.executeQuery = function executeQuery(query, callback) {
+                        var self = this;
+                        self.timerStart('find.round.ms', query.nodeId);
+
+                        if (self.tracing)
+                            self.trace('executeQuery(' + util.inspect(query, false, null) + ')');
+
+                        // query already successfully completed
+                        if (query.done)
+                            return;
+
+                        // if we have no nodes, we can't query anything
+                        if (!query.nodes || query.nodes.length == 0) {
+                            var latency = self.timerEndInMilliseconds('find.ms', query.nodeId);
+                            var roundLatency = self.timerEndInMilliseconds('find.round.ms', query.nodeId);
+                            callback(new Error("No known nodes to query"));
+                            self.emit('stats.timers.find.ms', latency);
+                            self.emit('stats.timers.find.round.ms', roundLatency);
+                            return;
+                        }
+
+                        if (query.index === undefined)
+                            query.index = 0;
+                        if (query.closest === undefined)
+                            query.closest = query.nodes[0];
+                        if (query.ongoingRequests === undefined)
+                            query.ongoingRequests = 0;
+                        if (query.newNodes === undefined)
+                            query.newNodes = [];
+
+                        // we listen for `node` events that contain the nodeId we asked for
+                        // this helps to decouple discover from the transport and allows us to
+                        // benefit from other ongoing queries (TODO: "prove" this)
+                        //
+                        // because executeQuery can be called multiple times on the same query,
+                        // we keep the state
+                        if (!query.listener) {
+                            // TODO: maybe there is an opportunity here to generate events
+                            // uniquely named by "nodeId" so I don't have to have tons of listeners
+                            // listen to everything and throw away what they don't want?
+                            query.listener = function (error, contact, nodeId, response) {
+                                // filter other queries
+                                if (nodeId != query.nodeId)
+                                    return;
+
+                                // query already successfully completed
+                                if (query.done)
+                                    return;
+
+                                // request has been handled
+                                // TODO: what happens if two requests for the same nodeId are
+                                //       happening at the same time?
+                                // maybe do a check prior to executeQuery to not duplicate searches
+                                // for the same nodeId across the network?
+                                query.ongoingRequests--;
+
+                                if (error) {
+                                    if (self.tracing) {
+                                        self.trace('error response from ' + util.inspect(
+                                                contact) +
+                                            ' looking for ' + nodeId + ': ' + util.inspect(
+                                                error));
+                                    }
+                                    var contactRecord = query.nodesMap[contact.id];
+
+                                    if (!contactRecord)
+                                        return;
+
+                                    if (contactRecord.kBucket) {
+                                        // we have a kBucket to report unreachability to
+                                        // remove from kBucket
+                                        var kBucketInfo = self.kBuckets[contactRecord.kBucket.id];
+                                        if (!kBucketInfo) {
+                                            return;
+                                        }
+
+                                        var kBucket = kBucketInfo.kBucket;
+                                        if (!kBucket) {
+                                            return;
+                                        }
+
+                                        var contactRecordToRemove = clone(contactRecord);
+                                        contactRecordToRemove.id =
+                                            new Buffer(contactRecord.id, 'base64');
+                                        kBucket.remove(contactRecordToRemove);
+                                    }
+
+                                    contactRecord.contacted = true;
+
+                                    // console.dir(query);
+
+                                    // initiate next request if there are still queries to be made
+                                    if (query.index < query.nodes.length &&
+                                        query.ongoingRequests < self.CONCURRENCY_CONSTANT) {
+                                        process.nextTick(function () {
+                                            self.executeQuery(query, callback);
+                                        });
+                                    } else {
+                                        self.queryCompletionCheck(query, callback);
+                                    }
+                                    return; // handled error
+                                }
+
+                                // we have a response, it could be an Object or Array
+
+                                if (self.tracing) {
+                                    self.trace('response from ' + util.inspect(contact) +
+                                        ' looking for ' + nodeId + ': ' + util.inspect(
+                                            response));
+                                }
+                                if (Array.isArray(response)) {
+                                    // add the closest contacts to new nodes
+                                    query.newNodes = query.newNodes.concat(response);
+
+                                    // TODO: same code inside error handler
+                                    // initiate next request if there are still queries to be made
+                                    if (query.index < query.nodes.length &&
+                                        query.ongoingRequests < self.CONCURRENCY_CONSTANT) {
+                                        process.nextTick(function () {
+                                            self.executeQuery(query, callback);
+                                        });
+                                    } else {
+                                        self.queryCompletionCheck(query, callback);
+                                    }
+                                    return;
+                                }
+
+                                // we have a response Object, found the contact!
+                                // add the new contact to the closestKBucket
+                                var finalClosestKBuckets = self.getClosestKBuckets(response.id);
+                                if (finalClosestKBuckets.length > 0) {
+                                    var finalClosestKBucket =
+                                        self.kBuckets[finalClosestKBuckets[0].id].kBucket;
+                                    var contact = clone(response);
+                                    contact.id = new Buffer(contact.id, "base64");
+                                    finalClosestKBucket.add(contact);
+                                }
+
+                                // return the response and stop querying
+                                var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+                                var roundLatency = self.timerEndInMilliseconds('find.round.ms',
+                                    nodeId);
+                                callback(null, response);
+                                query.done = true;
+                                self.transport.removeListener('node', query.listener);
+                                self.emit('stats.timers.find.ms', latency);
+                                self.emit('stats.timers.find.round.ms', roundLatency);
+                                return;
+                            };
+                            self.transport.on('node', query.listener);
+                        }
+
+                        for (query.index = query.index || 0; query.index < query.nodes.length &&
+                            query.ongoingRequests < self.CONCURRENCY_CONSTANT; query.index++) {
+
+                            query.ongoingRequests++;
+                            self.timerStart('find.request.ms', query.nodes[query.index].id + query.nodeId);
+                            self.transport.findNode(query.nodes[query.index], query.nodeId, query.sender);
+                        }
+
+                        // console.log("INSIDE EXECUTE QUERY");
+                        // console.dir(query);
+                        self.queryCompletionCheck(query, callback);
+                    };
+
+                    /*
+                    * `nodeId`: _String (base64)_ The node id to find, base64 encoded.
+                    * `callback`: _Function_ The callback to call with the result of searching for
+                            `nodeId`.
+                    * `announce`: _Object_ _(Default: undefined)_ _**CAUTION: reserved for
+                            internal use**_ Contact object, if specified, it indicates an
+                            announcement to the network so we ask the network instead of
+                            satisfying request locally and the sender is the `announce` contact
+                            object.
+                    */
+                    Discover.prototype.find = function find(nodeId, callback, announce) {
+                        var self = this;
+                        self.timerStart('find.ms', nodeId);
+
+                        var traceHeader;
+
+                        if (self.tracing) {
+                            traceHeader = "find(" + nodeId + "): ";
+                        }
+
+                        // see if we have a local match, and return it if not announcing
+                        if (!announce && self.kBuckets[nodeId]) {
+                            var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+                            callback(null, self.kBuckets[nodeId].contact);
+                            self.emit('stats.timers.find.ms', latency);
+                            return;
+                        }
+
+                        // see if we have a cache match, and return it if not announcing
+                        var cached = self.lruCache.get(nodeId);
+                        if (!announce && cached) {
+                            var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+                            callback(null, cached);
+                            self.emit('stats.timers.find.ms', latency);
+                            return;
+                        }
+
+                        // if we have no kBuckets, that means we haven't registered any nodes yet
+                        // the only nodes we are aware of are the seed nodes
+                        if (Object.keys(self.kBuckets).length == 0) {
+                            if (self.tracing)
+                                self.trace(traceHeader +
+                                    'no kBuckets, delegating to findViaSeeds()');
+                            return self.findViaSeeds(nodeId, callback, announce);
+                        }
+
+                        var closestKBuckets = self.getClosestKBuckets(nodeId);
+
+                        if (self.tracing) {
+                            self.trace(traceHeader + 'have ' + closestKBuckets.length + ' kBuckets');
+                            self.trace(traceHeader + 'kBuckets: ' + util.inspect(closestKBuckets,
+                                false, null));
+                        }
+
+                        var closestContacts = self.getClosestContacts(nodeId, closestKBuckets);
+
+                        // if none of our local kBuckets have any contacts (should only happen
+                        // when bootstrapping), talk to the seeds
+                        if (closestContacts.length == 0) {
+                            if (self.tracing)
+                                self.trace(traceHeader +
+                                    'no contacts in kBuckets, delegating to findViaSeeds()');
+                            return self.findViaSeeds(nodeId, callback, announce);
+                        }
+
+                        if (self.tracing)
+                            self.trace(traceHeader + 'have ' + closestContacts.length +
+                                ' closest contacts');
+
+                        // check if the closest contact is actually the node we are looking for
+                        if (closestContacts[0].id.toString("base64") == nodeId) {
+                            var contact = clone(closestContacts[0]);
+                            contact.id = contact.id.toString("base64");
+                            // hide internal implementation details
+                            delete contact.distance;
+                            var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+                            callback(null, contact);
+                            self.emit('stats.timers.find.ms', latency);
+                            return;
+                        }
+
+                        // closestContacts will contain contacts with id as a Buffer, we clone
+                        // the contacts so that we can have id be a base64 encoded String
+                        var closestNodes = [];
+                        var nodesMap = {};
+                        closestContacts.forEach(function (contact) {
+                            var clonedContact = clone(contact);
+                            clonedContact.id = clonedContact.id.toString("base64");
+                            clonedContact.kBucket = closestKBuckets[0]; // for reference later
+                            closestNodes.push(clonedContact);
+                            nodesMap[clonedContact.id] = clonedContact;
+                        });
+
+                        var query = {
+                            nodeId: nodeId,
+                            nodes: closestNodes,
+                            nodesMap: nodesMap,
+                            sender: self.kBuckets[closestKBuckets[0].id].contact
+                        };
+                        self.executeQuery(query, callback);
+                    };
+
+                    /*
+                    * `nodeId`: _String (base64)_ Base64 encoded node id to find.
+                    * `callback`: _Function_ The callback to call with the result of searching for
+                            `nodeId`.
+                    * `announce`: _Object_ _(Default: undefined)_ Contact object, if specified, it
+                            indicates an announcement and the sender is the `announce` contact
+                            object.
+                    */
+                    Discover.prototype.findViaSeeds = function findViaSeeds(nodeId, callback, announce) {
+                        var self = this;
+                        var traceHeader = "findViaSeeds(" + nodeId + "): ";
+
+                        // if we have no seeds, that means we don't know of any other nodes to query
+                        if (!self.seeds || self.seeds.length == 0) {
+                            if (self.tracing) {
+                                self.trace(traceHeader + 'No known seeds to query');
+                            }
+                            var latency = self.timerEndInMilliseconds('find.ms', nodeId);
+                            callback(new Error("No known seeds to query"));
+                            self.emit('stats.timers.find.ms', latency);
+                            return;
+                        }
+
+                        var closestNodes = [];
+                        var nodesMap = {};
+                        var nodeIdBuffer = new Buffer(nodeId, "base64");
+                        self.seeds.forEach(function (seed) {
+                            var seedIdBuffer = new Buffer(seed.id, "base64");
+                            var clonedSeed = clone(seed);
+                            clonedSeed.distance = KBucket.distance(nodeIdBuffer,
+                                seedIdBuffer);
+                            closestNodes.push(clonedSeed);
+                            nodesMap[clonedSeed.id] = clonedSeed;
+                        });
+
+                        closestNodes = closestNodes.sort(function (a, b) {
+                            return a.distance - b.distance;
+                        });
+
+                        // distances are now sorted, closest being first
+                        // TODO: probably refactor Query object to be it's own thing
+                        var query = {
+                            nodeId: nodeId,
+                            nodes: closestNodes,
+                            nodesMap: nodesMap,
+                            sender: announce
+                        };
+                        self.executeQuery(query, callback);
+                    };
+
+                    /*
+                    * `nodeId`: _String (base64)_ Base64 encoded node id to find closest contacts
+                            to.
+                    * `closestKBuckets`: _Array_ Sorted array of `KBucket`s from closest to
+                            furthest from `nodeId`.
+                    * Return: _Array_ List of closest contacts.
+                    */
+                    Discover.prototype.getClosestContacts = function getClosestContacts(nodeId,
+                        closestKBuckets) {
+                        var self = this;
+
+                        // we pick the closest kBucket to chose nodes from as it will have the
+                        // most information about nodes closest to nodeId, if closest kBucket has
+                        // no nodes, we pick the next one, until we find a kBucket with nodes in it
+                        // or reach the end
+                        var closestContacts = [];
+                        var closestKBucketsIndex = 0;
+                        // TODO: it is possible for closestKBucket.closest({...}, 3) to return
+                        //       less than 3 contacts, in that case a list of less than 3 will
+                        //       be returned, changing while condition to use
+                        //       `closestContacts.length < 3` may be a bette heuristic choice
+                        while (closestContacts.length == 0 &&
+                            closestKBucketsIndex < closestKBuckets.length) {
+                            var closestKBucketId = closestKBuckets[closestKBucketsIndex].id;
+                            var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
+                            // get three closest nodes
+                            closestContacts = closestKBucket.closest({
+                                id: new Buffer(nodeId, "base64")
+                            }, 3);
+                            closestKBucketsIndex++;
+                        }
+
+                        return closestContacts;
+                    };
+
+                    /*
+                    * `nodeId`: _String (base64)_ Base64 encoded node id to find closest contacts
+                            to.
+                    * Return: _Array_ List of closest `KBucket`s.
+                    */
+                    Discover.prototype.getClosestKBuckets = function getClosestKBuckets(nodeId) {
+                        var self = this;
+
+                        // TODO: change self.kBuckets data structure so that this operation is
+                        //       O(log n) instead of O(n), although, in proritizing this task
+                        //       remember the use-case of having more than one kBucket in self.kBuckets
+                        //       means that we are doing discover.register(contact) quite many times.
+                        //       It seems that for *most* use-cases, only one contact will ever be
+                        //       `discover.register`'ed (this registers identity of the local node)
+                        var closestKBuckets = [];
+                        var nodeIdBuffer = new Buffer(nodeId, "base64");
+                        Object.keys(self.kBuckets).forEach(function (kBucketKey) {
+                            var kBucket = self.kBuckets[kBucketKey];
+                            var kBucketIdBuffer = new Buffer(kBucket.id, "base64");
+                            closestKBuckets.push({
+                                id: kBucket.id,
+                                distance: KBucket.distance(nodeIdBuffer,
+                                    kBucketIdBuffer)
+                            });
+                        });
+
+                        closestKBuckets = closestKBuckets.sort(function (a, b) {
+                            return a.distance - b.distance;
+                        });
+
+                        return closestKBuckets;
+                    };
+
+                    /*
+                    * `query`: _Object_ Object containing query state for this request.
+                        * `nodeId`: _String (base64)_ Base64 encoded node id to find.
+                        * `nodes`: _Array_ `contact`s to query for `nodeId` arranged from closest to
+                                furthest.
+                        * `node`:
+                            * `id`: _String (base64)_ Base64 encoded contact id.
+                        * `nodesMap`: _Object_ A map to the same `contact`s already present in
+                                `nodes` for O(1) access.
+                    * `callback`: _Function_ The callback to call with result.
+                    */
+                    Discover.prototype.queryCompletionCheck = function queryCompletionCheck(query,
+                        callback) {
+                        var self = this;
+                        // console.log("QUERY COMPLETION CHECK");
+                        // are we done?
+                        if (query.index == query.nodes.length &&
+                            query.ongoingRequests == 0 && !query.done) {
+                            // find out if any new nodes are closer than the closest
+                            // node in order to determine if we should keep going or
+                            // stop
+                            self.emit('stats.timers.find.round.ms',
+                                self.timerEndInMilliseconds('find.round.ms', query.nodeId));
+
+                            // console.log('sorting new nodes');
+                            // sort the new nodes according to distance
+                            var newNodes = [];
+                            var nodeIdBuffer = new Buffer(query.nodeId, "base64");
+                            query.newNodes.forEach(function (newNode) {
+                                var clonedNewNode = clone(newNode);
+                                var newNodeIdBuffer = new Buffer(newNode.id, "base64");
+                                clonedNewNode.distance =
+                                    KBucket.distance(nodeIdBuffer, newNodeIdBuffer);
+                                // only add nodes that are closer to short circuit the
+                                // computation
+                                if (clonedNewNode.distance < query.closest.distance) {
+                                    newNodes.push(clonedNewNode);
+                                }
+                            });
+
+                            // console.log('sorted new nodes');
+
+                            // if we don't have any closer nodes, we didn't find
+                            // what we are looking for
+                            if (newNodes.length == 0) {
+                                // we are done done
+                                self.transport.removeListener('node', query.listener);
+
+                                // console.log('listener removed');
+                                // console.dir(query);
+                                // sanity check, just in case closest node is the one
+                                // we are looking for and wasn't short-circuited
+                                // somewhere else
+                                if (query.closest.id == query.nodeId) {
+                                    // console.log("returning closest node", query.closest);
+                                    return callback(null, query.closest);
+                                } else {
+                                    // console.log("returning not found error");
+                                    var latency = self.timerEndInMilliseconds('find.ms', query.nodeId);
+                                    callback(new Error("not found"));
+                                    self.emit('stats.timers.find.ms', latency);
+                                    return;
+                                }
+                            }
+
+                            // console.log("found closer nodes", newNodes);
+
+                            // found closer node, sort according to length
+                            newNodes = newNodes.sort(function (a, b) {
+                                return a.distance - b.distance;
+                            });
+
+                            // update query state and go another round
+                            query.index = 0;
+                            query.ongoingRequests = 0;
+                            query.nodes = newNodes; // these are sorted by distance (unlike query.newNodes)
+                            query.nodesMap = {};
+                            query.nodes.forEach(function (node) {
+                                query.nodesMap[node.id] = node;
+                            });
+                            query.closest = query.nodes[0];
+                            query.newNodes = [];
+
+                            return process.nextTick(function () {
+                                self.executeQuery(query, callback);
+                            });
+                        } // are we done?
+                        // console.log("FAILED QUERY COMPLETION CHECK >>> KEEP GOING");
+                    };
+
+                    /*
+                    * `contact`: _Object_ Contact object to register.
+                        * `id`: _String (base64)_ _(Default: `crypto.randomBytes(20).toString('base64'`)_
+                                The contact id, base 64 encoded; will be created if not present.
+                        * `data`: _Any_ Data to be included with the contact, it is guaranteed to be
+                                returned for anyone querying for this `contact` by `id`.
+                    * Return: _Object_ Contact that was registered with `id` and generated arbiter
+                        defaults if necessary.
+                    */
+                    Discover.prototype.register = function register(contact) {
+                        var self = this;
+                        contact = contact || {};
+                        contact = clone(contact); // separate references from outside
+
+                        if (!contact.id) {
+                            contact.id = crypto.randomBytes(20).toString('base64');
+                        }
+
+                        // add transport information to the stored contact
+                        contact = self.transport.setTransportInfo(contact);
+
+                        contact = self.arbiterDefaults(contact);
+
+                        var traceHeader = "register(" + contact.id + "): ";
+
+                        if (!self.kBuckets[contact.id]) {
+                            if (self.tracing)
+                                self.trace(traceHeader + 'creating new bucket for ' + util.inspect(
+                                    contact));
+                            var kBucket = new KBucket({
+                                arbiter: self.arbiter,
+                                localNodeId: contact.id
+                            });
+                            kBucket.on('ping', function (oldContacts, newContact) {
+                                // ping all the old contacts and if one does not respond, remove it
+                                var oldContactIdsBase64 = [];
+                                var reachedContactIdsBase64 = [];
+                                var unreachableListener = function (contact) {
+                                    if (oldContactIdsBase64.indexOf(contact.id) > -1) {
+                                        self.transport.removeListener('unreachable',
+                                            unreachableListener);
+                                        self.transport.removeListener('reached',
+                                            reachedListener);
+                                        kBucket.remove({
+                                            id: new Buffer(contact.id, "base64")
+                                        });
+                                        kBucket.add(newContact);
+                                    }
+                                };
+                                var reachedListener = function (contact) {
+                                    var index = reachedContactIdsBase64.indexOf(contact
+                                        .id);
+                                    if (index > -1) {
+                                        reachedContactIdsBase64.splice(index, 1);
+                                        if (reachedContactIdsBase64.length == 0) {
+                                            // all contacts were reached, won't be adding new one
+                                            self.transport.removeListener(
+                                                'unreachable', unreachableListener);
+                                            self.transport.removeListener(
+                                                'reached', reachedListener);
+                                        }
+                                    }
+                                };
+                                self.transport.on('reached', reachedListener);
+                                self.transport.on('unreachable', unreachableListener);
+                                var sender = self.kBuckets[contact.id].contact;
+                                oldContacts.forEach(function (oldContact) {
+                                    var contact = clone(oldContact);
+                                    contact.id = oldContact.id.toString("base64");
+                                    oldContactIdsBase64.push(contact.id);
+                                    reachedContactIdsBase64.push(contact.id);
+                                    self.transport.ping(contact, sender);
+                                });
+                            });
+                            self.kBuckets[contact.id] = {
+                                contact: contact,
+                                id: contact.id,
+                                kBucket: kBucket
+                            };
+                        } else {
+                            if (self.tracing)
+                                self.trace(traceHeader +
+                                    'bucket already exists, updating contact with ' + util.inspect(
+                                        contact));
+                            self.kBuckets[contact.id].contact = contact;
+                        }
+
+                        // issuing find(contact.id) against own contact.id, populates the DHT
+                        // with contact
+                        self.find(contact.id, function () {}, contact /*announce*/ );
+
+                        return clone(contact); // don't leak internal implementation
+                    };
+
+                    /*
+                    * `type`: _String_ Timer type.
+                    * `key`: _String_ Timer key.
+                    * Return: _Number_ Milliseconds since the first time in the timer.
+                    */
+                    Discover.prototype.timerEndInMilliseconds = function timerEndInMilliseconds(type,
+                        key) {
+                        var self = this;
+
+                        if (!self.timers[type] || !self.timers[type][key]) {
+                            return 0;
+                        }
+
+                        var diff = process.hrtime(self.timers[type][key].shift());
+                        if (self.timers[type][key].length == 0) {
+                            delete self.timers[type][key];
+                        }
+                        // diff[0] : seconds
+                        // diff[1] : nanoseconds
+                        // 1 second = 1e9 nanoseconds
+                        // 1 millisecond = 1e6 nanoseconds
+                        return Math.floor((diff[0] * 1e9 + diff[1]) / 1e6);
+                    };
+
+                    /*
+                    * `type`: _String_ Timer type.
+                    * `key`: _String_ Timer key.
+                    */
+                    Discover.prototype.timerStart = function timerStart(type, key) {
+                        var self = this;
+                        self.timers[type][key] = self.timers[type][key] || [];
+                        self.timers[type][key].push(process.hrtime());
+                    };
+
+                    /*
+                    * `message`: _String_ Message to trace.
+                    */
+                    Discover.prototype.trace = function (message) {
+                        var self = this;
+                        var options = self.options;
+
+                        if (options.inlineTrace)
+                            console.log('~trace', message);
+                        if (options.eventTrace)
+                            self.emit('~trace', message);
+                    };
+
+                    /*
+                    * `contact`: _Object_ Contact object to report unreachable
+                        * `id`: _String (base64)_ The previously registered contact id, base64
+                                encoded.
+                    */
+                    Discover.prototype.unreachable = function unreachable(contact) {
+                        var self = this;
+                        if (self.tracing)
+                            self.trace('unreachable(' + util.inspect(contact) + ')');
+
+                        // even if we don't have kBuckets, remove contact from LRU cache
+                        self.lruCache.del(contact.id);
+
+                        // find closest KBucket to remove unreachable contact from
+                        var closestKBuckets = self.getClosestKBuckets(contact.id);
+                        if (closestKBuckets.length == 0) {
+                            if (self.tracing)
+                                self.trace('no kBuckets for unreachable(contact) ' + util.inspect(
+                                    contact));
+                            return;
+                        }
+                        var closestKBucketId = closestKBuckets[0].id;
+                        var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
+                        if (!closestKBucket) {
+                            if (self.tracing)
+                                self.trace('no closest kBucket for unreachable(contact) ' + util.inspect(
+                                    contact));
+                            return;
+                        }
+                        var clonedContact = clone(contact);
+                        if (self.tracing)
+                            self.trace('removing ' + util.inspect(contact) + ' from kBucket ' +
+                                closestKBucketId);
+                        clonedContact.id = new Buffer(contact.id, "base64");
+                        closestKBucket.remove(clonedContact);
+                    };
+
+                    /*
+                    * `contact`: _Object_ Contact object to register
+                        * `id`: _String (base64)_ The previously registered contact id, base 64
+                                encoded.
+                    */
+                    Discover.prototype.unregister = function unregister(contact) {
+                        var self = this;
+                        var kBucket = self.kBuckets[contact.id];
+                        if (kBucket) {
+                            if (kBucket.contact === self.arbiter(kBucket.contact, contact) &&
+                                kBucket.contact !== contact) {
+                                // by returning the stored contact, arbiter determined that
+                                // unregister should fail as an attempt to unregister using
+                                // old data has been made
+                                return;
+                            }
+                            delete self.kBuckets[contact.id];
+                        }
+
+                        // current implemenation deletes all that "closest" contact information
+                        // that was gathered in the unregistering kBucket
+
+                        // TODO: elaborate the implementation to distribute known nodes in this
+                        //       kBucket to ones that aren't being deleted
+                    };
+                }).call(this, require('_process'), require("buffer").Buffer)
+            }, {
+                "_process": 125,
+                "buffer": 55,
+                "clone": 2,
+                "crypto": 63,
+                "discover-tcp-transport": 3,
+                "events": 90,
+                "k-bucket": 4,
+                "lru-cache": 5,
+                "util": 162
+            }],
+            2: [function (require, module, exports) {
+                (function (Buffer) {
+                    "use strict";
+
+                    function objectToString(o) {
+                        return Object.prototype.toString.call(o);
+                    }
+
+                    var util = {
+                        isArray: function (ar) {
+                            return Array.isArray(ar) || (typeof ar === 'object' &&
+                                objectToString(ar) === '[object Array]');
+                        },
+                        isDate: function (d) {
+                            return typeof d === 'object' && objectToString(d) ===
+                                '[object Date]';
+                        },
+                        isRegExp: function (re) {
+                            return typeof re === 'object' && objectToString(re) ===
+                                '[object RegExp]';
+                        },
+                        getRegExpFlags: function (re) {
+                            var flags = '';
+                            re.global && (flags += 'g');
+                            re.ignoreCase && (flags += 'i');
+                            re.multiline && (flags += 'm');
+                            return flags;
+                        }
+                    };
+
+                    if (typeof module === 'object')
+                        module.exports = clone;
+
+                    /**
+                    * Clones (copies) an Object using deep copying.
+                    *
+                    * This function supports circular references by default, but if you are certain
+                    * there are no circular references in your object, you can save some CPU time
+                    * by calling clone(obj, false).
+                    *
+                    * Caution: if `circular` is false and `parent` contains circular references,
+                    * your program may enter an infinite loop and crash.
+                    *
+                    * @param `parent` - the object to be cloned
+                    * @param `circular` - set to true if the object to be cloned may contain
+                    *    circular references. (optional - true by default)
+                    */
+                    function clone(parent, circular) {
+                        if (typeof circular == 'undefined')
+                            circular = true;
+
+                        var useBuffer = typeof Buffer != 'undefined';
+
+                        var circularParent = {};
+                        var circularResolved = {};
+                        var circularReplace = [];
+
+                        function _clone(parent, context, child, cIndex) {
+                            var i; // Use local context within this function
+                            // Deep clone all properties of parent into child
+                            if (typeof parent == 'object') {
+                                if (parent == null)
+                                    return parent;
+                                // Check for circular references
+                                for (i in circularParent)
+                                    if (circularParent[i] === parent) {
+                                        // We found a circular reference
+                                        circularReplace.push({
+                                            'resolveTo': i,
+                                            'child': child,
+                                            'i': cIndex
+                                        });
+                                        return null; //Just return null for now...
+                                        // we will resolve circular references later
+                                    }
+
+                                // Add to list of all parent objects
+                                circularParent[context] = parent;
+                                // Now continue cloning...
+                                if (util.isArray(parent)) {
+                                    child = [];
+                                    for (i in parent)
+                                        child[i] = _clone(parent[i], context + '[' + i + ']', child, i);
+                                } else if (util.isDate(parent))
+                                    child = new Date(parent.getTime());
+                                else if (util.isRegExp(parent)) {
+                                    child = new RegExp(parent.source, util.getRegExpFlags(parent));
+                                    if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+                                } else if (useBuffer && Buffer.isBuffer(parent)) {
+                                    child = new Buffer(parent.length);
+                                    parent.copy(child);
+                                } else {
+                                    child = {};
+
+                                    // Also copy prototype over to new cloned object
+                                    child.__proto__ = parent.__proto__;
+                                    for (i in parent)
+                                        child[i] = _clone(parent[i], context + '[' + i + ']', child, i);
+                                }
+
+                                // Add to list of all cloned objects
+                                circularResolved[context] = child;
+                            } else
+                                child = parent; //Just a simple shallow copy will do
+                            return child;
+                        }
+
+                        var i;
+                        if (circular) {
+                            var cloned = _clone(parent, '*');
+
+                            // Now this object has been cloned. Let's check to see if there are any
+                            // circular references for it
+                            for (i in circularReplace) {
+                                var c = circularReplace[i];
+                                if (c && c.child && c.i in c.child) {
+                                    c.child[c.i] = circularResolved[c.resolveTo];
+                                }
+                            }
+                            return cloned;
+                        } else {
+                            // Deep clone all properties of parent into child
+                            var child;
+                            if (typeof parent == 'object') {
+                                if (parent == null)
+                                    return parent;
+                                if (parent.constructor.name === 'Array') {
+                                    child = [];
+                                    for (i in parent)
+                                        child[i] = clone(parent[i], circular);
+                                } else if (util.isDate(parent))
+                                    child = new Date(parent.getTime());
+                                else if (util.isRegExp(parent)) {
+                                    child = new RegExp(parent.source, util.getRegExpFlags(parent));
+                                    if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+                                } else {
+                                    child = {};
+                                    child.__proto__ = parent.__proto__;
+                                    for (i in parent)
+                                        child[i] = clone(parent[i], circular);
+                                }
+                            } else
+                                child = parent; // Just a simple shallow clone will do
+                            return child;
+                        }
+                    }
+
+                    /**
+                    * Simple flat clone using prototype, accepts only objects, usefull for property
+                    * override on FLAT configuration object (no nested props).
+                    *
+                    * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+                    * works.
+                    */
+                    clone.clonePrototype = function (parent) {
+                        if (parent === null)
+                            return null;
+
+                        var c = function () {};
+                        c.prototype = parent;
+                        return new c();
+                    };
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "buffer": 55
+            }],
+            3: [function (require, module, exports) {
+                /*
+
+                index.js - discover-tcp-transport: TCP transport for Discover node discovery
+
+                The MIT License (MIT)
+
+                Copyright (c) 2013-2014 Tristan Slominski
+
+                Permission is hereby granted, free of charge, to any person
+                obtaining a copy of this software and associated documentation
+                files (the "Software"), to deal in the Software without
+                restriction, including without limitation the rights to use,
+                copy, modify, merge, publish, distribute, sublicense, and/or sell
+                copies of the Software, and to permit persons to whom the
+                Software is furnished to do so, subject to the following
+                conditions:
+
+                The above copyright notice and this permission notice shall be
+                included in all copies or substantial portions of the Software.
+
+                THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+                EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+                OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+                NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+                HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+                WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+                FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+                OTHER DEALINGS IN THE SOFTWARE.
+
+                */
+                "use strict";
+
+                var events = require('events'),
+                    net = require('net'),
+                    util = require('util');
+
+                var TcpTransport = module.exports = function TcpTransport(options) {
+                    var self = this;
+                    events.EventEmitter.call(self);
+
+                    options = options || {};
+
+                    self.id = options.id;
+                    self.host = options.host || 'localhost';
+                    self.port = options.port || 6742;
+
+                    self.server = null;
+                };
+
+                util.inherits(TcpTransport, events.EventEmitter);
+
+                /*
+                * `options`: See `new TcpTransport(options)` `options`.
+                * `callback`: See `tcpTransport.listen(callback)` `callback`.
+                Return: _Object_ An instance of TcpTransport with server running.
+                */
+                TcpTransport.listen = function listen(options, callback) {
+                    var tcpTransport = new TcpTransport(options);
+                    tcpTransport.listen(callback);
+                    return tcpTransport;
+                };
+
+                /*
+                * `callback`: _Function_ _(Default: undefined)_ Optional callback to call once
+                    the server is stopped.
+                */
+                TcpTransport.prototype.close = function close(callback) {
+                    var self = this;
+                    if (self.server)
+                        self.server.close(callback);
+                };
+
+                /*
+                * `contact`: _Object_ The node to contact with request to find `nodeId`.
+                * `id`: _String (base64)_ Base64 encoded contact node id.
+                * `transport`: _Object_ TCP transport data.
+                * `host`: _String_ IP address to connect to.
+                * `port`: _Integer_ Port to connect to.
+                * `nodeId`: _String (base64)_ Base64 encoded string representation of the node id to find.
+                * `sender`: _Object_ The node making the request
+                * `id`: _String (base64)_ Base64 encoded sender node id.
+                * `data`: _Any_ Sender node data.
+                * `transport`: _Object_ TCP transport data.
+                * `host`: _String_ Host to connect to.
+                * `port`: _Integer_ Port to connect to.
+                */
+                TcpTransport.prototype.findNode = function findNode(contact, nodeId, sender) {
+                    var self = this;
+                    self.rpc(contact, {
+                        request: {
+                            findNode: nodeId
+                        },
+                        sender: sender
+                    }, function (error, data) {
+                        if (error) {
+                            self.emit('node', new Error('unreachable'), contact, nodeId);
+                            self.emit('unreachable', contact);
+                            return;
+                        }
+                        if (!data)
+                            return self.emit('node', new Error('no data received'), contact,
+                                nodeId);
+
+                        try {
+                            data = JSON.parse(data.toString());
+                            return self.emit('node', null, contact, nodeId, data);
+                        } catch (exception) {
+                            self.emit('node',
+                                new Error('JSON parse error: ' + exception.message +
+                                    ' when parsing ' + data),
+                                contact, nodeId);
+                        }
+                    });
+                };
+
+                /*
+                * `callback`: _Function_ _(Default: undefined)_ Optional callback to call once
+                    the server is up.
+                */
+                TcpTransport.prototype.listen = function listen(callback) {
+                    var self = this;
+                    self.server = net.createServer(function (connection) {
+                        var responseCallback = function (response) {
+                            connection.write(JSON.stringify(response) + '\r\n');
+                            connection.end();
+                        };
+                        var data = "";
+                        connection.on('data', function (chunk) {
+                            data += chunk.toString("utf8");
+                            if (!~data.indexOf('\r\n')) {
+                                return; // wait for more data
+                            }
+
+                            try {
+                                data = JSON.parse(data.toString("utf8"));
+                            } catch (exception) {
+                                return connection.end(); // kill connection
+                            }
+                            if (data.request && data.request.findNode) {
+                                self.emit('findNode', data.request.findNode, data.sender,
+                                    function (error, response) {
+                                        if (error)
+                                            return connection.end();
+                                        if (responseCallback)
+                                            responseCallback(response);
+                                    });
+                            } else if (data.request && data.request.ping) {
+                                self.emit('ping', data.request.ping, data.sender,
+                                    function (error, response) {
+                                        if (error)
+                                            return connection.end();
+                                        if (responseCallback)
+                                            responseCallback(response);
+                                    });
+                            } else {
+                                return connection.end(); // kill connection
+                            }
+                        });
+                        connection.on('end', function () {
+                            responseCallback = undefined;
+                        });
+                        connection.on('error', function (error) {
+                            responseCallback = undefined;
+                        });
+                    });
+                    self.server.listen(self.port, self.host, callback);
+                };
+
+                /*
+                * `contact`: _Object_ Contact to ping.
+                * `id`: _String (base64)_ Base64 encoded contact node id.
+                * `transport`: _Object_ TCP transport data.
+                * `host`: _String_ Host to connect to.
+                * `port`: _Integer_ Port to connect to.
+                * `sender`: _Object_ The contact making the request.
+                * `id`: _String (base64)_ Base64 encoded sender node id.
+                * `data`: _Any_ Sender node data.
+                * `transport`: _Object_ TCP transport data.
+                * `host`: _String_ Host of the sender.
+                * `port`: _Integer_ Port of the sender.
+                */
+                TcpTransport.prototype.ping = function ping(contact, sender) {
+                    var self = this;
+                    self.rpc(contact, {
+                        request: {
+                            ping: contact.id
+                        },
+                        sender: sender
+                    }, function (error, data) {
+                        if (error || !data)
+                            return self.emit('unreachable', contact);
+
+                        try {
+                            data = JSON.parse(data);
+                            if (data.id === undefined || data.transport === undefined ||
+                                data.transport.host === undefined ||
+                                data.transport.port === undefined) { // data.data is optional
+                                return self.emit('unreachable', contact);
+                            }
+                            return self.emit('reached', contact);
+                        } catch (exception) {
+                            // console.dir(exception);
+                            return self.emit('unreachable', contact);
+                        }
+                    });
+                };
+
+                /*
+                * `contact`: _Object_ Contact to ping.
+                    * `id`: _String (base64)_ Base64 encoded contact node id.
+                    * `transport`: _Object_ TCP transport data.
+                    * `host`: _String_ Host to connect to.
+                    * `port`: _Integer_ Port to connect to.
+                * `payload`: _String_ or _Object_ Payload to send on the wire. If an _Object_
+                    is provided, it will be `JSON.stringify()`'ed.
+                * `callback`: _Function_ Callback to call with an error or response.
+                */
+                TcpTransport.prototype.rpc = function rpc(contact, payload, callback) {
+                    var self = this;
+                    var client = net.connect({
+                            host: contact.transport.host,
+                            port: contact.transport.port
+                        },
+                        function () {
+                            if (typeof payload != "string")
+                                payload = JSON.stringify(payload);
+                            client.write(payload + '\r\n');
+                        });
+
+                    var hasError = false;
+                    var data = "";
+                    client.on('data', function (buf) {
+                        data += buf.toString("utf8");
+                    });
+                    client.on('end', function () {
+                        if (!hasError)
+                            callback(null, data);
+                    });
+                    client.on('error', function (error) {
+                        hasError = true;
+                        callback(error);
+                    });
+                };
+
+                /*
+                * `contact`: _Object_ A contact.
+                * Return: _Object_ `contact` with `contact.transport` populated.
+                */
+                TcpTransport.prototype.setTransportInfo = function setTransportInfo(contact) {
+                    var self = this;
+
+                    contact.transport = {
+                        host: self.host,
+                        port: self.port
+                    };
+                    return contact;
+                };
+
+            }, {
+                "events": 90,
+                "net": 8,
+                "util": 162
+            }],
+            4: [function (require, module, exports) {
+                /*
+                index.js - Kademlia DHT K-bucket implementation as a binary tree.
+
+                The MIT License (MIT)
+
+                Copyright (c) 2013-2018 Tristan Slominski
+
+                Permission is hereby granted, free of charge, to any person
+                obtaining a copy of this software and associated documentation
+                files (the "Software"), to deal in the Software without
+                restriction, including without limitation the rights to use,
+                copy, modify, merge, publish, distribute, sublicense, and/or sell
+                copies of the Software, and to permit persons to whom the
+                Software is furnished to do so, subject to the following
+                conditions:
+
+                The above copyright notice and this permission notice shall be
+                included in all copies or substantial portions of the Software.
+
+                THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+                EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+                OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+                NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+                HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+                WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+                FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+                OTHER DEALINGS IN THE SOFTWARE.
+                */
+                'use strict'
+
+                const randomBytes = require('randombytes')
+                const {
+                    EventEmitter
+                } = require('events')
+
+                /**
+                * @param  {Uint8Array} array1
+                * @param  {Uint8Array} array2
+                * @return {Boolean}
+                */
+                function arrayEquals(array1, array2) {
+                    if (array1 === array2) {
+                        return true
+                    }
+                    if (array1.length !== array2.length) {
+                        return false
+                    }
+                    for (let i = 0, length = array1.length; i < length; ++i) {
+                        if (array1[i] !== array2[i]) {
+                            return false
+                        }
+                    }
+                    return true
+                }
+
+                function createNode() {
+                    return {
+                        contacts: [],
+                        dontSplit: false,
+                        left: null,
+                        right: null
+                    }
+                }
+
+                function ensureInt8(name, val) {
+                    if (!(val instanceof Uint8Array)) {
+                        throw new TypeError(name + ' is not a Uint8Array')
+                    }
+                }
+
+                /**
+                * Implementation of a Kademlia DHT k-bucket used for storing
+                * contact (peer node) information.
+                *
+                * @extends EventEmitter
+                */
+                class KBucket extends EventEmitter {
+                    /**
+                    * `options`:
+                    *   `distance`: _Function_
+                    *     `function (firstId, secondId) { return distance }` An optional
+                    *     `distance` function that gets two `id` Uint8Arrays
+                    *     and return distance (as number) between them.
+                    *   `arbiter`: _Function_ _(Default: vectorClock arbiter)_
+                    *     `function (incumbent, candidate) { return contact; }` An optional
+                    *     `arbiter` function that givent two `contact` objects with the same `id`
+                    *     returns the desired object to be used for updating the k-bucket. For
+                    *     more details, see [arbiter function](#arbiter-function).
+                    *   `localNodeId`: _Uint8Array_ An optional Uint8Array representing the local node id.
+                    *     If not provided, a local node id will be created via `randomBytes(20)`.
+                    *     `metadata`: _Object_ _(Default: {})_ Optional satellite data to include
+                    *     with the k-bucket. `metadata` property is guaranteed not be altered by,
+                    *     it is provided as an explicit container for users of k-bucket to store
+                    *     implementation-specific data.
+                    *   `numberOfNodesPerKBucket`: _Integer_ _(Default: 20)_ The number of nodes
+                    *     that a k-bucket can contain before being full or split.
+                    *     `numberOfNodesToPing`: _Integer_ _(Default: 3)_ The number of nodes to
+                    *     ping when a bucket that should not be split becomes full. KBucket will
+                    *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
+                    *     not been contacted the longest.
+                    *
+                    * @param {Object=} options optional
+                    */
+                    constructor(options = {}) {
+                        super()
+
+                        this.localNodeId = options.localNodeId || randomBytes(20)
+                        this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
+                        this.numberOfNodesToPing = options.numberOfNodesToPing || 3
+                        this.distance = options.distance || KBucket.distance
+                        // use an arbiter from options or vectorClock arbiter by default
+                        this.arbiter = options.arbiter || KBucket.arbiter
+                        this.metadata = Object.assign({}, options.metadata)
+
+                        ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
+
+                        this.root = createNode()
+                    }
+
+                    /**
+                    * Default arbiter function for contacts with the same id. Uses
+                    * contact.vectorClock to select which contact to update the k-bucket with.
+                    * Contact with larger vectorClock field will be selected. If vectorClock is
+                    * the same, candidat will be selected.
+                    *
+                    * @param  {Object} incumbent Contact currently stored in the k-bucket.
+                    * @param  {Object} candidate Contact being added to the k-bucket.
+                    * @return {Object}           Contact to updated the k-bucket with.
+                    */
+                    static arbiter(incumbent, candidate) {
+                        return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
+                    }
+
+                    /**
+                    * Default distance function. Finds the XOR
+                    * distance between firstId and secondId.
+                    *
+                    * @param  {Uint8Array} firstId  Uint8Array containing first id.
+                    * @param  {Uint8Array} secondId Uint8Array containing second id.
+                    * @return {Number}              Integer The XOR distance between firstId
+                    *                               and secondId.
+                    */
+                    static distance(firstId, secondId) {
+                        let distance = 0
+                        let i = 0
+                        const min = Math.min(firstId.length, secondId.length)
+                        const max = Math.max(firstId.length, secondId.length)
+                        for (; i < min; ++i) {
+                            distance = distance * 256 + (firstId[i] ^ secondId[i])
+                        }
+                        for (; i < max; ++i) distance = distance * 256 + 255
+                        return distance
+                    }
+
+                    /**
+                    * Adds a contact to the k-bucket.
+                    *
+                    * @param {Object} contact the contact object to add
+                    */
+                    add(contact) {
+                        ensureInt8('contact.id', (contact || {}).id)
+
+                        let bitIndex = 0
+                        let node = this.root
+
+                        while (node.contacts === null) {
+                            // this is not a leaf node but an inner node with 'low' and 'high'
+                            // branches; we will check the appropriate bit of the identifier and
+                            // delegate to the appropriate node for further processing
+                            node = this._determineNode(node, contact.id, bitIndex++)
+                        }
+
+                        // check if the contact already exists
+                        const index = this._indexOf(node, contact.id)
+                        if (index >= 0) {
+                            this._update(node, index, contact)
+                            return this
+                        }
+
+                        if (node.contacts.length < this.numberOfNodesPerKBucket) {
+                            node.contacts.push(contact)
+                            this.emit('added', contact)
+                            return this
+                        }
+
+                        // the bucket is full
+                        if (node.dontSplit) {
+                            // we are not allowed to split the bucket
+                            // we need to ping the first this.numberOfNodesToPing
+                            // in order to determine if they are alive
+                            // only if one of the pinged nodes does not respond, can the new contact
+                            // be added (this prevents DoS flodding with new invalid contacts)
+                            this.emit('ping', node.contacts.slice(0, this.numberOfNodesToPing), contact)
+                            return this
+                        }
+
+                        this._split(node, bitIndex)
+                        return this.add(contact)
+                    }
+
+                    /**
+                    * Get the n closest contacts to the provided node id. "Closest" here means:
+                    * closest according to the XOR metric of the contact node id.
+                    *
+                    * @param  {Uint8Array} id  Contact node id
+                    * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
+                    *                          closest contacts to return
+                    * @return {Array}          Array Maximum of n closest contacts to the node id
+                    */
+                    closest(id, n = Infinity) {
+                        ensureInt8('id', id)
+
+                        if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
+                            throw new TypeError('n is not positive number')
+                        }
+
+                        let contacts = []
+
+                        for (let nodes = [this.root], bitIndex = 0; nodes.length > 0 && contacts.length <
+                            n;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) {
+                                const detNode = this._determineNode(node, id, bitIndex++)
+                                nodes.push(node.left === detNode ? node.right : node.left)
+                                nodes.push(detNode)
+                            } else {
+                                contacts = contacts.concat(node.contacts)
+                            }
+                        }
+
+                        return contacts
+                            .map(a => [this.distance(a.id, id), a])
+                            .sort((a, b) => a[0] - b[0])
+                            .slice(0, n)
+                            .map(a => a[1])
+                    }
+
+                    /**
+                    * Counts the total number of contacts in the tree.
+                    *
+                    * @return {Number} The number of contacts held in the tree
+                    */
+                    count() {
+                        // return this.toArray().length
+                        let count = 0
+                        for (const nodes = [this.root]; nodes.length > 0;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) nodes.push(node.right, node.left)
+                            else count += node.contacts.length
+                        }
+                        return count
+                    }
+
+                    /**
+                    * Determines whether the id at the bitIndex is 0 or 1.
+                    * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
+                    *
+                    * @param  {Object} node     internal object that has 2 leafs: left and right
+                    * @param  {Uint8Array} id   Id to compare localNodeId with.
+                    * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
+                    *                           to check in the id Uint8Array.
+                    * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
+                    */
+                    _determineNode(node, id, bitIndex) {
+                        // **NOTE** remember that id is a Uint8Array and has granularity of
+                        // bytes (8 bits), whereas the bitIndex is the _bit_ index (not byte)
+
+                        // id's that are too short are put in low bucket (1 byte = 8 bits)
+                        // (bitIndex >> 3) finds how many bytes the bitIndex describes
+                        // bitIndex % 8 checks if we have extra bits beyond byte multiples
+                        // if number of bytes is <= no. of bytes described by bitIndex and there
+                        // are extra bits to consider, this means id has less bits than what
+                        // bitIndex describes, id therefore is too short, and will be put in low
+                        // bucket
+                        const bytesDescribedByBitIndex = bitIndex >> 3
+                        const bitIndexWithinByte = bitIndex % 8
+                        if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
+                            return node.left
+                        }
+
+                        const byteUnderConsideration = id[bytesDescribedByBitIndex]
+
+                        // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
+                        // where 255 is 11111111 and 0 is 00000000
+                        // in order to find out whether the bit at bitIndexWithinByte is set
+                        // we construct (1 << (7 - bitIndexWithinByte)) which will consist
+                        // of all bits being 0, with only one bit set to 1
+                        // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
+                        // (1 << (7 - 3)) -> (1 << 4) -> 16
+                        if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
+                            return node.right
+                        }
+
+                        return node.left
+                    }
+
+                    /**
+                    * Get a contact by its exact ID.
+                    * If this is a leaf, loop through the bucket contents and return the correct
+                    * contact if we have it or null if not. If this is an inner node, determine
+                    * which branch of the tree to traverse and repeat.
+                    *
+                    * @param  {Uint8Array} id The ID of the contact to fetch.
+                    * @return {Object|Null}   The contact if available, otherwise null
+                    */
+                    get(id) {
+                        ensureInt8('id', id)
+
+                        let bitIndex = 0
+
+                        let node = this.root
+                        while (node.contacts === null) {
+                            node = this._determineNode(node, id, bitIndex++)
+                        }
+
+                        // index of uses contact id for matching
+                        const index = this._indexOf(node, id)
+                        return index >= 0 ? node.contacts[index] : null
+                    }
+
+                    /**
+                    * Returns the index of the contact with provided
+                    * id if it exists, returns -1 otherwise.
+                    *
+                    * @param  {Object} node    internal object that has 2 leafs: left and right
+                    * @param  {Uint8Array} id  Contact node id.
+                    * @return {Number}         Integer Index of contact with provided id if it
+                    *                          exists, -1 otherwise.
+                    */
+                    _indexOf(node, id) {
+                        for (let i = 0; i < node.contacts.length; ++i) {
+                            if (arrayEquals(node.contacts[i].id, id)) return i
+                        }
+
+                        return -1
+                    }
+
+                    /**
+                    * Removes contact with the provided id.
+                    *
+                    * @param  {Uint8Array} id The ID of the contact to remove.
+                    * @return {Object}        The k-bucket itself.
+                    */
+                    remove(id) {
+                        ensureInt8('the id as parameter 1', id)
+
+                        let bitIndex = 0
+                        let node = this.root
+
+                        while (node.contacts === null) {
+                            node = this._determineNode(node, id, bitIndex++)
+                        }
+
+                        const index = this._indexOf(node, id)
+                        if (index >= 0) {
+                            const contact = node.contacts.splice(index, 1)[0]
+                            this.emit('removed', contact)
+                        }
+
+                        return this
+                    }
+
+                    /**
+                    * Splits the node, redistributes contacts to the new nodes, and marks the
+                    * node that was split as an inner node of the binary tree of nodes by
+                    * setting this.root.contacts = null
+                    *
+                    * @param  {Object} node     node for splitting
+                    * @param  {Number} bitIndex the bitIndex to which byte to check in the
+                    *                           Uint8Array for navigating the binary tree
+                    */
+                    _split(node, bitIndex) {
+                        node.left = createNode()
+                        node.right = createNode()
+
+                        // redistribute existing contacts amongst the two newly created nodes
+                        for (const contact of node.contacts) {
+                            this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
+                        }
+
+                        node.contacts = null // mark as inner tree node
+
+                        // don't split the "far away" node
+                        // we check where the local node would end up and mark the other one as
+                        // "dontSplit" (i.e. "far away")
+                        const detNode = this._determineNode(node, this.localNodeId, bitIndex)
+                        const otherNode = node.left === detNode ? node.right : node.left
+                        otherNode.dontSplit = true
+                    }
+
+                    /**
+                    * Returns all the contacts contained in the tree as an array.
+                    * If this is a leaf, return a copy of the bucket. `slice` is used so that we
+                    * don't accidentally leak an internal reference out that might be
+                    * accidentally misused. If this is not a leaf, return the union of the low
+                    * and high branches (themselves also as arrays).
+                    *
+                    * @return {Array} All of the contacts in the tree, as an array
+                    */
+                    toArray() {
+                        let result = []
+                        for (const nodes = [this.root]; nodes.length > 0;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) nodes.push(node.right, node.left)
+                            else result = result.concat(node.contacts)
+                        }
+                        return result
+                    }
+
+                    /**
+                    * Updates the contact selected by the arbiter.
+                    * If the selection is our old contact and the candidate is some new contact
+                    * then the new contact is abandoned (not added).
+                    * If the selection is our old contact and the candidate is our old contact
+                    * then we are refreshing the contact and it is marked as most recently
+                    * contacted (by being moved to the right/end of the bucket array).
+                    * If the selection is our new contact, the old contact is removed and the new
+                    * contact is marked as most recently contacted.
+                    *
+                    * @param  {Object} node    internal object that has 2 leafs: left and right
+                    * @param  {Number} index   the index in the bucket where contact exists
+                    *                          (index has already been computed in a previous
+                    *                          calculation)
+                    * @param  {Object} contact The contact object to update.
+                    */
+                    _update(node, index, contact) {
+                        // sanity check
+                        if (!arrayEquals(node.contacts[index].id, contact.id)) {
+                            throw new Error('wrong index for _update')
+                        }
+
+                        const incumbent = node.contacts[index]
+                        const selection = this.arbiter(incumbent, contact)
+                        // if the selection is our old contact and the candidate is some new
+                        // contact, then there is nothing to do
+                        if (selection === incumbent && incumbent !== contact) return
+
+                        node.contacts.splice(index, 1) // remove old contact
+                        node.contacts.push(selection) // add more recent contact version
+                        this.emit('updated', incumbent, selection)
+                    }
+                }
+
+                module.exports = KBucket
+
+            }, {
+                "events": 90,
+                "randombytes": 6
+            }],
+            5: [function (require, module, exports) {
+                ;
+                (function () { // closure for web browsers
+
+                    if (typeof module === 'object' && module.exports) {
+                        module.exports = LRUCache
                     } else {
-                        var clonedSender = clone(sender);
-                        if (self.tracing)
-                            self.trace('adding ' + util.inspect(clonedSender)
-                                + ' to kBucket ' + senderClosestKBucketId);
-                        clonedSender.id = new Buffer(clonedSender.id, "base64");
-                        senderClosestKBucket.add(clonedSender);
+                        // just set the global for non-node platforms.
+                        this.LRUCache = LRUCache
+                    }
+
+                    function hOP(obj, key) {
+                        return Object.prototype.hasOwnProperty.call(obj, key)
+                    }
+
+                    function naiveLength() {
+                        return 1
+                    }
+
+                    function LRUCache(options) {
+                        if (!(this instanceof LRUCache))
+                            return new LRUCache(options)
+
+                        if (typeof options === 'number')
+                            options = {
+                                max: options
+                            }
+
+                        if (!options)
+                            options = {}
+
+                        this._max = options.max
+                        // Kind of weird to have a default max of Infinity, but oh well.
+                        if (!this._max || !(typeof this._max === "number") || this._max <= 0)
+                            this._max = Infinity
+
+                        this._lengthCalculator = options.length || naiveLength
+                        if (typeof this._lengthCalculator !== "function")
+                            this._lengthCalculator = naiveLength
+
+                        this._allowStale = options.stale || false
+                        this._maxAge = options.maxAge || null
+                        this._dispose = options.dispose
+                        this.reset()
+                    }
+
+                    // resize the cache when the max changes.
+                    Object.defineProperty(LRUCache.prototype, "max", {
+                        set: function (mL) {
+                            if (!mL || !(typeof mL === "number") || mL <= 0) mL = Infinity
+                            this._max = mL
+                            if (this._length > this._max) trim(this)
+                        },
+                        get: function () {
+                            return this._max
+                        },
+                        enumerable: true
+                    })
+
+                    // resize the cache when the lengthCalculator changes.
+                    Object.defineProperty(LRUCache.prototype, "lengthCalculator", {
+                        set: function (lC) {
+                            if (typeof lC !== "function") {
+                                this._lengthCalculator = naiveLength
+                                this._length = this._itemCount
+                                for (var key in this._cache) {
+                                    this._cache[key].length = 1
+                                }
+                            } else {
+                                this._lengthCalculator = lC
+                                this._length = 0
+                                for (var key in this._cache) {
+                                    this._cache[key].length = this._lengthCalculator(this._cache[
+                                        key].value)
+                                    this._length += this._cache[key].length
+                                }
+                            }
+
+                            if (this._length > this._max) trim(this)
+                        },
+                        get: function () {
+                            return this._lengthCalculator
+                        },
+                        enumerable: true
+                    })
+
+                    Object.defineProperty(LRUCache.prototype, "length", {
+                        get: function () {
+                            return this._length
+                        },
+                        enumerable: true
+                    })
+
+
+                    Object.defineProperty(LRUCache.prototype, "itemCount", {
+                        get: function () {
+                            return this._itemCount
+                        },
+                        enumerable: true
+                    })
+
+                    LRUCache.prototype.forEach = function (fn, thisp) {
+                        thisp = thisp || this
+                        var i = 0;
+                        for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--)
+                            if (this._lruList[k]) {
+                                i++
+                                var hit = this._lruList[k]
+                                if (this._maxAge && (Date.now() - hit.now > this._maxAge)) {
+                                    del(this, hit)
+                                    if (!this._allowStale) hit = undefined
+                                }
+                                if (hit) {
+                                    fn.call(thisp, hit.value, hit.key, this)
+                                }
+                            }
+                    }
+
+                    LRUCache.prototype.keys = function () {
+                        var keys = new Array(this._itemCount)
+                        var i = 0
+                        for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--)
+                            if (this._lruList[k]) {
+                                var hit = this._lruList[k]
+                                keys[i++] = hit.key
+                            }
+                        return keys
+                    }
+
+                    LRUCache.prototype.values = function () {
+                        var values = new Array(this._itemCount)
+                        var i = 0
+                        for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--)
+                            if (this._lruList[k]) {
+                                var hit = this._lruList[k]
+                                values[i++] = hit.value
+                            }
+                        return values
+                    }
+
+                    LRUCache.prototype.reset = function () {
+                        if (this._dispose && this._cache) {
+                            for (var k in this._cache) {
+                                this._dispose(k, this._cache[k].value)
+                            }
+                        }
+
+                        this._cache = Object.create(null) // hash of items by key
+                        this._lruList = Object.create(null) // list of items in order of use recency
+                        this._mru = 0 // most recently used
+                        this._lru = 0 // least recently used
+                        this._length = 0 // number of items in the list
+                        this._itemCount = 0
+                    }
+
+                    // Provided for debugging/dev purposes only. No promises whatsoever that
+                    // this API stays stable.
+                    LRUCache.prototype.dump = function () {
+                        return this._cache
+                    }
+
+                    LRUCache.prototype.dumpLru = function () {
+                        return this._lruList
+                    }
+
+                    LRUCache.prototype.set = function (key, value) {
+                        if (hOP(this._cache, key)) {
+                            // dispose of the old one before overwriting
+                            if (this._dispose) this._dispose(key, this._cache[key].value)
+                            if (this._maxAge) this._cache[key].now = Date.now()
+                            this._cache[key].value = value
+                            this.get(key)
+                            return true
+                        }
+
+                        var len = this._lengthCalculator(value)
+                        var age = this._maxAge ? Date.now() : 0
+                        var hit = new Entry(key, value, this._mru++, len, age)
+
+                        // oversized objects fall out of cache automatically.
+                        if (hit.length > this._max) {
+                            if (this._dispose) this._dispose(key, value)
+                            return false
+                        }
+
+                        this._length += hit.length
+                        this._lruList[hit.lu] = this._cache[key] = hit
+                        this._itemCount++
+
+                        if (this._length > this._max) trim(this)
+                        return true
+                    }
+
+                    LRUCache.prototype.has = function (key) {
+                        if (!hOP(this._cache, key)) return false
+                        var hit = this._cache[key]
+                        if (this._maxAge && (Date.now() - hit.now > this._maxAge)) {
+                            return false
+                        }
+                        return true
+                    }
+
+                    LRUCache.prototype.get = function (key) {
+                        return get(this, key, true)
+                    }
+
+                    LRUCache.prototype.peek = function (key) {
+                        return get(this, key, false)
+                    }
+
+                    LRUCache.prototype.pop = function () {
+                        var hit = this._lruList[this._lru]
+                        del(this, hit)
+                        return hit || null
+                    }
+
+                    LRUCache.prototype.del = function (key) {
+                        del(this, this._cache[key])
+                    }
+
+                    function get(self, key, doUse) {
+                        var hit = self._cache[key]
+                        if (hit) {
+                            if (self._maxAge && (Date.now() - hit.now > self._maxAge)) {
+                                del(self, hit)
+                                if (!self._allowStale) hit = undefined
+                            } else {
+                                if (doUse) use(self, hit)
+                            }
+                            if (hit) hit = hit.value
+                        }
+                        return hit
+                    }
+
+                    function use(self, hit) {
+                        shiftLU(self, hit)
+                        hit.lu = self._mru++
+                        self._lruList[hit.lu] = hit
+                    }
+
+                    function trim(self) {
+                        while (self._lru < self._mru && self._length > self._max)
+                            del(self, self._lruList[self._lru])
+                    }
+
+                    function shiftLU(self, hit) {
+                        delete self._lruList[hit.lu]
+                        while (self._lru < self._mru && !self._lruList[self._lru]) self._lru++
+                    }
+
+                    function del(self, hit) {
+                        if (hit) {
+                            if (self._dispose) self._dispose(hit.key, hit.value)
+                            self._length -= hit.length
+                            self._itemCount--
+                            delete self._cache[hit.key]
+                            shiftLU(self, hit)
+                        }
+                    }
+
+                    // classy, since V8 prefers predictable objects.
+                    function Entry(key, value, lu, length, now) {
+                        this.key = key
+                        this.value = value
+                        this.lu = lu
+                        this.length = length
+                        this.now = now
+                    }
+
+                })()
+
+            }, {}],
+            6: [function (require, module, exports) {
+                (function (process, global) {
+                    'use strict'
+
+                    function oldBrowser() {
+                        throw new Error(
+                            'Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11'
+                        )
+                    }
+
+                    var Buffer = require('safe-buffer').Buffer
+                    var crypto = global.crypto || global.msCrypto
+
+                    if (crypto && crypto.getRandomValues) {
+                        module.exports = randomBytes
+                    } else {
+                        module.exports = oldBrowser
+                    }
+
+                    function randomBytes(size, cb) {
+                        // phantomjs needs to throw
+                        if (size > 65536) throw new Error('requested too many random bytes')
+                        // in case browserify  isn't using the Uint8Array version
+                        var rawBytes = new global.Uint8Array(size)
+
+                        // This will not work in older browsers.
+                        // See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
+                        if (size > 0) { // getRandomValues fails on IE if size == 0
+                            crypto.getRandomValues(rawBytes)
+                        }
+
+                        // XXX: phantomjs doesn't like a buffer being passed here
+                        var bytes = Buffer.from(rawBytes.buffer)
+
+                        if (typeof cb === 'function') {
+                            return process.nextTick(function () {
+                                cb(null, bytes)
+                            })
+                        }
+
+                        return bytes
+                    }
+
+                }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !==
+                    "undefined" ? self : typeof window !== "undefined" ? window : {})
+            }, {
+                "_process": 125,
+                "safe-buffer": 7
+            }],
+            7: [function (require, module, exports) {
+                /* eslint-disable node/no-deprecated-api */
+                var buffer = require('buffer')
+                var Buffer = buffer.Buffer
+
+                // alternative to using Object.keys for old browsers
+                function copyProps(src, dst) {
+                    for (var key in src) {
+                        dst[key] = src[key]
                     }
                 }
-            }
-        }
-
-        // check if we already responded prior to processing the sender
-        if (localContactKBucket)
-            return;
-
-        if (closestContacts.length == 0) {
-            return callback(null, []);
-        }
-
-        // check for exact match
-        if (closestContacts[0].id.toString("base64") == nodeId) {
-            var contact = clone(closestContacts[0]);
-            contact.id = contact.id.toString("base64");
-            return callback(null, contact);
-        }
-
-        // return closest contacts
-        var contacts = [];
-        closestContacts.forEach(function (closeContact) {
-            var contact = clone(closeContact);
-            contact.id = contact.id.toString("base64");
-            // hide implementation details
-            delete contact.distance;
-            contacts.push(contact);
-        });
-
-        return callback(null, contacts);
-    });
-
-    // register a listener to handle transport 'ping' events
-    self.transport.on('ping', function (nodeId, sender, callback) {
-        if (self.tracing)
-            self.trace("on 'ping' - nodeId: " + nodeId + ", sender: " + util.inspect(sender));
-
-        // add the sender
-        // in contrast to self.transport.on('findNode', ...) we can add the
-        // sender prior to responding because it is verifying a ping for a
-        // specific node and not searching for one, the 'findNode' consideration
-        // to update K-Buckets only after responding does not apply in this case
-        var senderClosestKBuckets = self.getClosestKBuckets(sender.id);
-        if (senderClosestKBuckets.length == 0) {
-            if (self.tracing)
-                self.trace('no kBuckets for ping sender ' + util.inspect(sender));
-        } else {
-            var senderClosestKBucketId = senderClosestKBuckets[0].id;
-            var senderClosestKBucket = self.kBuckets[senderClosestKBucketId].kBucket;
-            if (!senderClosestKBucket) {
-                if (self.tracing)
-                    self.trace('no closest kBucket for ping sender ' + util.inspect(sender));
-            } else {
-                var clonedSender = clone(sender);
-                if (self.tracing)
-                    self.trace('adding ' + util.inspect(clonedSender) + ' to kBucket ' + senderClosestKBucketId);
-                clonedSender.id = new Buffer(clonedSender.id, "base64");
-                senderClosestKBucket.add(clonedSender);
-            }
-        }
-
-        // check if nodeId is one of the locally registered nodes
-        var localContactKBucket = self.kBuckets[nodeId];
-        if (localContactKBucket) {
-            callback(null, localContactKBucket.contact);
-        } else {
-            // the nodeId is not one of the locally registered nodes, ping fail
-            callback(true);
-        }
-    });
-
-    // register a listener to handle transport 'reached' events
-    self.transport.on('reached', function (contact) {
-        if (self.tracing)
-            self.trace('reached ' + util.inspect(contact));
-
-        // we successfully reached a contact, add it (refreshes the contact)
-        self.add(contact);
-    });
-
-    // register a listener to handle transport 'unreachable' events
-    self.transport.on('unreachable', function (contact) {
-        self.unreachable(contact);
-    });
-
-    self.kBuckets = {};
-    if (self.noCache) {
-        self.lruCache = {
-            del: function () {},
-            get: function () {},
-            set: function () {},
-        };
-    } else {
-        self.lruCache = LruCache(self.maxCacheSize);
-    }
-    self.timers = {
-        'find.ms': {},
-        'find.request.ms': {},
-        'find.round.ms': {}
-    };
-};
-
-util.inherits(Discover, events.EventEmitter);
-
-/*
-  * `remoteContact`: _Object_ Contact object to add that is not managed by this
-      Discover node.
-    * `id`: _String (base64)_ The contact id, base64 encoded.
-    * `data`: _Any_ Data to be included with the contact, it is guaranteed to be
-        returned for anyone querying for this `contact` by `id`.
-  * Return: _Object_ Contact that was added.
-*/
-Discover.prototype.add = function add (remoteContact) {
-    var self = this;
-
-    if (!remoteContact.id || typeof remoteContact.id !== 'string') {
-        throw new Error("Invalid or missing contact.id");
-    }
-
-    // even if we don't have kBuckets to update, we can still store information
-    // in LRU cache (check using arbiter to update cache with latest only)
-    var cached = self.lruCache.get(remoteContact.id);
-    var selection = self.arbiter(cached, remoteContact);
-    if (selection !== cached) {
-        self.lruCache.set(remoteContact.id, remoteContact);
-    }
-
-    if (Object.keys(self.kBuckets).length == 0) {
-        return null; // no k-buckets to update
-    }
-
-    // first, check if remote contact id is locally registered
-    if (self.kBuckets[remoteContact.id]) {
-        // remote contact id is same as locally registered contact id
-        // need to arbiter which contact version should be retained
-        // (we already calculated the selection)
-        self.kBuckets[remoteContact.id].contact = selection;
-    } else {
-        // we pick the closest kBucket to the node id of our contact to store the
-        // data in, since they have the most space to accomodate near-by node ids
-        // (inherent KBucket property)
-        var closestKBuckets = self.getClosestKBuckets(remoteContact.id);
-        var closestKBucketId = closestKBuckets[0].id;
-        var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
-        var clonedContact = clone(remoteContact);
-        if (self.tracing) {
-            self.trace('adding ' + util.inspect(clonedContact) + ' to kBucket '
-                + closestKBucketId);
-        }
-        // convert id from string to Buffer
-        clonedContact.id = new Buffer(clonedContact.id, "base64");
-        closestKBucket.add(clonedContact);
-    }
-
-    return remoteContact;
-};
-
-/*
-  * `query`: _Object_ Object containing query state for this request.
-    * `nodeId`: _String (base64)_ Base64 encoded node id to find.
-    * `nodes`: _Array_ `contact`s to query for `nodeId` arranged from closest to
-            farthest.
-      * `node`:
-        * `id`: _String (base64)_ Base64 encoded contact id.
-    * `nodesMap`: _Object_ A map to the same `contact`s already present in
-            `nodes` for O(1) access.
-  * `callback`: _Function_ The callback to call with result.
-*/
-Discover.prototype.executeQuery = function executeQuery (query, callback) {
-    var self = this;
-    self.timerStart('find.round.ms', query.nodeId);
-
-    if (self.tracing)
-        self.trace('executeQuery(' + util.inspect(query, false, null) + ')');
-
-    // query already successfully completed
-    if (query.done)
-        return;
-
-    // if we have no nodes, we can't query anything
-    if (!query.nodes || query.nodes.length == 0) {
-        var latency = self.timerEndInMilliseconds('find.ms', query.nodeId);
-        var roundLatency = self.timerEndInMilliseconds('find.round.ms', query.nodeId);
-        callback(new Error("No known nodes to query"));
-        self.emit('stats.timers.find.ms', latency);
-        self.emit('stats.timers.find.round.ms', roundLatency);
-        return;
-    }
-
-    if (query.index === undefined)
-        query.index = 0;
-    if (query.closest === undefined)
-        query.closest = query.nodes[0];
-    if (query.ongoingRequests === undefined)
-        query.ongoingRequests = 0;
-    if (query.newNodes === undefined)
-        query.newNodes = [];
-
-    // we listen for `node` events that contain the nodeId we asked for
-    // this helps to decouple discover from the transport and allows us to
-    // benefit from other ongoing queries (TODO: "prove" this)
-    //
-    // because executeQuery can be called multiple times on the same query,
-    // we keep the state
-    if (!query.listener) {
-        // TODO: maybe there is an opportunity here to generate events
-        // uniquely named by "nodeId" so I don't have to have tons of listeners
-        // listen to everything and throw away what they don't want?
-        query.listener = function (error, contact, nodeId, response) {
-            // filter other queries
-            if (nodeId != query.nodeId)
-                return;
-
-            // query already successfully completed
-            if (query.done)
-                return;
-
-            // request has been handled
-            // TODO: what happens if two requests for the same nodeId are
-            //       happening at the same time?
-            // maybe do a check prior to executeQuery to not duplicate searches
-            // for the same nodeId across the network?
-            query.ongoingRequests--;
-
-            if (error) {
-                if (self.tracing) {
-                    self.trace('error response from ' + util.inspect(contact) +
-                        ' looking for ' + nodeId + ': ' + util.inspect(error));
+                if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+                    module.exports = buffer
+                } else {
+                    // Copy properties from require('buffer')
+                    copyProps(buffer, exports)
+                    exports.Buffer = SafeBuffer
                 }
-                var contactRecord = query.nodesMap[contact.id];
 
-                if (!contactRecord)
-                    return;
+                function SafeBuffer(arg, encodingOrOffset, length) {
+                    return Buffer(arg, encodingOrOffset, length)
+                }
 
-                if (contactRecord.kBucket) {
-                    // we have a kBucket to report unreachability to
-                    // remove from kBucket
-                    var kBucketInfo = self.kBuckets[contactRecord.kBucket.id];
-                    if (!kBucketInfo) {
+                // Copy static methods from Buffer
+                copyProps(Buffer, SafeBuffer)
+
+                SafeBuffer.from = function (arg, encodingOrOffset, length) {
+                    if (typeof arg === 'number') {
+                        throw new TypeError('Argument must not be a number')
+                    }
+                    return Buffer(arg, encodingOrOffset, length)
+                }
+
+                SafeBuffer.alloc = function (size, fill, encoding) {
+                    if (typeof size !== 'number') {
+                        throw new TypeError('Argument must be a number')
+                    }
+                    var buf = Buffer(size)
+                    if (fill !== undefined) {
+                        if (typeof encoding === 'string') {
+                            buf.fill(fill, encoding)
+                        } else {
+                            buf.fill(fill)
+                        }
+                    } else {
+                        buf.fill(0)
+                    }
+                    return buf
+                }
+
+                SafeBuffer.allocUnsafe = function (size) {
+                    if (typeof size !== 'number') {
+                        throw new TypeError('Argument must be a number')
+                    }
+                    return Buffer(size)
+                }
+
+                SafeBuffer.allocUnsafeSlow = function (size) {
+                    if (typeof size !== 'number') {
+                        throw new TypeError('Argument must be a number')
+                    }
+                    return buffer.SlowBuffer(size)
+                }
+
+            }, {
+                "buffer": 55
+            }],
+            8: [function (require, module, exports) {
+
+            }, {}],
+            9: [function (require, module, exports) {
+                var asn1 = exports;
+
+                asn1.bignum = require('bn.js');
+
+                asn1.define = require('./asn1/api').define;
+                asn1.base = require('./asn1/base');
+                asn1.constants = require('./asn1/constants');
+                asn1.decoders = require('./asn1/decoders');
+                asn1.encoders = require('./asn1/encoders');
+
+            }, {
+                "./asn1/api": 10,
+                "./asn1/base": 12,
+                "./asn1/constants": 16,
+                "./asn1/decoders": 18,
+                "./asn1/encoders": 21,
+                "bn.js": 24
+            }],
+            10: [function (require, module, exports) {
+                var asn1 = require('../asn1');
+                var inherits = require('inherits');
+
+                var api = exports;
+
+                api.define = function define(name, body) {
+                    return new Entity(name, body);
+                };
+
+                function Entity(name, body) {
+                    this.name = name;
+                    this.body = body;
+
+                    this.decoders = {};
+                    this.encoders = {};
+                };
+
+                Entity.prototype._createNamed = function createNamed(base) {
+                    var named;
+                    try {
+                        named = require('vm').runInThisContext(
+                            '(function ' + this.name + '(entity) {\n' +
+                            '  this._initNamed(entity);\n' +
+                            '})'
+                        );
+                    } catch (e) {
+                        named = function (entity) {
+                            this._initNamed(entity);
+                        };
+                    }
+                    inherits(named, base);
+                    named.prototype._initNamed = function initnamed(entity) {
+                        base.call(this, entity);
+                    };
+
+                    return new named(this);
+                };
+
+                Entity.prototype._getDecoder = function _getDecoder(enc) {
+                    enc = enc || 'der';
+                    // Lazily create decoder
+                    if (!this.decoders.hasOwnProperty(enc))
+                        this.decoders[enc] = this._createNamed(asn1.decoders[enc]);
+                    return this.decoders[enc];
+                };
+
+                Entity.prototype.decode = function decode(data, enc, options) {
+                    return this._getDecoder(enc).decode(data, options);
+                };
+
+                Entity.prototype._getEncoder = function _getEncoder(enc) {
+                    enc = enc || 'der';
+                    // Lazily create encoder
+                    if (!this.encoders.hasOwnProperty(enc))
+                        this.encoders[enc] = this._createNamed(asn1.encoders[enc]);
+                    return this.encoders[enc];
+                };
+
+                Entity.prototype.encode = function encode(data, enc, /* internal */ reporter) {
+                    return this._getEncoder(enc).encode(data, reporter);
+                };
+
+            }, {
+                "../asn1": 9,
+                "inherits": 107,
+                "vm": 163
+            }],
+            11: [function (require, module, exports) {
+                var inherits = require('inherits');
+                var Reporter = require('../base').Reporter;
+                var Buffer = require('buffer').Buffer;
+
+                function DecoderBuffer(base, options) {
+                    Reporter.call(this, options);
+                    if (!Buffer.isBuffer(base)) {
+                        this.error('Input not Buffer');
                         return;
                     }
 
-                    var kBucket = kBucketInfo.kBucket;
-                    if (!kBucket) {
+                    this.base = base;
+                    this.offset = 0;
+                    this.length = base.length;
+                }
+                inherits(DecoderBuffer, Reporter);
+                exports.DecoderBuffer = DecoderBuffer;
+
+                DecoderBuffer.prototype.save = function save() {
+                    return {
+                        offset: this.offset,
+                        reporter: Reporter.prototype.save.call(this)
+                    };
+                };
+
+                DecoderBuffer.prototype.restore = function restore(save) {
+                    // Return skipped data
+                    var res = new DecoderBuffer(this.base);
+                    res.offset = save.offset;
+                    res.length = this.offset;
+
+                    this.offset = save.offset;
+                    Reporter.prototype.restore.call(this, save.reporter);
+
+                    return res;
+                };
+
+                DecoderBuffer.prototype.isEmpty = function isEmpty() {
+                    return this.offset === this.length;
+                };
+
+                DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {
+                    if (this.offset + 1 <= this.length)
+                        return this.base.readUInt8(this.offset++, true);
+                    else
+                        return this.error(fail || 'DecoderBuffer overrun');
+                }
+
+                DecoderBuffer.prototype.skip = function skip(bytes, fail) {
+                    if (!(this.offset + bytes <= this.length))
+                        return this.error(fail || 'DecoderBuffer overrun');
+
+                    var res = new DecoderBuffer(this.base);
+
+                    // Share reporter state
+                    res._reporterState = this._reporterState;
+
+                    res.offset = this.offset;
+                    res.length = this.offset + bytes;
+                    this.offset += bytes;
+                    return res;
+                }
+
+                DecoderBuffer.prototype.raw = function raw(save) {
+                    return this.base.slice(save ? save.offset : this.offset, this.length);
+                }
+
+                function EncoderBuffer(value, reporter) {
+                    if (Array.isArray(value)) {
+                        this.length = 0;
+                        this.value = value.map(function (item) {
+                            if (!(item instanceof EncoderBuffer))
+                                item = new EncoderBuffer(item, reporter);
+                            this.length += item.length;
+                            return item;
+                        }, this);
+                    } else if (typeof value === 'number') {
+                        if (!(0 <= value && value <= 0xff))
+                            return reporter.error('non-byte EncoderBuffer value');
+                        this.value = value;
+                        this.length = 1;
+                    } else if (typeof value === 'string') {
+                        this.value = value;
+                        this.length = Buffer.byteLength(value);
+                    } else if (Buffer.isBuffer(value)) {
+                        this.value = value;
+                        this.length = value.length;
+                    } else {
+                        return reporter.error('Unsupported type: ' + typeof value);
+                    }
+                }
+                exports.EncoderBuffer = EncoderBuffer;
+
+                EncoderBuffer.prototype.join = function join(out, offset) {
+                    if (!out)
+                        out = new Buffer(this.length);
+                    if (!offset)
+                        offset = 0;
+
+                    if (this.length === 0)
+                        return out;
+
+                    if (Array.isArray(this.value)) {
+                        this.value.forEach(function (item) {
+                            item.join(out, offset);
+                            offset += item.length;
+                        });
+                    } else {
+                        if (typeof this.value === 'number')
+                            out[offset] = this.value;
+                        else if (typeof this.value === 'string')
+                            out.write(this.value, offset);
+                        else if (Buffer.isBuffer(this.value))
+                            this.value.copy(out, offset);
+                        offset += this.length;
+                    }
+
+                    return out;
+                };
+
+            }, {
+                "../base": 12,
+                "buffer": 55,
+                "inherits": 107
+            }],
+            12: [function (require, module, exports) {
+                var base = exports;
+
+                base.Reporter = require('./reporter').Reporter;
+                base.DecoderBuffer = require('./buffer').DecoderBuffer;
+                base.EncoderBuffer = require('./buffer').EncoderBuffer;
+                base.Node = require('./node');
+
+            }, {
+                "./buffer": 11,
+                "./node": 13,
+                "./reporter": 14
+            }],
+            13: [function (require, module, exports) {
+                var Reporter = require('../base').Reporter;
+                var EncoderBuffer = require('../base').EncoderBuffer;
+                var DecoderBuffer = require('../base').DecoderBuffer;
+                var assert = require('minimalistic-assert');
+
+                // Supported tags
+                var tags = [
+                    'seq', 'seqof', 'set', 'setof', 'objid', 'bool',
+                    'gentime', 'utctime', 'null_', 'enum', 'int', 'objDesc',
+                    'bitstr', 'bmpstr', 'charstr', 'genstr', 'graphstr', 'ia5str', 'iso646str',
+                    'numstr', 'octstr', 'printstr', 't61str', 'unistr', 'utf8str', 'videostr'
+                ];
+
+                // Public methods list
+                var methods = [
+                    'key', 'obj', 'use', 'optional', 'explicit', 'implicit', 'def', 'choice',
+                    'any', 'contains'
+                ].concat(tags);
+
+                // Overrided methods list
+                var overrided = [
+                    '_peekTag', '_decodeTag', '_use',
+                    '_decodeStr', '_decodeObjid', '_decodeTime',
+                    '_decodeNull', '_decodeInt', '_decodeBool', '_decodeList',
+
+                    '_encodeComposite', '_encodeStr', '_encodeObjid', '_encodeTime',
+                    '_encodeNull', '_encodeInt', '_encodeBool'
+                ];
+
+                function Node(enc, parent) {
+                    var state = {};
+                    this._baseState = state;
+
+                    state.enc = enc;
+
+                    state.parent = parent || null;
+                    state.children = null;
+
+                    // State
+                    state.tag = null;
+                    state.args = null;
+                    state.reverseArgs = null;
+                    state.choice = null;
+                    state.optional = false;
+                    state.any = false;
+                    state.obj = false;
+                    state.use = null;
+                    state.useDecoder = null;
+                    state.key = null;
+                    state['default'] = null;
+                    state.explicit = null;
+                    state.implicit = null;
+                    state.contains = null;
+
+                    // Should create new instance on each method
+                    if (!state.parent) {
+                        state.children = [];
+                        this._wrap();
+                    }
+                }
+                module.exports = Node;
+
+                var stateProps = [
+                    'enc', 'parent', 'children', 'tag', 'args', 'reverseArgs', 'choice',
+                    'optional', 'any', 'obj', 'use', 'alteredUse', 'key', 'default', 'explicit',
+                    'implicit', 'contains'
+                ];
+
+                Node.prototype.clone = function clone() {
+                    var state = this._baseState;
+                    var cstate = {};
+                    stateProps.forEach(function (prop) {
+                        cstate[prop] = state[prop];
+                    });
+                    var res = new this.constructor(cstate.parent);
+                    res._baseState = cstate;
+                    return res;
+                };
+
+                Node.prototype._wrap = function wrap() {
+                    var state = this._baseState;
+                    methods.forEach(function (method) {
+                        this[method] = function _wrappedMethod() {
+                            var clone = new this.constructor(this);
+                            state.children.push(clone);
+                            return clone[method].apply(clone, arguments);
+                        };
+                    }, this);
+                };
+
+                Node.prototype._init = function init(body) {
+                    var state = this._baseState;
+
+                    assert(state.parent === null);
+                    body.call(this);
+
+                    // Filter children
+                    state.children = state.children.filter(function (child) {
+                        return child._baseState.parent === this;
+                    }, this);
+                    assert.equal(state.children.length, 1, 'Root node can have only one child');
+                };
+
+                Node.prototype._useArgs = function useArgs(args) {
+                    var state = this._baseState;
+
+                    // Filter children and args
+                    var children = args.filter(function (arg) {
+                        return arg instanceof this.constructor;
+                    }, this);
+                    args = args.filter(function (arg) {
+                        return !(arg instanceof this.constructor);
+                    }, this);
+
+                    if (children.length !== 0) {
+                        assert(state.children === null);
+                        state.children = children;
+
+                        // Replace parent to maintain backward link
+                        children.forEach(function (child) {
+                            child._baseState.parent = this;
+                        }, this);
+                    }
+                    if (args.length !== 0) {
+                        assert(state.args === null);
+                        state.args = args;
+                        state.reverseArgs = args.map(function (arg) {
+                            if (typeof arg !== 'object' || arg.constructor !== Object)
+                                return arg;
+
+                            var res = {};
+                            Object.keys(arg).forEach(function (key) {
+                                if (key == (key | 0))
+                                    key |= 0;
+                                var value = arg[key];
+                                res[value] = key;
+                            });
+                            return res;
+                        });
+                    }
+                };
+
+                //
+                // Overrided methods
+                //
+
+                overrided.forEach(function (method) {
+                    Node.prototype[method] = function _overrided() {
+                        var state = this._baseState;
+                        throw new Error(method + ' not implemented for encoding: ' + state.enc);
+                    };
+                });
+
+                //
+                // Public methods
+                //
+
+                tags.forEach(function (tag) {
+                    Node.prototype[tag] = function _tagMethod() {
+                        var state = this._baseState;
+                        var args = Array.prototype.slice.call(arguments);
+
+                        assert(state.tag === null);
+                        state.tag = tag;
+
+                        this._useArgs(args);
+
+                        return this;
+                    };
+                });
+
+                Node.prototype.use = function use(item) {
+                    assert(item);
+                    var state = this._baseState;
+
+                    assert(state.use === null);
+                    state.use = item;
+
+                    return this;
+                };
+
+                Node.prototype.optional = function optional() {
+                    var state = this._baseState;
+
+                    state.optional = true;
+
+                    return this;
+                };
+
+                Node.prototype.def = function def(val) {
+                    var state = this._baseState;
+
+                    assert(state['default'] === null);
+                    state['default'] = val;
+                    state.optional = true;
+
+                    return this;
+                };
+
+                Node.prototype.explicit = function explicit(num) {
+                    var state = this._baseState;
+
+                    assert(state.explicit === null && state.implicit === null);
+                    state.explicit = num;
+
+                    return this;
+                };
+
+                Node.prototype.implicit = function implicit(num) {
+                    var state = this._baseState;
+
+                    assert(state.explicit === null && state.implicit === null);
+                    state.implicit = num;
+
+                    return this;
+                };
+
+                Node.prototype.obj = function obj() {
+                    var state = this._baseState;
+                    var args = Array.prototype.slice.call(arguments);
+
+                    state.obj = true;
+
+                    if (args.length !== 0)
+                        this._useArgs(args);
+
+                    return this;
+                };
+
+                Node.prototype.key = function key(newKey) {
+                    var state = this._baseState;
+
+                    assert(state.key === null);
+                    state.key = newKey;
+
+                    return this;
+                };
+
+                Node.prototype.any = function any() {
+                    var state = this._baseState;
+
+                    state.any = true;
+
+                    return this;
+                };
+
+                Node.prototype.choice = function choice(obj) {
+                    var state = this._baseState;
+
+                    assert(state.choice === null);
+                    state.choice = obj;
+                    this._useArgs(Object.keys(obj).map(function (key) {
+                        return obj[key];
+                    }));
+
+                    return this;
+                };
+
+                Node.prototype.contains = function contains(item) {
+                    var state = this._baseState;
+
+                    assert(state.use === null);
+                    state.contains = item;
+
+                    return this;
+                };
+
+                //
+                // Decoding
+                //
+
+                Node.prototype._decode = function decode(input, options) {
+                    var state = this._baseState;
+
+                    // Decode root node
+                    if (state.parent === null)
+                        return input.wrapResult(state.children[0]._decode(input, options));
+
+                    var result = state['default'];
+                    var present = true;
+
+                    var prevKey = null;
+                    if (state.key !== null)
+                        prevKey = input.enterKey(state.key);
+
+                    // Check if tag is there
+                    if (state.optional) {
+                        var tag = null;
+                        if (state.explicit !== null)
+                            tag = state.explicit;
+                        else if (state.implicit !== null)
+                            tag = state.implicit;
+                        else if (state.tag !== null)
+                            tag = state.tag;
+
+                        if (tag === null && !state.any) {
+                            // Trial and Error
+                            var save = input.save();
+                            try {
+                                if (state.choice === null)
+                                    this._decodeGeneric(state.tag, input, options);
+                                else
+                                    this._decodeChoice(input, options);
+                                present = true;
+                            } catch (e) {
+                                present = false;
+                            }
+                            input.restore(save);
+                        } else {
+                            present = this._peekTag(input, tag, state.any);
+
+                            if (input.isError(present))
+                                return present;
+                        }
+                    }
+
+                    // Push object on stack
+                    var prevObj;
+                    if (state.obj && present)
+                        prevObj = input.enterObject();
+
+                    if (present) {
+                        // Unwrap explicit values
+                        if (state.explicit !== null) {
+                            var explicit = this._decodeTag(input, state.explicit);
+                            if (input.isError(explicit))
+                                return explicit;
+                            input = explicit;
+                        }
+
+                        var start = input.offset;
+
+                        // Unwrap implicit and normal values
+                        if (state.use === null && state.choice === null) {
+                            if (state.any)
+                                var save = input.save();
+                            var body = this._decodeTag(
+                                input,
+                                state.implicit !== null ? state.implicit : state.tag,
+                                state.any
+                            );
+                            if (input.isError(body))
+                                return body;
+
+                            if (state.any)
+                                result = input.raw(save);
+                            else
+                                input = body;
+                        }
+
+                        if (options && options.track && state.tag !== null)
+                            options.track(input.path(), start, input.length, 'tagged');
+
+                        if (options && options.track && state.tag !== null)
+                            options.track(input.path(), input.offset, input.length, 'content');
+
+                        // Select proper method for tag
+                        if (state.any)
+                            result = result;
+                        else if (state.choice === null)
+                            result = this._decodeGeneric(state.tag, input, options);
+                        else
+                            result = this._decodeChoice(input, options);
+
+                        if (input.isError(result))
+                            return result;
+
+                        // Decode children
+                        if (!state.any && state.choice === null && state.children !== null) {
+                            state.children.forEach(function decodeChildren(child) {
+                                // NOTE: We are ignoring errors here, to let parser continue with other
+                                // parts of encoded data
+                                child._decode(input, options);
+                            });
+                        }
+
+                        // Decode contained/encoded by schema, only in bit or octet strings
+                        if (state.contains && (state.tag === 'octstr' || state.tag === 'bitstr')) {
+                            var data = new DecoderBuffer(result);
+                            result = this._getUse(state.contains, input._reporterState.obj)
+                                ._decode(data, options);
+                        }
+                    }
+
+                    // Pop object
+                    if (state.obj && present)
+                        result = input.leaveObject(prevObj);
+
+                    // Set key
+                    if (state.key !== null && (result !== null || present === true))
+                        input.leaveKey(prevKey, state.key, result);
+                    else if (prevKey !== null)
+                        input.exitKey(prevKey);
+
+                    return result;
+                };
+
+                Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
+                    var state = this._baseState;
+
+                    if (tag === 'seq' || tag === 'set')
+                        return null;
+                    if (tag === 'seqof' || tag === 'setof')
+                        return this._decodeList(input, tag, state.args[0], options);
+                    else if (/str$/.test(tag))
+                        return this._decodeStr(input, tag, options);
+                    else if (tag === 'objid' && state.args)
+                        return this._decodeObjid(input, state.args[0], state.args[1], options);
+                    else if (tag === 'objid')
+                        return this._decodeObjid(input, null, null, options);
+                    else if (tag === 'gentime' || tag === 'utctime')
+                        return this._decodeTime(input, tag, options);
+                    else if (tag === 'null_')
+                        return this._decodeNull(input, options);
+                    else if (tag === 'bool')
+                        return this._decodeBool(input, options);
+                    else if (tag === 'objDesc')
+                        return this._decodeStr(input, tag, options);
+                    else if (tag === 'int' || tag === 'enum')
+                        return this._decodeInt(input, state.args && state.args[0], options);
+
+                    if (state.use !== null) {
+                        return this._getUse(state.use, input._reporterState.obj)
+                            ._decode(input, options);
+                    } else {
+                        return input.error('unknown tag: ' + tag);
+                    }
+                };
+
+                Node.prototype._getUse = function _getUse(entity, obj) {
+
+                    var state = this._baseState;
+                    // Create altered use decoder if implicit is set
+                    state.useDecoder = this._use(entity, obj);
+                    assert(state.useDecoder._baseState.parent === null);
+                    state.useDecoder = state.useDecoder._baseState.children[0];
+                    if (state.implicit !== state.useDecoder._baseState.implicit) {
+                        state.useDecoder = state.useDecoder.clone();
+                        state.useDecoder._baseState.implicit = state.implicit;
+                    }
+                    return state.useDecoder;
+                };
+
+                Node.prototype._decodeChoice = function decodeChoice(input, options) {
+                    var state = this._baseState;
+                    var result = null;
+                    var match = false;
+
+                    Object.keys(state.choice).some(function (key) {
+                        var save = input.save();
+                        var node = state.choice[key];
+                        try {
+                            var value = node._decode(input, options);
+                            if (input.isError(value))
+                                return false;
+
+                            result = {
+                                type: key,
+                                value: value
+                            };
+                            match = true;
+                        } catch (e) {
+                            input.restore(save);
+                            return false;
+                        }
+                        return true;
+                    }, this);
+
+                    if (!match)
+                        return input.error('Choice not matched');
+
+                    return result;
+                };
+
+                //
+                // Encoding
+                //
+
+                Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
+                    return new EncoderBuffer(data, this.reporter);
+                };
+
+                Node.prototype._encode = function encode(data, reporter, parent) {
+                    var state = this._baseState;
+                    if (state['default'] !== null && state['default'] === data)
+                        return;
+
+                    var result = this._encodeValue(data, reporter, parent);
+                    if (result === undefined)
+                        return;
+
+                    if (this._skipDefault(result, reporter, parent))
+                        return;
+
+                    return result;
+                };
+
+                Node.prototype._encodeValue = function encode(data, reporter, parent) {
+                    var state = this._baseState;
+
+                    // Decode root node
+                    if (state.parent === null)
+                        return state.children[0]._encode(data, reporter || new Reporter());
+
+                    var result = null;
+
+                    // Set reporter to share it with a child class
+                    this.reporter = reporter;
+
+                    // Check if data is there
+                    if (state.optional && data === undefined) {
+                        if (state['default'] !== null)
+                            data = state['default']
+                        else
+                            return;
+                    }
+
+                    // Encode children first
+                    var content = null;
+                    var primitive = false;
+                    if (state.any) {
+                        // Anything that was given is translated to buffer
+                        result = this._createEncoderBuffer(data);
+                    } else if (state.choice) {
+                        result = this._encodeChoice(data, reporter);
+                    } else if (state.contains) {
+                        content = this._getUse(state.contains, parent)._encode(data, reporter);
+                        primitive = true;
+                    } else if (state.children) {
+                        content = state.children.map(function (child) {
+                            if (child._baseState.tag === 'null_')
+                                return child._encode(null, reporter, data);
+
+                            if (child._baseState.key === null)
+                                return reporter.error('Child should have a key');
+                            var prevKey = reporter.enterKey(child._baseState.key);
+
+                            if (typeof data !== 'object')
+                                return reporter.error('Child expected, but input is not object');
+
+                            var res = child._encode(data[child._baseState.key], reporter, data);
+                            reporter.leaveKey(prevKey);
+
+                            return res;
+                        }, this).filter(function (child) {
+                            return child;
+                        });
+                        content = this._createEncoderBuffer(content);
+                    } else {
+                        if (state.tag === 'seqof' || state.tag === 'setof') {
+                            // TODO(indutny): this should be thrown on DSL level
+                            if (!(state.args && state.args.length === 1))
+                                return reporter.error('Too many args for : ' + state.tag);
+
+                            if (!Array.isArray(data))
+                                return reporter.error('seqof/setof, but data is not Array');
+
+                            var child = this.clone();
+                            child._baseState.implicit = null;
+                            content = this._createEncoderBuffer(data.map(function (item) {
+                                var state = this._baseState;
+
+                                return this._getUse(state.args[0], data)._encode(item,
+                                    reporter);
+                            }, child));
+                        } else if (state.use !== null) {
+                            result = this._getUse(state.use, parent)._encode(data, reporter);
+                        } else {
+                            content = this._encodePrimitive(state.tag, data);
+                            primitive = true;
+                        }
+                    }
+
+                    // Encode data itself
+                    var result;
+                    if (!state.any && state.choice === null) {
+                        var tag = state.implicit !== null ? state.implicit : state.tag;
+                        var cls = state.implicit === null ? 'universal' : 'context';
+
+                        if (tag === null) {
+                            if (state.use === null)
+                                reporter.error('Tag could be omitted only for .use()');
+                        } else {
+                            if (state.use === null)
+                                result = this._encodeComposite(tag, primitive, cls, content);
+                        }
+                    }
+
+                    // Wrap in explicit
+                    if (state.explicit !== null)
+                        result = this._encodeComposite(state.explicit, false, 'context', result);
+
+                    return result;
+                };
+
+                Node.prototype._encodeChoice = function encodeChoice(data, reporter) {
+                    var state = this._baseState;
+
+                    var node = state.choice[data.type];
+                    if (!node) {
+                        assert(
+                            false,
+                            data.type + ' not found in ' +
+                            JSON.stringify(Object.keys(state.choice)));
+                    }
+                    return node._encode(data.value, reporter);
+                };
+
+                Node.prototype._encodePrimitive = function encodePrimitive(tag, data) {
+                    var state = this._baseState;
+
+                    if (/str$/.test(tag))
+                        return this._encodeStr(data, tag);
+                    else if (tag === 'objid' && state.args)
+                        return this._encodeObjid(data, state.reverseArgs[0], state.args[1]);
+                    else if (tag === 'objid')
+                        return this._encodeObjid(data, null, null);
+                    else if (tag === 'gentime' || tag === 'utctime')
+                        return this._encodeTime(data, tag);
+                    else if (tag === 'null_')
+                        return this._encodeNull();
+                    else if (tag === 'int' || tag === 'enum')
+                        return this._encodeInt(data, state.args && state.reverseArgs[0]);
+                    else if (tag === 'bool')
+                        return this._encodeBool(data);
+                    else if (tag === 'objDesc')
+                        return this._encodeStr(data, tag);
+                    else
+                        throw new Error('Unsupported tag: ' + tag);
+                };
+
+                Node.prototype._isNumstr = function isNumstr(str) {
+                    return /^[0-9 ]*$/.test(str);
+                };
+
+                Node.prototype._isPrintstr = function isPrintstr(str) {
+                    return /^[A-Za-z0-9 '\(\)\+,\-\.\/:=\?]*$/.test(str);
+                };
+
+            }, {
+                "../base": 12,
+                "minimalistic-assert": 112
+            }],
+            14: [function (require, module, exports) {
+                var inherits = require('inherits');
+
+                function Reporter(options) {
+                    this._reporterState = {
+                        obj: null,
+                        path: [],
+                        options: options || {},
+                        errors: []
+                    };
+                }
+                exports.Reporter = Reporter;
+
+                Reporter.prototype.isError = function isError(obj) {
+                    return obj instanceof ReporterError;
+                };
+
+                Reporter.prototype.save = function save() {
+                    var state = this._reporterState;
+
+                    return {
+                        obj: state.obj,
+                        pathLen: state.path.length
+                    };
+                };
+
+                Reporter.prototype.restore = function restore(data) {
+                    var state = this._reporterState;
+
+                    state.obj = data.obj;
+                    state.path = state.path.slice(0, data.pathLen);
+                };
+
+                Reporter.prototype.enterKey = function enterKey(key) {
+                    return this._reporterState.path.push(key);
+                };
+
+                Reporter.prototype.exitKey = function exitKey(index) {
+                    var state = this._reporterState;
+
+                    state.path = state.path.slice(0, index - 1);
+                };
+
+                Reporter.prototype.leaveKey = function leaveKey(index, key, value) {
+                    var state = this._reporterState;
+
+                    this.exitKey(index);
+                    if (state.obj !== null)
+                        state.obj[key] = value;
+                };
+
+                Reporter.prototype.path = function path() {
+                    return this._reporterState.path.join('/');
+                };
+
+                Reporter.prototype.enterObject = function enterObject() {
+                    var state = this._reporterState;
+
+                    var prev = state.obj;
+                    state.obj = {};
+                    return prev;
+                };
+
+                Reporter.prototype.leaveObject = function leaveObject(prev) {
+                    var state = this._reporterState;
+
+                    var now = state.obj;
+                    state.obj = prev;
+                    return now;
+                };
+
+                Reporter.prototype.error = function error(msg) {
+                    var err;
+                    var state = this._reporterState;
+
+                    var inherited = msg instanceof ReporterError;
+                    if (inherited) {
+                        err = msg;
+                    } else {
+                        err = new ReporterError(state.path.map(function (elem) {
+                            return '[' + JSON.stringify(elem) + ']';
+                        }).join(''), msg.message || msg, msg.stack);
+                    }
+
+                    if (!state.options.partial)
+                        throw err;
+
+                    if (!inherited)
+                        state.errors.push(err);
+
+                    return err;
+                };
+
+                Reporter.prototype.wrapResult = function wrapResult(result) {
+                    var state = this._reporterState;
+                    if (!state.options.partial)
+                        return result;
+
+                    return {
+                        result: this.isError(result) ? null : result,
+                        errors: state.errors
+                    };
+                };
+
+                function ReporterError(path, msg) {
+                    this.path = path;
+                    this.rethrow(msg);
+                };
+                inherits(ReporterError, Error);
+
+                ReporterError.prototype.rethrow = function rethrow(msg) {
+                    this.message = msg + ' at: ' + (this.path || '(shallow)');
+                    if (Error.captureStackTrace)
+                        Error.captureStackTrace(this, ReporterError);
+
+                    if (!this.stack) {
+                        try {
+                            // IE only adds stack when thrown
+                            throw new Error(this.message);
+                        } catch (e) {
+                            this.stack = e.stack;
+                        }
+                    }
+                    return this;
+                };
+
+            }, {
+                "inherits": 107
+            }],
+            15: [function (require, module, exports) {
+                var constants = require('../constants');
+
+                exports.tagClass = {
+                    0: 'universal',
+                    1: 'application',
+                    2: 'context',
+                    3: 'private'
+                };
+                exports.tagClassByName = constants._reverse(exports.tagClass);
+
+                exports.tag = {
+                    0x00: 'end',
+                    0x01: 'bool',
+                    0x02: 'int',
+                    0x03: 'bitstr',
+                    0x04: 'octstr',
+                    0x05: 'null_',
+                    0x06: 'objid',
+                    0x07: 'objDesc',
+                    0x08: 'external',
+                    0x09: 'real',
+                    0x0a: 'enum',
+                    0x0b: 'embed',
+                    0x0c: 'utf8str',
+                    0x0d: 'relativeOid',
+                    0x10: 'seq',
+                    0x11: 'set',
+                    0x12: 'numstr',
+                    0x13: 'printstr',
+                    0x14: 't61str',
+                    0x15: 'videostr',
+                    0x16: 'ia5str',
+                    0x17: 'utctime',
+                    0x18: 'gentime',
+                    0x19: 'graphstr',
+                    0x1a: 'iso646str',
+                    0x1b: 'genstr',
+                    0x1c: 'unistr',
+                    0x1d: 'charstr',
+                    0x1e: 'bmpstr'
+                };
+                exports.tagByName = constants._reverse(exports.tag);
+
+            }, {
+                "../constants": 16
+            }],
+            16: [function (require, module, exports) {
+                var constants = exports;
+
+                // Helper
+                constants._reverse = function reverse(map) {
+                    var res = {};
+
+                    Object.keys(map).forEach(function (key) {
+                        // Convert key to integer if it is stringified
+                        if ((key | 0) == key)
+                            key = key | 0;
+
+                        var value = map[key];
+                        res[value] = key;
+                    });
+
+                    return res;
+                };
+
+                constants.der = require('./der');
+
+            }, {
+                "./der": 15
+            }],
+            17: [function (require, module, exports) {
+                var inherits = require('inherits');
+
+                var asn1 = require('../../asn1');
+                var base = asn1.base;
+                var bignum = asn1.bignum;
+
+                // Import DER constants
+                var der = asn1.constants.der;
+
+                function DERDecoder(entity) {
+                    this.enc = 'der';
+                    this.name = entity.name;
+                    this.entity = entity;
+
+                    // Construct base tree
+                    this.tree = new DERNode();
+                    this.tree._init(entity.body);
+                };
+                module.exports = DERDecoder;
+
+                DERDecoder.prototype.decode = function decode(data, options) {
+                    if (!(data instanceof base.DecoderBuffer))
+                        data = new base.DecoderBuffer(data, options);
+
+                    return this.tree._decode(data, options);
+                };
+
+                // Tree methods
+
+                function DERNode(parent) {
+                    base.Node.call(this, 'der', parent);
+                }
+                inherits(DERNode, base.Node);
+
+                DERNode.prototype._peekTag = function peekTag(buffer, tag, any) {
+                    if (buffer.isEmpty())
+                        return false;
+
+                    var state = buffer.save();
+                    var decodedTag = derDecodeTag(buffer, 'Failed to peek tag: "' + tag + '"');
+                    if (buffer.isError(decodedTag))
+                        return decodedTag;
+
+                    buffer.restore(state);
+
+                    return decodedTag.tag === tag || decodedTag.tagStr === tag ||
+                        (decodedTag.tagStr + 'of') === tag || any;
+                };
+
+                DERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {
+                    var decodedTag = derDecodeTag(buffer,
+                        'Failed to decode tag of "' + tag + '"');
+                    if (buffer.isError(decodedTag))
+                        return decodedTag;
+
+                    var len = derDecodeLen(buffer,
+                        decodedTag.primitive,
+                        'Failed to get length of "' + tag + '"');
+
+                    // Failure
+                    if (buffer.isError(len))
+                        return len;
+
+                    if (!any &&
+                        decodedTag.tag !== tag &&
+                        decodedTag.tagStr !== tag &&
+                        decodedTag.tagStr + 'of' !== tag) {
+                        return buffer.error('Failed to match tag: "' + tag + '"');
+                    }
+
+                    if (decodedTag.primitive || len !== null)
+                        return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
+
+                    // Indefinite length... find END tag
+                    var state = buffer.save();
+                    var res = this._skipUntilEnd(
+                        buffer,
+                        'Failed to skip indefinite length body: "' + this.tag + '"');
+                    if (buffer.isError(res))
+                        return res;
+
+                    len = buffer.offset - state.offset;
+                    buffer.restore(state);
+                    return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
+                };
+
+                DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {
+                    while (true) {
+                        var tag = derDecodeTag(buffer, fail);
+                        if (buffer.isError(tag))
+                            return tag;
+                        var len = derDecodeLen(buffer, tag.primitive, fail);
+                        if (buffer.isError(len))
+                            return len;
+
+                        var res;
+                        if (tag.primitive || len !== null)
+                            res = buffer.skip(len)
+                        else
+                            res = this._skipUntilEnd(buffer, fail);
+
+                        // Failure
+                        if (buffer.isError(res))
+                            return res;
+
+                        if (tag.tagStr === 'end')
+                            break;
+                    }
+                };
+
+                DERNode.prototype._decodeList = function decodeList(buffer, tag, decoder,
+                    options) {
+                    var result = [];
+                    while (!buffer.isEmpty()) {
+                        var possibleEnd = this._peekTag(buffer, 'end');
+                        if (buffer.isError(possibleEnd))
+                            return possibleEnd;
+
+                        var res = decoder.decode(buffer, 'der', options);
+                        if (buffer.isError(res) && possibleEnd)
+                            break;
+                        result.push(res);
+                    }
+                    return result;
+                };
+
+                DERNode.prototype._decodeStr = function decodeStr(buffer, tag) {
+                    if (tag === 'bitstr') {
+                        var unused = buffer.readUInt8();
+                        if (buffer.isError(unused))
+                            return unused;
+                        return {
+                            unused: unused,
+                            data: buffer.raw()
+                        };
+                    } else if (tag === 'bmpstr') {
+                        var raw = buffer.raw();
+                        if (raw.length % 2 === 1)
+                            return buffer.error('Decoding of string type: bmpstr length mismatch');
+
+                        var str = '';
+                        for (var i = 0; i < raw.length / 2; i++) {
+                            str += String.fromCharCode(raw.readUInt16BE(i * 2));
+                        }
+                        return str;
+                    } else if (tag === 'numstr') {
+                        var numstr = buffer.raw().toString('ascii');
+                        if (!this._isNumstr(numstr)) {
+                            return buffer.error('Decoding of string type: ' +
+                                'numstr unsupported characters');
+                        }
+                        return numstr;
+                    } else if (tag === 'octstr') {
+                        return buffer.raw();
+                    } else if (tag === 'objDesc') {
+                        return buffer.raw();
+                    } else if (tag === 'printstr') {
+                        var printstr = buffer.raw().toString('ascii');
+                        if (!this._isPrintstr(printstr)) {
+                            return buffer.error('Decoding of string type: ' +
+                                'printstr unsupported characters');
+                        }
+                        return printstr;
+                    } else if (/str$/.test(tag)) {
+                        return buffer.raw().toString();
+                    } else {
+                        return buffer.error('Decoding of string type: ' + tag + ' unsupported');
+                    }
+                };
+
+                DERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {
+                    var result;
+                    var identifiers = [];
+                    var ident = 0;
+                    while (!buffer.isEmpty()) {
+                        var subident = buffer.readUInt8();
+                        ident <<= 7;
+                        ident |= subident & 0x7f;
+                        if ((subident & 0x80) === 0) {
+                            identifiers.push(ident);
+                            ident = 0;
+                        }
+                    }
+                    if (subident & 0x80)
+                        identifiers.push(ident);
+
+                    var first = (identifiers[0] / 40) | 0;
+                    var second = identifiers[0] % 40;
+
+                    if (relative)
+                        result = identifiers;
+                    else
+                        result = [first, second].concat(identifiers.slice(1));
+
+                    if (values) {
+                        var tmp = values[result.join(' ')];
+                        if (tmp === undefined)
+                            tmp = values[result.join('.')];
+                        if (tmp !== undefined)
+                            result = tmp;
+                    }
+
+                    return result;
+                };
+
+                DERNode.prototype._decodeTime = function decodeTime(buffer, tag) {
+                    var str = buffer.raw().toString();
+                    if (tag === 'gentime') {
+                        var year = str.slice(0, 4) | 0;
+                        var mon = str.slice(4, 6) | 0;
+                        var day = str.slice(6, 8) | 0;
+                        var hour = str.slice(8, 10) | 0;
+                        var min = str.slice(10, 12) | 0;
+                        var sec = str.slice(12, 14) | 0;
+                    } else if (tag === 'utctime') {
+                        var year = str.slice(0, 2) | 0;
+                        var mon = str.slice(2, 4) | 0;
+                        var day = str.slice(4, 6) | 0;
+                        var hour = str.slice(6, 8) | 0;
+                        var min = str.slice(8, 10) | 0;
+                        var sec = str.slice(10, 12) | 0;
+                        if (year < 70)
+                            year = 2000 + year;
+                        else
+                            year = 1900 + year;
+                    } else {
+                        return buffer.error('Decoding ' + tag + ' time is not supported yet');
+                    }
+
+                    return Date.UTC(year, mon - 1, day, hour, min, sec, 0);
+                };
+
+                DERNode.prototype._decodeNull = function decodeNull(buffer) {
+                    return null;
+                };
+
+                DERNode.prototype._decodeBool = function decodeBool(buffer) {
+                    var res = buffer.readUInt8();
+                    if (buffer.isError(res))
+                        return res;
+                    else
+                        return res !== 0;
+                };
+
+                DERNode.prototype._decodeInt = function decodeInt(buffer, values) {
+                    // Bigint, return as it is (assume big endian)
+                    var raw = buffer.raw();
+                    var res = new bignum(raw);
+
+                    if (values)
+                        res = values[res.toString(10)] || res;
+
+                    return res;
+                };
+
+                DERNode.prototype._use = function use(entity, obj) {
+                    if (typeof entity === 'function')
+                        entity = entity(obj);
+                    return entity._getDecoder('der').tree;
+                };
+
+                // Utility methods
+
+                function derDecodeTag(buf, fail) {
+                    var tag = buf.readUInt8(fail);
+                    if (buf.isError(tag))
+                        return tag;
+
+                    var cls = der.tagClass[tag >> 6];
+                    var primitive = (tag & 0x20) === 0;
+
+                    // Multi-octet tag - load
+                    if ((tag & 0x1f) === 0x1f) {
+                        var oct = tag;
+                        tag = 0;
+                        while ((oct & 0x80) === 0x80) {
+                            oct = buf.readUInt8(fail);
+                            if (buf.isError(oct))
+                                return oct;
+
+                            tag <<= 7;
+                            tag |= oct & 0x7f;
+                        }
+                    } else {
+                        tag &= 0x1f;
+                    }
+                    var tagStr = der.tag[tag];
+
+                    return {
+                        cls: cls,
+                        primitive: primitive,
+                        tag: tag,
+                        tagStr: tagStr
+                    };
+                }
+
+                function derDecodeLen(buf, primitive, fail) {
+                    var len = buf.readUInt8(fail);
+                    if (buf.isError(len))
+                        return len;
+
+                    // Indefinite form
+                    if (!primitive && len === 0x80)
+                        return null;
+
+                    // Definite form
+                    if ((len & 0x80) === 0) {
+                        // Short form
+                        return len;
+                    }
+
+                    // Long form
+                    var num = len & 0x7f;
+                    if (num > 4)
+                        return buf.error('length octect is too long');
+
+                    len = 0;
+                    for (var i = 0; i < num; i++) {
+                        len <<= 8;
+                        var j = buf.readUInt8(fail);
+                        if (buf.isError(j))
+                            return j;
+                        len |= j;
+                    }
+
+                    return len;
+                }
+
+            }, {
+                "../../asn1": 9,
+                "inherits": 107
+            }],
+            18: [function (require, module, exports) {
+                var decoders = exports;
+
+                decoders.der = require('./der');
+                decoders.pem = require('./pem');
+
+            }, {
+                "./der": 17,
+                "./pem": 19
+            }],
+            19: [function (require, module, exports) {
+                var inherits = require('inherits');
+                var Buffer = require('buffer').Buffer;
+
+                var DERDecoder = require('./der');
+
+                function PEMDecoder(entity) {
+                    DERDecoder.call(this, entity);
+                    this.enc = 'pem';
+                };
+                inherits(PEMDecoder, DERDecoder);
+                module.exports = PEMDecoder;
+
+                PEMDecoder.prototype.decode = function decode(data, options) {
+                    var lines = data.toString().split(/[\r\n]+/g);
+
+                    var label = options.label.toUpperCase();
+
+                    var re = /^-----(BEGIN|END) ([^-]+)-----$/;
+                    var start = -1;
+                    var end = -1;
+                    for (var i = 0; i < lines.length; i++) {
+                        var match = lines[i].match(re);
+                        if (match === null)
+                            continue;
+
+                        if (match[2] !== label)
+                            continue;
+
+                        if (start === -1) {
+                            if (match[1] !== 'BEGIN')
+                                break;
+                            start = i;
+                        } else {
+                            if (match[1] !== 'END')
+                                break;
+                            end = i;
+                            break;
+                        }
+                    }
+                    if (start === -1 || end === -1)
+                        throw new Error('PEM section not found for: ' + label);
+
+                    var base64 = lines.slice(start + 1, end).join('');
+                    // Remove excessive symbols
+                    base64.replace(/[^a-z0-9\+\/=]+/gi, '');
+
+                    var input = new Buffer(base64, 'base64');
+                    return DERDecoder.prototype.decode.call(this, input, options);
+                };
+
+            }, {
+                "./der": 17,
+                "buffer": 55,
+                "inherits": 107
+            }],
+            20: [function (require, module, exports) {
+                var inherits = require('inherits');
+                var Buffer = require('buffer').Buffer;
+
+                var asn1 = require('../../asn1');
+                var base = asn1.base;
+
+                // Import DER constants
+                var der = asn1.constants.der;
+
+                function DEREncoder(entity) {
+                    this.enc = 'der';
+                    this.name = entity.name;
+                    this.entity = entity;
+
+                    // Construct base tree
+                    this.tree = new DERNode();
+                    this.tree._init(entity.body);
+                };
+                module.exports = DEREncoder;
+
+                DEREncoder.prototype.encode = function encode(data, reporter) {
+                    return this.tree._encode(data, reporter).join();
+                };
+
+                // Tree methods
+
+                function DERNode(parent) {
+                    base.Node.call(this, 'der', parent);
+                }
+                inherits(DERNode, base.Node);
+
+                DERNode.prototype._encodeComposite = function encodeComposite(tag,
+                    primitive,
+                    cls,
+                    content) {
+                    var encodedTag = encodeTag(tag, primitive, cls, this.reporter);
+
+                    // Short form
+                    if (content.length < 0x80) {
+                        var header = new Buffer(2);
+                        header[0] = encodedTag;
+                        header[1] = content.length;
+                        return this._createEncoderBuffer([header, content]);
+                    }
+
+                    // Long form
+                    // Count octets required to store length
+                    var lenOctets = 1;
+                    for (var i = content.length; i >= 0x100; i >>= 8)
+                        lenOctets++;
+
+                    var header = new Buffer(1 + 1 + lenOctets);
+                    header[0] = encodedTag;
+                    header[1] = 0x80 | lenOctets;
+
+                    for (var i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8)
+                        header[i] = j & 0xff;
+
+                    return this._createEncoderBuffer([header, content]);
+                };
+
+                DERNode.prototype._encodeStr = function encodeStr(str, tag) {
+                    if (tag === 'bitstr') {
+                        return this._createEncoderBuffer([str.unused | 0, str.data]);
+                    } else if (tag === 'bmpstr') {
+                        var buf = new Buffer(str.length * 2);
+                        for (var i = 0; i < str.length; i++) {
+                            buf.writeUInt16BE(str.charCodeAt(i), i * 2);
+                        }
+                        return this._createEncoderBuffer(buf);
+                    } else if (tag === 'numstr') {
+                        if (!this._isNumstr(str)) {
+                            return this.reporter.error('Encoding of string type: numstr supports ' +
+                                'only digits and space');
+                        }
+                        return this._createEncoderBuffer(str);
+                    } else if (tag === 'printstr') {
+                        if (!this._isPrintstr(str)) {
+                            return this.reporter.error('Encoding of string type: printstr supports ' +
+                                'only latin upper and lower case letters, ' +
+                                'digits, space, apostrophe, left and rigth ' +
+                                'parenthesis, plus sign, comma, hyphen, ' +
+                                'dot, slash, colon, equal sign, ' +
+                                'question mark');
+                        }
+                        return this._createEncoderBuffer(str);
+                    } else if (/str$/.test(tag)) {
+                        return this._createEncoderBuffer(str);
+                    } else if (tag === 'objDesc') {
+                        return this._createEncoderBuffer(str);
+                    } else {
+                        return this.reporter.error('Encoding of string type: ' + tag +
+                            ' unsupported');
+                    }
+                };
+
+                DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {
+                    if (typeof id === 'string') {
+                        if (!values)
+                            return this.reporter.error('string objid given, but no values map found');
+                        if (!values.hasOwnProperty(id))
+                            return this.reporter.error('objid not found in values map');
+                        id = values[id].split(/[\s\.]+/g);
+                        for (var i = 0; i < id.length; i++)
+                            id[i] |= 0;
+                    } else if (Array.isArray(id)) {
+                        id = id.slice();
+                        for (var i = 0; i < id.length; i++)
+                            id[i] |= 0;
+                    }
+
+                    if (!Array.isArray(id)) {
+                        return this.reporter.error('objid() should be either array or string, ' +
+                            'got: ' + JSON.stringify(id));
+                    }
+
+                    if (!relative) {
+                        if (id[1] >= 40)
+                            return this.reporter.error('Second objid identifier OOB');
+                        id.splice(0, 2, id[0] * 40 + id[1]);
+                    }
+
+                    // Count number of octets
+                    var size = 0;
+                    for (var i = 0; i < id.length; i++) {
+                        var ident = id[i];
+                        for (size++; ident >= 0x80; ident >>= 7)
+                            size++;
+                    }
+
+                    var objid = new Buffer(size);
+                    var offset = objid.length - 1;
+                    for (var i = id.length - 1; i >= 0; i--) {
+                        var ident = id[i];
+                        objid[offset--] = ident & 0x7f;
+                        while ((ident >>= 7) > 0)
+                            objid[offset--] = 0x80 | (ident & 0x7f);
+                    }
+
+                    return this._createEncoderBuffer(objid);
+                };
+
+                function two(num) {
+                    if (num < 10)
+                        return '0' + num;
+                    else
+                        return num;
+                }
+
+                DERNode.prototype._encodeTime = function encodeTime(time, tag) {
+                    var str;
+                    var date = new Date(time);
+
+                    if (tag === 'gentime') {
+                        str = [
+                            two(date.getFullYear()),
+                            two(date.getUTCMonth() + 1),
+                            two(date.getUTCDate()),
+                            two(date.getUTCHours()),
+                            two(date.getUTCMinutes()),
+                            two(date.getUTCSeconds()),
+                            'Z'
+                        ].join('');
+                    } else if (tag === 'utctime') {
+                        str = [
+                            two(date.getFullYear() % 100),
+                            two(date.getUTCMonth() + 1),
+                            two(date.getUTCDate()),
+                            two(date.getUTCHours()),
+                            two(date.getUTCMinutes()),
+                            two(date.getUTCSeconds()),
+                            'Z'
+                        ].join('');
+                    } else {
+                        this.reporter.error('Encoding ' + tag + ' time is not supported yet');
+                    }
+
+                    return this._encodeStr(str, 'octstr');
+                };
+
+                DERNode.prototype._encodeNull = function encodeNull() {
+                    return this._createEncoderBuffer('');
+                };
+
+                DERNode.prototype._encodeInt = function encodeInt(num, values) {
+                    if (typeof num === 'string') {
+                        if (!values)
+                            return this.reporter.error('String int or enum given, but no values map');
+                        if (!values.hasOwnProperty(num)) {
+                            return this.reporter.error('Values map doesn\'t contain: ' +
+                                JSON.stringify(num));
+                        }
+                        num = values[num];
+                    }
+
+                    // Bignum, assume big endian
+                    if (typeof num !== 'number' && !Buffer.isBuffer(num)) {
+                        var numArray = num.toArray();
+                        if (!num.sign && numArray[0] & 0x80) {
+                            numArray.unshift(0);
+                        }
+                        num = new Buffer(numArray);
+                    }
+
+                    if (Buffer.isBuffer(num)) {
+                        var size = num.length;
+                        if (num.length === 0)
+                            size++;
+
+                        var out = new Buffer(size);
+                        num.copy(out);
+                        if (num.length === 0)
+                            out[0] = 0
+                        return this._createEncoderBuffer(out);
+                    }
+
+                    if (num < 0x80)
+                        return this._createEncoderBuffer(num);
+
+                    if (num < 0x100)
+                        return this._createEncoderBuffer([0, num]);
+
+                    var size = 1;
+                    for (var i = num; i >= 0x100; i >>= 8)
+                        size++;
+
+                    var out = new Array(size);
+                    for (var i = out.length - 1; i >= 0; i--) {
+                        out[i] = num & 0xff;
+                        num >>= 8;
+                    }
+                    if (out[0] & 0x80) {
+                        out.unshift(0);
+                    }
+
+                    return this._createEncoderBuffer(new Buffer(out));
+                };
+
+                DERNode.prototype._encodeBool = function encodeBool(value) {
+                    return this._createEncoderBuffer(value ? 0xff : 0);
+                };
+
+                DERNode.prototype._use = function use(entity, obj) {
+                    if (typeof entity === 'function')
+                        entity = entity(obj);
+                    return entity._getEncoder('der').tree;
+                };
+
+                DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) {
+                    var state = this._baseState;
+                    var i;
+                    if (state['default'] === null)
+                        return false;
+
+                    var data = dataBuffer.join();
+                    if (state.defaultBuffer === undefined)
+                        state.defaultBuffer = this._encodeValue(state['default'], reporter, parent).join();
+
+                    if (data.length !== state.defaultBuffer.length)
+                        return false;
+
+                    for (i = 0; i < data.length; i++)
+                        if (data[i] !== state.defaultBuffer[i])
+                            return false;
+
+                    return true;
+                };
+
+                // Utility methods
+
+                function encodeTag(tag, primitive, cls, reporter) {
+                    var res;
+
+                    if (tag === 'seqof')
+                        tag = 'seq';
+                    else if (tag === 'setof')
+                        tag = 'set';
+
+                    if (der.tagByName.hasOwnProperty(tag))
+                        res = der.tagByName[tag];
+                    else if (typeof tag === 'number' && (tag | 0) === tag)
+                        res = tag;
+                    else
+                        return reporter.error('Unknown tag: ' + tag);
+
+                    if (res >= 0x1f)
+                        return reporter.error('Multi-octet tag encoding unsupported');
+
+                    if (!primitive)
+                        res |= 0x20;
+
+                    res |= (der.tagClassByName[cls || 'universal'] << 6);
+
+                    return res;
+                }
+
+            }, {
+                "../../asn1": 9,
+                "buffer": 55,
+                "inherits": 107
+            }],
+            21: [function (require, module, exports) {
+                var encoders = exports;
+
+                encoders.der = require('./der');
+                encoders.pem = require('./pem');
+
+            }, {
+                "./der": 20,
+                "./pem": 22
+            }],
+            22: [function (require, module, exports) {
+                var inherits = require('inherits');
+
+                var DEREncoder = require('./der');
+
+                function PEMEncoder(entity) {
+                    DEREncoder.call(this, entity);
+                    this.enc = 'pem';
+                };
+                inherits(PEMEncoder, DEREncoder);
+                module.exports = PEMEncoder;
+
+                PEMEncoder.prototype.encode = function encode(data, options) {
+                    var buf = DEREncoder.prototype.encode.call(this, data);
+
+                    var p = buf.toString('base64');
+                    var out = ['-----BEGIN ' + options.label + '-----'];
+                    for (var i = 0; i < p.length; i += 64)
+                        out.push(p.slice(i, i + 64));
+                    out.push('-----END ' + options.label + '-----');
+                    return out.join('\n');
+                };
+
+            }, {
+                "./der": 20,
+                "inherits": 107
+            }],
+            23: [function (require, module, exports) {
+                'use strict'
+
+                exports.byteLength = byteLength
+                exports.toByteArray = toByteArray
+                exports.fromByteArray = fromByteArray
+
+                var lookup = []
+                var revLookup = []
+                var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+                var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+                for (var i = 0, len = code.length; i < len; ++i) {
+                    lookup[i] = code[i]
+                    revLookup[code.charCodeAt(i)] = i
+                }
+
+                // Support decoding URL-safe base64 strings, as Node.js does.
+                // See: https://en.wikipedia.org/wiki/Base64#URL_applications
+                revLookup['-'.charCodeAt(0)] = 62
+                revLookup['_'.charCodeAt(0)] = 63
+
+                function getLens(b64) {
+                    var len = b64.length
+
+                    if (len % 4 > 0) {
+                        throw new Error('Invalid string. Length must be a multiple of 4')
+                    }
+
+                    // Trim off extra bytes after placeholder bytes are found
+                    // See: https://github.com/beatgammit/base64-js/issues/42
+                    var validLen = b64.indexOf('=')
+                    if (validLen === -1) validLen = len
+
+                    var placeHoldersLen = validLen === len ?
+                        0 :
+                        4 - (validLen % 4)
+
+                    return [validLen, placeHoldersLen]
+                }
+
+                // base64 is 4/3 + up to two characters of the original data
+                function byteLength(b64) {
+                    var lens = getLens(b64)
+                    var validLen = lens[0]
+                    var placeHoldersLen = lens[1]
+                    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+                }
+
+                function _byteLength(b64, validLen, placeHoldersLen) {
+                    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+                }
+
+                function toByteArray(b64) {
+                    var tmp
+                    var lens = getLens(b64)
+                    var validLen = lens[0]
+                    var placeHoldersLen = lens[1]
+
+                    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+                    var curByte = 0
+
+                    // if there are placeholders, only get up to the last complete 4 chars
+                    var len = placeHoldersLen > 0 ?
+                        validLen - 4 :
+                        validLen
+
+                    for (var i = 0; i < len; i += 4) {
+                        tmp =
+                            (revLookup[b64.charCodeAt(i)] << 18) |
+                            (revLookup[b64.charCodeAt(i + 1)] << 12) |
+                            (revLookup[b64.charCodeAt(i + 2)] << 6) |
+                            revLookup[b64.charCodeAt(i + 3)]
+                        arr[curByte++] = (tmp >> 16) & 0xFF
+                        arr[curByte++] = (tmp >> 8) & 0xFF
+                        arr[curByte++] = tmp & 0xFF
+                    }
+
+                    if (placeHoldersLen === 2) {
+                        tmp =
+                            (revLookup[b64.charCodeAt(i)] << 2) |
+                            (revLookup[b64.charCodeAt(i + 1)] >> 4)
+                        arr[curByte++] = tmp & 0xFF
+                    }
+
+                    if (placeHoldersLen === 1) {
+                        tmp =
+                            (revLookup[b64.charCodeAt(i)] << 10) |
+                            (revLookup[b64.charCodeAt(i + 1)] << 4) |
+                            (revLookup[b64.charCodeAt(i + 2)] >> 2)
+                        arr[curByte++] = (tmp >> 8) & 0xFF
+                        arr[curByte++] = 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) & 0xFF0000) +
+                            ((uint8[i + 1] << 8) & 0xFF00) +
+                            (uint8[i + 2] & 0xFF)
+                        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 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]
+                        parts.push(
+                            lookup[tmp >> 2] +
+                            lookup[(tmp << 4) & 0x3F] +
+                            '=='
+                        )
+                    } else if (extraBytes === 2) {
+                        tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+                        parts.push(
+                            lookup[tmp >> 10] +
+                            lookup[(tmp >> 4) & 0x3F] +
+                            lookup[(tmp << 2) & 0x3F] +
+                            '='
+                        )
+                    }
+
+                    return parts.join('')
+                }
+
+            }, {}],
+            24: [function (require, module, exports) {
+                (function (module, exports) {
+                    'use strict';
+
+                    // Utils
+                    function assert(val, msg) {
+                        if (!val) throw new Error(msg || 'Assertion failed');
+                    }
+
+                    // Could use `inherits` module, but don't want to move from single file
+                    // architecture yet.
+                    function inherits(ctor, superCtor) {
+                        ctor.super_ = superCtor;
+                        var TempCtor = function () {};
+                        TempCtor.prototype = superCtor.prototype;
+                        ctor.prototype = new TempCtor();
+                        ctor.prototype.constructor = ctor;
+                    }
+
+                    // BN
+
+                    function BN(number, base, endian) {
+                        if (BN.isBN(number)) {
+                            return number;
+                        }
+
+                        this.negative = 0;
+                        this.words = null;
+                        this.length = 0;
+
+                        // Reduction context
+                        this.red = null;
+
+                        if (number !== null) {
+                            if (base === 'le' || base === 'be') {
+                                endian = base;
+                                base = 10;
+                            }
+
+                            this._init(number || 0, base || 10, endian || 'be');
+                        }
+                    }
+                    if (typeof module === 'object') {
+                        module.exports = BN;
+                    } else {
+                        exports.BN = BN;
+                    }
+
+                    BN.BN = BN;
+                    BN.wordSize = 26;
+
+                    var Buffer;
+                    try {
+                        Buffer = require('buffer').Buffer;
+                    } catch (e) {}
+
+                    BN.isBN = function isBN(num) {
+                        if (num instanceof BN) {
+                            return true;
+                        }
+
+                        return num !== null && typeof num === 'object' &&
+                            num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
+                    };
+
+                    BN.max = function max(left, right) {
+                        if (left.cmp(right) > 0) return left;
+                        return right;
+                    };
+
+                    BN.min = function min(left, right) {
+                        if (left.cmp(right) < 0) return left;
+                        return right;
+                    };
+
+                    BN.prototype._init = function init(number, base, endian) {
+                        if (typeof number === 'number') {
+                            return this._initNumber(number, base, endian);
+                        }
+
+                        if (typeof number === 'object') {
+                            return this._initArray(number, base, endian);
+                        }
+
+                        if (base === 'hex') {
+                            base = 16;
+                        }
+                        assert(base === (base | 0) && base >= 2 && base <= 36);
+
+                        number = number.toString().replace(/\s+/g, '');
+                        var start = 0;
+                        if (number[0] === '-') {
+                            start++;
+                        }
+
+                        if (base === 16) {
+                            this._parseHex(number, start);
+                        } else {
+                            this._parseBase(number, base, start);
+                        }
+
+                        if (number[0] === '-') {
+                            this.negative = 1;
+                        }
+
+                        this.strip();
+
+                        if (endian !== 'le') return;
+
+                        this._initArray(this.toArray(), base, endian);
+                    };
+
+                    BN.prototype._initNumber = function _initNumber(number, base, endian) {
+                        if (number < 0) {
+                            this.negative = 1;
+                            number = -number;
+                        }
+                        if (number < 0x4000000) {
+                            this.words = [number & 0x3ffffff];
+                            this.length = 1;
+                        } else if (number < 0x10000000000000) {
+                            this.words = [
+                                number & 0x3ffffff,
+                                (number / 0x4000000) & 0x3ffffff
+                            ];
+                            this.length = 2;
+                        } else {
+                            assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
+                            this.words = [
+                                number & 0x3ffffff,
+                                (number / 0x4000000) & 0x3ffffff,
+                                1
+                            ];
+                            this.length = 3;
+                        }
+
+                        if (endian !== 'le') return;
+
+                        // Reverse the bytes
+                        this._initArray(this.toArray(), base, endian);
+                    };
+
+                    BN.prototype._initArray = function _initArray(number, base, endian) {
+                        // Perhaps a Uint8Array
+                        assert(typeof number.length === 'number');
+                        if (number.length <= 0) {
+                            this.words = [0];
+                            this.length = 1;
+                            return this;
+                        }
+
+                        this.length = Math.ceil(number.length / 3);
+                        this.words = new Array(this.length);
+                        for (var i = 0; i < this.length; i++) {
+                            this.words[i] = 0;
+                        }
+
+                        var j, w;
+                        var off = 0;
+                        if (endian === 'be') {
+                            for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
+                                w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
+                                this.words[j] |= (w << off) & 0x3ffffff;
+                                this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+                                off += 24;
+                                if (off >= 26) {
+                                    off -= 26;
+                                    j++;
+                                }
+                            }
+                        } else if (endian === 'le') {
+                            for (i = 0, j = 0; i < number.length; i += 3) {
+                                w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
+                                this.words[j] |= (w << off) & 0x3ffffff;
+                                this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+                                off += 24;
+                                if (off >= 26) {
+                                    off -= 26;
+                                    j++;
+                                }
+                            }
+                        }
+                        return this.strip();
+                    };
+
+                    function parseHex(str, start, end) {
+                        var r = 0;
+                        var len = Math.min(str.length, end);
+                        for (var i = start; i < len; i++) {
+                            var c = str.charCodeAt(i) - 48;
+
+                            r <<= 4;
+
+                            // 'a' - 'f'
+                            if (c >= 49 && c <= 54) {
+                                r |= c - 49 + 0xa;
+
+                                // 'A' - 'F'
+                            } else if (c >= 17 && c <= 22) {
+                                r |= c - 17 + 0xa;
+
+                                // '0' - '9'
+                            } else {
+                                r |= c & 0xf;
+                            }
+                        }
+                        return r;
+                    }
+
+                    BN.prototype._parseHex = function _parseHex(number, start) {
+                        // Create possibly bigger array to ensure that it fits the number
+                        this.length = Math.ceil((number.length - start) / 6);
+                        this.words = new Array(this.length);
+                        for (var i = 0; i < this.length; i++) {
+                            this.words[i] = 0;
+                        }
+
+                        var j, w;
+                        // Scan 24-bit chunks and add them to the number
+                        var off = 0;
+                        for (i = number.length - 6, j = 0; i >= start; i -= 6) {
+                            w = parseHex(number, i, i + 6);
+                            this.words[j] |= (w << off) & 0x3ffffff;
+                            // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb
+                            this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
+                            off += 24;
+                            if (off >= 26) {
+                                off -= 26;
+                                j++;
+                            }
+                        }
+                        if (i + 6 !== start) {
+                            w = parseHex(number, start, i + 6);
+                            this.words[j] |= (w << off) & 0x3ffffff;
+                            this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
+                        }
+                        this.strip();
+                    };
+
+                    function parseBase(str, start, end, mul) {
+                        var r = 0;
+                        var len = Math.min(str.length, end);
+                        for (var i = start; i < len; i++) {
+                            var c = str.charCodeAt(i) - 48;
+
+                            r *= mul;
+
+                            // 'a'
+                            if (c >= 49) {
+                                r += c - 49 + 0xa;
+
+                                // 'A'
+                            } else if (c >= 17) {
+                                r += c - 17 + 0xa;
+
+                                // '0' - '9'
+                            } else {
+                                r += c;
+                            }
+                        }
+                        return r;
+                    }
+
+                    BN.prototype._parseBase = function _parseBase(number, base, start) {
+                        // Initialize as zero
+                        this.words = [0];
+                        this.length = 1;
+
+                        // Find length of limb in base
+                        for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
+                            limbLen++;
+                        }
+                        limbLen--;
+                        limbPow = (limbPow / base) | 0;
+
+                        var total = number.length - start;
+                        var mod = total % limbLen;
+                        var end = Math.min(total, total - mod) + start;
+
+                        var word = 0;
+                        for (var i = start; i < end; i += limbLen) {
+                            word = parseBase(number, i, i + limbLen, base);
+
+                            this.imuln(limbPow);
+                            if (this.words[0] + word < 0x4000000) {
+                                this.words[0] += word;
+                            } else {
+                                this._iaddn(word);
+                            }
+                        }
+
+                        if (mod !== 0) {
+                            var pow = 1;
+                            word = parseBase(number, i, number.length, base);
+
+                            for (i = 0; i < mod; i++) {
+                                pow *= base;
+                            }
+
+                            this.imuln(pow);
+                            if (this.words[0] + word < 0x4000000) {
+                                this.words[0] += word;
+                            } else {
+                                this._iaddn(word);
+                            }
+                        }
+                    };
+
+                    BN.prototype.copy = function copy(dest) {
+                        dest.words = new Array(this.length);
+                        for (var i = 0; i < this.length; i++) {
+                            dest.words[i] = this.words[i];
+                        }
+                        dest.length = this.length;
+                        dest.negative = this.negative;
+                        dest.red = this.red;
+                    };
+
+                    BN.prototype.clone = function clone() {
+                        var r = new BN(null);
+                        this.copy(r);
+                        return r;
+                    };
+
+                    BN.prototype._expand = function _expand(size) {
+                        while (this.length < size) {
+                            this.words[this.length++] = 0;
+                        }
+                        return this;
+                    };
+
+                    // Remove leading `0` from `this`
+                    BN.prototype.strip = function strip() {
+                        while (this.length > 1 && this.words[this.length - 1] === 0) {
+                            this.length--;
+                        }
+                        return this._normSign();
+                    };
+
+                    BN.prototype._normSign = function _normSign() {
+                        // -0 = 0
+                        if (this.length === 1 && this.words[0] === 0) {
+                            this.negative = 0;
+                        }
+                        return this;
+                    };
+
+                    BN.prototype.inspect = function inspect() {
+                        return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
+                    };
+
+                    /*
+
+                    var zeros = [];
+                    var groupSizes = [];
+                    var groupBases = [];
+
+                    var s = '';
+                    var i = -1;
+                    while (++i < BN.wordSize) {
+                    zeros[i] = s;
+                    s += '0';
+                    }
+                    groupSizes[0] = 0;
+                    groupSizes[1] = 0;
+                    groupBases[0] = 0;
+                    groupBases[1] = 0;
+                    var base = 2 - 1;
+                    while (++base < 36 + 1) {
+                    var groupSize = 0;
+                    var groupBase = 1;
+                    while (groupBase < (1 << BN.wordSize) / base) {
+                        groupBase *= base;
+                        groupSize += 1;
+                    }
+                    groupSizes[base] = groupSize;
+                    groupBases[base] = groupBase;
+                    }
+
+                    */
+
+                    var zeros = [
+                        '',
+                        '0',
+                        '00',
+                        '000',
+                        '0000',
+                        '00000',
+                        '000000',
+                        '0000000',
+                        '00000000',
+                        '000000000',
+                        '0000000000',
+                        '00000000000',
+                        '000000000000',
+                        '0000000000000',
+                        '00000000000000',
+                        '000000000000000',
+                        '0000000000000000',
+                        '00000000000000000',
+                        '000000000000000000',
+                        '0000000000000000000',
+                        '00000000000000000000',
+                        '000000000000000000000',
+                        '0000000000000000000000',
+                        '00000000000000000000000',
+                        '000000000000000000000000',
+                        '0000000000000000000000000'
+                    ];
+
+                    var groupSizes = [
+                        0, 0,
+                        25, 16, 12, 11, 10, 9, 8,
+                        8, 7, 7, 7, 7, 6, 6,
+                        6, 6, 6, 6, 6, 5, 5,
+                        5, 5, 5, 5, 5, 5, 5,
+                        5, 5, 5, 5, 5, 5, 5
+                    ];
+
+                    var groupBases = [
+                        0, 0,
+                        33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
+                        43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
+                        16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
+                        6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
+                        24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
+                    ];
+
+                    BN.prototype.toString = function toString(base, padding) {
+                        base = base || 10;
+                        padding = padding | 0 || 1;
+
+                        var out;
+                        if (base === 16 || base === 'hex') {
+                            out = '';
+                            var off = 0;
+                            var carry = 0;
+                            for (var i = 0; i < this.length; i++) {
+                                var w = this.words[i];
+                                var word = (((w << off) | carry) & 0xffffff).toString(16);
+                                carry = (w >>> (24 - off)) & 0xffffff;
+                                if (carry !== 0 || i !== this.length - 1) {
+                                    out = zeros[6 - word.length] + word + out;
+                                } else {
+                                    out = word + out;
+                                }
+                                off += 2;
+                                if (off >= 26) {
+                                    off -= 26;
+                                    i--;
+                                }
+                            }
+                            if (carry !== 0) {
+                                out = carry.toString(16) + out;
+                            }
+                            while (out.length % padding !== 0) {
+                                out = '0' + out;
+                            }
+                            if (this.negative !== 0) {
+                                out = '-' + out;
+                            }
+                            return out;
+                        }
+
+                        if (base === (base | 0) && base >= 2 && base <= 36) {
+                            // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
+                            var groupSize = groupSizes[base];
+                            // var groupBase = Math.pow(base, groupSize);
+                            var groupBase = groupBases[base];
+                            out = '';
+                            var c = this.clone();
+                            c.negative = 0;
+                            while (!c.isZero()) {
+                                var r = c.modn(groupBase).toString(base);
+                                c = c.idivn(groupBase);
+
+                                if (!c.isZero()) {
+                                    out = zeros[groupSize - r.length] + r + out;
+                                } else {
+                                    out = r + out;
+                                }
+                            }
+                            if (this.isZero()) {
+                                out = '0' + out;
+                            }
+                            while (out.length % padding !== 0) {
+                                out = '0' + out;
+                            }
+                            if (this.negative !== 0) {
+                                out = '-' + out;
+                            }
+                            return out;
+                        }
+
+                        assert(false, 'Base should be between 2 and 36');
+                    };
+
+                    BN.prototype.toNumber = function toNumber() {
+                        var ret = this.words[0];
+                        if (this.length === 2) {
+                            ret += this.words[1] * 0x4000000;
+                        } else if (this.length === 3 && this.words[2] === 0x01) {
+                            // NOTE: at this stage it is known that the top bit is set
+                            ret += 0x10000000000000 + (this.words[1] * 0x4000000);
+                        } else if (this.length > 2) {
+                            assert(false, 'Number can only safely store up to 53 bits');
+                        }
+                        return (this.negative !== 0) ? -ret : ret;
+                    };
+
+                    BN.prototype.toJSON = function toJSON() {
+                        return this.toString(16);
+                    };
+
+                    BN.prototype.toBuffer = function toBuffer(endian, length) {
+                        assert(typeof Buffer !== 'undefined');
+                        return this.toArrayLike(Buffer, endian, length);
+                    };
+
+                    BN.prototype.toArray = function toArray(endian, length) {
+                        return this.toArrayLike(Array, endian, length);
+                    };
+
+                    BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
+                        var byteLength = this.byteLength();
+                        var reqLength = length || Math.max(1, byteLength);
+                        assert(byteLength <= reqLength, 'byte array longer than desired length');
+                        assert(reqLength > 0, 'Requested array length <= 0');
+
+                        this.strip();
+                        var littleEndian = endian === 'le';
+                        var res = new ArrayType(reqLength);
+
+                        var b, i;
+                        var q = this.clone();
+                        if (!littleEndian) {
+                            // Assume big-endian
+                            for (i = 0; i < reqLength - byteLength; i++) {
+                                res[i] = 0;
+                            }
+
+                            for (i = 0; !q.isZero(); i++) {
+                                b = q.andln(0xff);
+                                q.iushrn(8);
+
+                                res[reqLength - i - 1] = b;
+                            }
+                        } else {
+                            for (i = 0; !q.isZero(); i++) {
+                                b = q.andln(0xff);
+                                q.iushrn(8);
+
+                                res[i] = b;
+                            }
+
+                            for (; i < reqLength; i++) {
+                                res[i] = 0;
+                            }
+                        }
+
+                        return res;
+                    };
+
+                    if (Math.clz32) {
+                        BN.prototype._countBits = function _countBits(w) {
+                            return 32 - Math.clz32(w);
+                        };
+                    } else {
+                        BN.prototype._countBits = function _countBits(w) {
+                            var t = w;
+                            var r = 0;
+                            if (t >= 0x1000) {
+                                r += 13;
+                                t >>>= 13;
+                            }
+                            if (t >= 0x40) {
+                                r += 7;
+                                t >>>= 7;
+                            }
+                            if (t >= 0x8) {
+                                r += 4;
+                                t >>>= 4;
+                            }
+                            if (t >= 0x02) {
+                                r += 2;
+                                t >>>= 2;
+                            }
+                            return r + t;
+                        };
+                    }
+
+                    BN.prototype._zeroBits = function _zeroBits(w) {
+                        // Short-cut
+                        if (w === 0) return 26;
+
+                        var t = w;
+                        var r = 0;
+                        if ((t & 0x1fff) === 0) {
+                            r += 13;
+                            t >>>= 13;
+                        }
+                        if ((t & 0x7f) === 0) {
+                            r += 7;
+                            t >>>= 7;
+                        }
+                        if ((t & 0xf) === 0) {
+                            r += 4;
+                            t >>>= 4;
+                        }
+                        if ((t & 0x3) === 0) {
+                            r += 2;
+                            t >>>= 2;
+                        }
+                        if ((t & 0x1) === 0) {
+                            r++;
+                        }
+                        return r;
+                    };
+
+                    // Return number of used bits in a BN
+                    BN.prototype.bitLength = function bitLength() {
+                        var w = this.words[this.length - 1];
+                        var hi = this._countBits(w);
+                        return (this.length - 1) * 26 + hi;
+                    };
+
+                    function toBitArray(num) {
+                        var w = new Array(num.bitLength());
+
+                        for (var bit = 0; bit < w.length; bit++) {
+                            var off = (bit / 26) | 0;
+                            var wbit = bit % 26;
+
+                            w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;
+                        }
+
+                        return w;
+                    }
+
+                    // Number of trailing zero bits
+                    BN.prototype.zeroBits = function zeroBits() {
+                        if (this.isZero()) return 0;
+
+                        var r = 0;
+                        for (var i = 0; i < this.length; i++) {
+                            var b = this._zeroBits(this.words[i]);
+                            r += b;
+                            if (b !== 26) break;
+                        }
+                        return r;
+                    };
+
+                    BN.prototype.byteLength = function byteLength() {
+                        return Math.ceil(this.bitLength() / 8);
+                    };
+
+                    BN.prototype.toTwos = function toTwos(width) {
+                        if (this.negative !== 0) {
+                            return this.abs().inotn(width).iaddn(1);
+                        }
+                        return this.clone();
+                    };
+
+                    BN.prototype.fromTwos = function fromTwos(width) {
+                        if (this.testn(width - 1)) {
+                            return this.notn(width).iaddn(1).ineg();
+                        }
+                        return this.clone();
+                    };
+
+                    BN.prototype.isNeg = function isNeg() {
+                        return this.negative !== 0;
+                    };
+
+                    // Return negative clone of `this`
+                    BN.prototype.neg = function neg() {
+                        return this.clone().ineg();
+                    };
+
+                    BN.prototype.ineg = function ineg() {
+                        if (!this.isZero()) {
+                            this.negative ^= 1;
+                        }
+
+                        return this;
+                    };
+
+                    // Or `num` with `this` in-place
+                    BN.prototype.iuor = function iuor(num) {
+                        while (this.length < num.length) {
+                            this.words[this.length++] = 0;
+                        }
+
+                        for (var i = 0; i < num.length; i++) {
+                            this.words[i] = this.words[i] | num.words[i];
+                        }
+
+                        return this.strip();
+                    };
+
+                    BN.prototype.ior = function ior(num) {
+                        assert((this.negative | num.negative) === 0);
+                        return this.iuor(num);
+                    };
+
+                    // Or `num` with `this`
+                    BN.prototype.or = function or(num) {
+                        if (this.length > num.length) return this.clone().ior(num);
+                        return num.clone().ior(this);
+                    };
+
+                    BN.prototype.uor = function uor(num) {
+                        if (this.length > num.length) return this.clone().iuor(num);
+                        return num.clone().iuor(this);
+                    };
+
+                    // And `num` with `this` in-place
+                    BN.prototype.iuand = function iuand(num) {
+                        // b = min-length(num, this)
+                        var b;
+                        if (this.length > num.length) {
+                            b = num;
+                        } else {
+                            b = this;
+                        }
+
+                        for (var i = 0; i < b.length; i++) {
+                            this.words[i] = this.words[i] & num.words[i];
+                        }
+
+                        this.length = b.length;
+
+                        return this.strip();
+                    };
+
+                    BN.prototype.iand = function iand(num) {
+                        assert((this.negative | num.negative) === 0);
+                        return this.iuand(num);
+                    };
+
+                    // And `num` with `this`
+                    BN.prototype.and = function and(num) {
+                        if (this.length > num.length) return this.clone().iand(num);
+                        return num.clone().iand(this);
+                    };
+
+                    BN.prototype.uand = function uand(num) {
+                        if (this.length > num.length) return this.clone().iuand(num);
+                        return num.clone().iuand(this);
+                    };
+
+                    // Xor `num` with `this` in-place
+                    BN.prototype.iuxor = function iuxor(num) {
+                        // a.length > b.length
+                        var a;
+                        var b;
+                        if (this.length > num.length) {
+                            a = this;
+                            b = num;
+                        } else {
+                            a = num;
+                            b = this;
+                        }
+
+                        for (var i = 0; i < b.length; i++) {
+                            this.words[i] = a.words[i] ^ b.words[i];
+                        }
+
+                        if (this !== a) {
+                            for (; i < a.length; i++) {
+                                this.words[i] = a.words[i];
+                            }
+                        }
+
+                        this.length = a.length;
+
+                        return this.strip();
+                    };
+
+                    BN.prototype.ixor = function ixor(num) {
+                        assert((this.negative | num.negative) === 0);
+                        return this.iuxor(num);
+                    };
+
+                    // Xor `num` with `this`
+                    BN.prototype.xor = function xor(num) {
+                        if (this.length > num.length) return this.clone().ixor(num);
+                        return num.clone().ixor(this);
+                    };
+
+                    BN.prototype.uxor = function uxor(num) {
+                        if (this.length > num.length) return this.clone().iuxor(num);
+                        return num.clone().iuxor(this);
+                    };
+
+                    // Not ``this`` with ``width`` bitwidth
+                    BN.prototype.inotn = function inotn(width) {
+                        assert(typeof width === 'number' && width >= 0);
+
+                        var bytesNeeded = Math.ceil(width / 26) | 0;
+                        var bitsLeft = width % 26;
+
+                        // Extend the buffer with leading zeroes
+                        this._expand(bytesNeeded);
+
+                        if (bitsLeft > 0) {
+                            bytesNeeded--;
+                        }
+
+                        // Handle complete words
+                        for (var i = 0; i < bytesNeeded; i++) {
+                            this.words[i] = ~this.words[i] & 0x3ffffff;
+                        }
+
+                        // Handle the residue
+                        if (bitsLeft > 0) {
+                            this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
+                        }
+
+                        // And remove leading zeroes
+                        return this.strip();
+                    };
+
+                    BN.prototype.notn = function notn(width) {
+                        return this.clone().inotn(width);
+                    };
+
+                    // Set `bit` of `this`
+                    BN.prototype.setn = function setn(bit, val) {
+                        assert(typeof bit === 'number' && bit >= 0);
+
+                        var off = (bit / 26) | 0;
+                        var wbit = bit % 26;
+
+                        this._expand(off + 1);
+
+                        if (val) {
+                            this.words[off] = this.words[off] | (1 << wbit);
+                        } else {
+                            this.words[off] = this.words[off] & ~(1 << wbit);
+                        }
+
+                        return this.strip();
+                    };
+
+                    // Add `num` to `this` in-place
+                    BN.prototype.iadd = function iadd(num) {
+                        var r;
+
+                        // negative + positive
+                        if (this.negative !== 0 && num.negative === 0) {
+                            this.negative = 0;
+                            r = this.isub(num);
+                            this.negative ^= 1;
+                            return this._normSign();
+
+                            // positive + negative
+                        } else if (this.negative === 0 && num.negative !== 0) {
+                            num.negative = 0;
+                            r = this.isub(num);
+                            num.negative = 1;
+                            return r._normSign();
+                        }
+
+                        // a.length > b.length
+                        var a, b;
+                        if (this.length > num.length) {
+                            a = this;
+                            b = num;
+                        } else {
+                            a = num;
+                            b = this;
+                        }
+
+                        var carry = 0;
+                        for (var i = 0; i < b.length; i++) {
+                            r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
+                            this.words[i] = r & 0x3ffffff;
+                            carry = r >>> 26;
+                        }
+                        for (; carry !== 0 && i < a.length; i++) {
+                            r = (a.words[i] | 0) + carry;
+                            this.words[i] = r & 0x3ffffff;
+                            carry = r >>> 26;
+                        }
+
+                        this.length = a.length;
+                        if (carry !== 0) {
+                            this.words[this.length] = carry;
+                            this.length++;
+                            // Copy the rest of the words
+                        } else if (a !== this) {
+                            for (; i < a.length; i++) {
+                                this.words[i] = a.words[i];
+                            }
+                        }
+
+                        return this;
+                    };
+
+                    // Add `num` to `this`
+                    BN.prototype.add = function add(num) {
+                        var res;
+                        if (num.negative !== 0 && this.negative === 0) {
+                            num.negative = 0;
+                            res = this.sub(num);
+                            num.negative ^= 1;
+                            return res;
+                        } else if (num.negative === 0 && this.negative !== 0) {
+                            this.negative = 0;
+                            res = num.sub(this);
+                            this.negative = 1;
+                            return res;
+                        }
+
+                        if (this.length > num.length) return this.clone().iadd(num);
+
+                        return num.clone().iadd(this);
+                    };
+
+                    // Subtract `num` from `this` in-place
+                    BN.prototype.isub = function isub(num) {
+                        // this - (-num) = this + num
+                        if (num.negative !== 0) {
+                            num.negative = 0;
+                            var r = this.iadd(num);
+                            num.negative = 1;
+                            return r._normSign();
+
+                            // -this - num = -(this + num)
+                        } else if (this.negative !== 0) {
+                            this.negative = 0;
+                            this.iadd(num);
+                            this.negative = 1;
+                            return this._normSign();
+                        }
+
+                        // At this point both numbers are positive
+                        var cmp = this.cmp(num);
+
+                        // Optimization - zeroify
+                        if (cmp === 0) {
+                            this.negative = 0;
+                            this.length = 1;
+                            this.words[0] = 0;
+                            return this;
+                        }
+
+                        // a > b
+                        var a, b;
+                        if (cmp > 0) {
+                            a = this;
+                            b = num;
+                        } else {
+                            a = num;
+                            b = this;
+                        }
+
+                        var carry = 0;
+                        for (var i = 0; i < b.length; i++) {
+                            r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
+                            carry = r >> 26;
+                            this.words[i] = r & 0x3ffffff;
+                        }
+                        for (; carry !== 0 && i < a.length; i++) {
+                            r = (a.words[i] | 0) + carry;
+                            carry = r >> 26;
+                            this.words[i] = r & 0x3ffffff;
+                        }
+
+                        // Copy rest of the words
+                        if (carry === 0 && i < a.length && a !== this) {
+                            for (; i < a.length; i++) {
+                                this.words[i] = a.words[i];
+                            }
+                        }
+
+                        this.length = Math.max(this.length, i);
+
+                        if (a !== this) {
+                            this.negative = 1;
+                        }
+
+                        return this.strip();
+                    };
+
+                    // Subtract `num` from `this`
+                    BN.prototype.sub = function sub(num) {
+                        return this.clone().isub(num);
+                    };
+
+                    function smallMulTo(self, num, out) {
+                        out.negative = num.negative ^ self.negative;
+                        var len = (self.length + num.length) | 0;
+                        out.length = len;
+                        len = (len - 1) | 0;
+
+                        // Peel one iteration (compiler can't do it, because of code complexity)
+                        var a = self.words[0] | 0;
+                        var b = num.words[0] | 0;
+                        var r = a * b;
+
+                        var lo = r & 0x3ffffff;
+                        var carry = (r / 0x4000000) | 0;
+                        out.words[0] = lo;
+
+                        for (var k = 1; k < len; k++) {
+                            // Sum all words with the same `i + j = k` and accumulate `ncarry`,
+                            // note that ncarry could be >= 0x3ffffff
+                            var ncarry = carry >>> 26;
+                            var rword = carry & 0x3ffffff;
+                            var maxJ = Math.min(k, num.length - 1);
+                            for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+                                var i = (k - j) | 0;
+                                a = self.words[i] | 0;
+                                b = num.words[j] | 0;
+                                r = a * b + rword;
+                                ncarry += (r / 0x4000000) | 0;
+                                rword = r & 0x3ffffff;
+                            }
+                            out.words[k] = rword | 0;
+                            carry = ncarry | 0;
+                        }
+                        if (carry !== 0) {
+                            out.words[k] = carry | 0;
+                        } else {
+                            out.length--;
+                        }
+
+                        return out.strip();
+                    }
+
+                    // TODO(indutny): it may be reasonable to omit it for users who don't need
+                    // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
+                    // multiplication (like elliptic secp256k1).
+                    var comb10MulTo = function comb10MulTo(self, num, out) {
+                        var a = self.words;
+                        var b = num.words;
+                        var o = out.words;
+                        var c = 0;
+                        var lo;
+                        var mid;
+                        var hi;
+                        var a0 = a[0] | 0;
+                        var al0 = a0 & 0x1fff;
+                        var ah0 = a0 >>> 13;
+                        var a1 = a[1] | 0;
+                        var al1 = a1 & 0x1fff;
+                        var ah1 = a1 >>> 13;
+                        var a2 = a[2] | 0;
+                        var al2 = a2 & 0x1fff;
+                        var ah2 = a2 >>> 13;
+                        var a3 = a[3] | 0;
+                        var al3 = a3 & 0x1fff;
+                        var ah3 = a3 >>> 13;
+                        var a4 = a[4] | 0;
+                        var al4 = a4 & 0x1fff;
+                        var ah4 = a4 >>> 13;
+                        var a5 = a[5] | 0;
+                        var al5 = a5 & 0x1fff;
+                        var ah5 = a5 >>> 13;
+                        var a6 = a[6] | 0;
+                        var al6 = a6 & 0x1fff;
+                        var ah6 = a6 >>> 13;
+                        var a7 = a[7] | 0;
+                        var al7 = a7 & 0x1fff;
+                        var ah7 = a7 >>> 13;
+                        var a8 = a[8] | 0;
+                        var al8 = a8 & 0x1fff;
+                        var ah8 = a8 >>> 13;
+                        var a9 = a[9] | 0;
+                        var al9 = a9 & 0x1fff;
+                        var ah9 = a9 >>> 13;
+                        var b0 = b[0] | 0;
+                        var bl0 = b0 & 0x1fff;
+                        var bh0 = b0 >>> 13;
+                        var b1 = b[1] | 0;
+                        var bl1 = b1 & 0x1fff;
+                        var bh1 = b1 >>> 13;
+                        var b2 = b[2] | 0;
+                        var bl2 = b2 & 0x1fff;
+                        var bh2 = b2 >>> 13;
+                        var b3 = b[3] | 0;
+                        var bl3 = b3 & 0x1fff;
+                        var bh3 = b3 >>> 13;
+                        var b4 = b[4] | 0;
+                        var bl4 = b4 & 0x1fff;
+                        var bh4 = b4 >>> 13;
+                        var b5 = b[5] | 0;
+                        var bl5 = b5 & 0x1fff;
+                        var bh5 = b5 >>> 13;
+                        var b6 = b[6] | 0;
+                        var bl6 = b6 & 0x1fff;
+                        var bh6 = b6 >>> 13;
+                        var b7 = b[7] | 0;
+                        var bl7 = b7 & 0x1fff;
+                        var bh7 = b7 >>> 13;
+                        var b8 = b[8] | 0;
+                        var bl8 = b8 & 0x1fff;
+                        var bh8 = b8 >>> 13;
+                        var b9 = b[9] | 0;
+                        var bl9 = b9 & 0x1fff;
+                        var bh9 = b9 >>> 13;
+
+                        out.negative = self.negative ^ num.negative;
+                        out.length = 19;
+                        /* k = 0 */
+                        lo = Math.imul(al0, bl0);
+                        mid = Math.imul(al0, bh0);
+                        mid = (mid + Math.imul(ah0, bl0)) | 0;
+                        hi = Math.imul(ah0, bh0);
+                        var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;
+                        w0 &= 0x3ffffff;
+                        /* k = 1 */
+                        lo = Math.imul(al1, bl0);
+                        mid = Math.imul(al1, bh0);
+                        mid = (mid + Math.imul(ah1, bl0)) | 0;
+                        hi = Math.imul(ah1, bh0);
+                        lo = (lo + Math.imul(al0, bl1)) | 0;
+                        mid = (mid + Math.imul(al0, bh1)) | 0;
+                        mid = (mid + Math.imul(ah0, bl1)) | 0;
+                        hi = (hi + Math.imul(ah0, bh1)) | 0;
+                        var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;
+                        w1 &= 0x3ffffff;
+                        /* k = 2 */
+                        lo = Math.imul(al2, bl0);
+                        mid = Math.imul(al2, bh0);
+                        mid = (mid + Math.imul(ah2, bl0)) | 0;
+                        hi = Math.imul(ah2, bh0);
+                        lo = (lo + Math.imul(al1, bl1)) | 0;
+                        mid = (mid + Math.imul(al1, bh1)) | 0;
+                        mid = (mid + Math.imul(ah1, bl1)) | 0;
+                        hi = (hi + Math.imul(ah1, bh1)) | 0;
+                        lo = (lo + Math.imul(al0, bl2)) | 0;
+                        mid = (mid + Math.imul(al0, bh2)) | 0;
+                        mid = (mid + Math.imul(ah0, bl2)) | 0;
+                        hi = (hi + Math.imul(ah0, bh2)) | 0;
+                        var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;
+                        w2 &= 0x3ffffff;
+                        /* k = 3 */
+                        lo = Math.imul(al3, bl0);
+                        mid = Math.imul(al3, bh0);
+                        mid = (mid + Math.imul(ah3, bl0)) | 0;
+                        hi = Math.imul(ah3, bh0);
+                        lo = (lo + Math.imul(al2, bl1)) | 0;
+                        mid = (mid + Math.imul(al2, bh1)) | 0;
+                        mid = (mid + Math.imul(ah2, bl1)) | 0;
+                        hi = (hi + Math.imul(ah2, bh1)) | 0;
+                        lo = (lo + Math.imul(al1, bl2)) | 0;
+                        mid = (mid + Math.imul(al1, bh2)) | 0;
+                        mid = (mid + Math.imul(ah1, bl2)) | 0;
+                        hi = (hi + Math.imul(ah1, bh2)) | 0;
+                        lo = (lo + Math.imul(al0, bl3)) | 0;
+                        mid = (mid + Math.imul(al0, bh3)) | 0;
+                        mid = (mid + Math.imul(ah0, bl3)) | 0;
+                        hi = (hi + Math.imul(ah0, bh3)) | 0;
+                        var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;
+                        w3 &= 0x3ffffff;
+                        /* k = 4 */
+                        lo = Math.imul(al4, bl0);
+                        mid = Math.imul(al4, bh0);
+                        mid = (mid + Math.imul(ah4, bl0)) | 0;
+                        hi = Math.imul(ah4, bh0);
+                        lo = (lo + Math.imul(al3, bl1)) | 0;
+                        mid = (mid + Math.imul(al3, bh1)) | 0;
+                        mid = (mid + Math.imul(ah3, bl1)) | 0;
+                        hi = (hi + Math.imul(ah3, bh1)) | 0;
+                        lo = (lo + Math.imul(al2, bl2)) | 0;
+                        mid = (mid + Math.imul(al2, bh2)) | 0;
+                        mid = (mid + Math.imul(ah2, bl2)) | 0;
+                        hi = (hi + Math.imul(ah2, bh2)) | 0;
+                        lo = (lo + Math.imul(al1, bl3)) | 0;
+                        mid = (mid + Math.imul(al1, bh3)) | 0;
+                        mid = (mid + Math.imul(ah1, bl3)) | 0;
+                        hi = (hi + Math.imul(ah1, bh3)) | 0;
+                        lo = (lo + Math.imul(al0, bl4)) | 0;
+                        mid = (mid + Math.imul(al0, bh4)) | 0;
+                        mid = (mid + Math.imul(ah0, bl4)) | 0;
+                        hi = (hi + Math.imul(ah0, bh4)) | 0;
+                        var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;
+                        w4 &= 0x3ffffff;
+                        /* k = 5 */
+                        lo = Math.imul(al5, bl0);
+                        mid = Math.imul(al5, bh0);
+                        mid = (mid + Math.imul(ah5, bl0)) | 0;
+                        hi = Math.imul(ah5, bh0);
+                        lo = (lo + Math.imul(al4, bl1)) | 0;
+                        mid = (mid + Math.imul(al4, bh1)) | 0;
+                        mid = (mid + Math.imul(ah4, bl1)) | 0;
+                        hi = (hi + Math.imul(ah4, bh1)) | 0;
+                        lo = (lo + Math.imul(al3, bl2)) | 0;
+                        mid = (mid + Math.imul(al3, bh2)) | 0;
+                        mid = (mid + Math.imul(ah3, bl2)) | 0;
+                        hi = (hi + Math.imul(ah3, bh2)) | 0;
+                        lo = (lo + Math.imul(al2, bl3)) | 0;
+                        mid = (mid + Math.imul(al2, bh3)) | 0;
+                        mid = (mid + Math.imul(ah2, bl3)) | 0;
+                        hi = (hi + Math.imul(ah2, bh3)) | 0;
+                        lo = (lo + Math.imul(al1, bl4)) | 0;
+                        mid = (mid + Math.imul(al1, bh4)) | 0;
+                        mid = (mid + Math.imul(ah1, bl4)) | 0;
+                        hi = (hi + Math.imul(ah1, bh4)) | 0;
+                        lo = (lo + Math.imul(al0, bl5)) | 0;
+                        mid = (mid + Math.imul(al0, bh5)) | 0;
+                        mid = (mid + Math.imul(ah0, bl5)) | 0;
+                        hi = (hi + Math.imul(ah0, bh5)) | 0;
+                        var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;
+                        w5 &= 0x3ffffff;
+                        /* k = 6 */
+                        lo = Math.imul(al6, bl0);
+                        mid = Math.imul(al6, bh0);
+                        mid = (mid + Math.imul(ah6, bl0)) | 0;
+                        hi = Math.imul(ah6, bh0);
+                        lo = (lo + Math.imul(al5, bl1)) | 0;
+                        mid = (mid + Math.imul(al5, bh1)) | 0;
+                        mid = (mid + Math.imul(ah5, bl1)) | 0;
+                        hi = (hi + Math.imul(ah5, bh1)) | 0;
+                        lo = (lo + Math.imul(al4, bl2)) | 0;
+                        mid = (mid + Math.imul(al4, bh2)) | 0;
+                        mid = (mid + Math.imul(ah4, bl2)) | 0;
+                        hi = (hi + Math.imul(ah4, bh2)) | 0;
+                        lo = (lo + Math.imul(al3, bl3)) | 0;
+                        mid = (mid + Math.imul(al3, bh3)) | 0;
+                        mid = (mid + Math.imul(ah3, bl3)) | 0;
+                        hi = (hi + Math.imul(ah3, bh3)) | 0;
+                        lo = (lo + Math.imul(al2, bl4)) | 0;
+                        mid = (mid + Math.imul(al2, bh4)) | 0;
+                        mid = (mid + Math.imul(ah2, bl4)) | 0;
+                        hi = (hi + Math.imul(ah2, bh4)) | 0;
+                        lo = (lo + Math.imul(al1, bl5)) | 0;
+                        mid = (mid + Math.imul(al1, bh5)) | 0;
+                        mid = (mid + Math.imul(ah1, bl5)) | 0;
+                        hi = (hi + Math.imul(ah1, bh5)) | 0;
+                        lo = (lo + Math.imul(al0, bl6)) | 0;
+                        mid = (mid + Math.imul(al0, bh6)) | 0;
+                        mid = (mid + Math.imul(ah0, bl6)) | 0;
+                        hi = (hi + Math.imul(ah0, bh6)) | 0;
+                        var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;
+                        w6 &= 0x3ffffff;
+                        /* k = 7 */
+                        lo = Math.imul(al7, bl0);
+                        mid = Math.imul(al7, bh0);
+                        mid = (mid + Math.imul(ah7, bl0)) | 0;
+                        hi = Math.imul(ah7, bh0);
+                        lo = (lo + Math.imul(al6, bl1)) | 0;
+                        mid = (mid + Math.imul(al6, bh1)) | 0;
+                        mid = (mid + Math.imul(ah6, bl1)) | 0;
+                        hi = (hi + Math.imul(ah6, bh1)) | 0;
+                        lo = (lo + Math.imul(al5, bl2)) | 0;
+                        mid = (mid + Math.imul(al5, bh2)) | 0;
+                        mid = (mid + Math.imul(ah5, bl2)) | 0;
+                        hi = (hi + Math.imul(ah5, bh2)) | 0;
+                        lo = (lo + Math.imul(al4, bl3)) | 0;
+                        mid = (mid + Math.imul(al4, bh3)) | 0;
+                        mid = (mid + Math.imul(ah4, bl3)) | 0;
+                        hi = (hi + Math.imul(ah4, bh3)) | 0;
+                        lo = (lo + Math.imul(al3, bl4)) | 0;
+                        mid = (mid + Math.imul(al3, bh4)) | 0;
+                        mid = (mid + Math.imul(ah3, bl4)) | 0;
+                        hi = (hi + Math.imul(ah3, bh4)) | 0;
+                        lo = (lo + Math.imul(al2, bl5)) | 0;
+                        mid = (mid + Math.imul(al2, bh5)) | 0;
+                        mid = (mid + Math.imul(ah2, bl5)) | 0;
+                        hi = (hi + Math.imul(ah2, bh5)) | 0;
+                        lo = (lo + Math.imul(al1, bl6)) | 0;
+                        mid = (mid + Math.imul(al1, bh6)) | 0;
+                        mid = (mid + Math.imul(ah1, bl6)) | 0;
+                        hi = (hi + Math.imul(ah1, bh6)) | 0;
+                        lo = (lo + Math.imul(al0, bl7)) | 0;
+                        mid = (mid + Math.imul(al0, bh7)) | 0;
+                        mid = (mid + Math.imul(ah0, bl7)) | 0;
+                        hi = (hi + Math.imul(ah0, bh7)) | 0;
+                        var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;
+                        w7 &= 0x3ffffff;
+                        /* k = 8 */
+                        lo = Math.imul(al8, bl0);
+                        mid = Math.imul(al8, bh0);
+                        mid = (mid + Math.imul(ah8, bl0)) | 0;
+                        hi = Math.imul(ah8, bh0);
+                        lo = (lo + Math.imul(al7, bl1)) | 0;
+                        mid = (mid + Math.imul(al7, bh1)) | 0;
+                        mid = (mid + Math.imul(ah7, bl1)) | 0;
+                        hi = (hi + Math.imul(ah7, bh1)) | 0;
+                        lo = (lo + Math.imul(al6, bl2)) | 0;
+                        mid = (mid + Math.imul(al6, bh2)) | 0;
+                        mid = (mid + Math.imul(ah6, bl2)) | 0;
+                        hi = (hi + Math.imul(ah6, bh2)) | 0;
+                        lo = (lo + Math.imul(al5, bl3)) | 0;
+                        mid = (mid + Math.imul(al5, bh3)) | 0;
+                        mid = (mid + Math.imul(ah5, bl3)) | 0;
+                        hi = (hi + Math.imul(ah5, bh3)) | 0;
+                        lo = (lo + Math.imul(al4, bl4)) | 0;
+                        mid = (mid + Math.imul(al4, bh4)) | 0;
+                        mid = (mid + Math.imul(ah4, bl4)) | 0;
+                        hi = (hi + Math.imul(ah4, bh4)) | 0;
+                        lo = (lo + Math.imul(al3, bl5)) | 0;
+                        mid = (mid + Math.imul(al3, bh5)) | 0;
+                        mid = (mid + Math.imul(ah3, bl5)) | 0;
+                        hi = (hi + Math.imul(ah3, bh5)) | 0;
+                        lo = (lo + Math.imul(al2, bl6)) | 0;
+                        mid = (mid + Math.imul(al2, bh6)) | 0;
+                        mid = (mid + Math.imul(ah2, bl6)) | 0;
+                        hi = (hi + Math.imul(ah2, bh6)) | 0;
+                        lo = (lo + Math.imul(al1, bl7)) | 0;
+                        mid = (mid + Math.imul(al1, bh7)) | 0;
+                        mid = (mid + Math.imul(ah1, bl7)) | 0;
+                        hi = (hi + Math.imul(ah1, bh7)) | 0;
+                        lo = (lo + Math.imul(al0, bl8)) | 0;
+                        mid = (mid + Math.imul(al0, bh8)) | 0;
+                        mid = (mid + Math.imul(ah0, bl8)) | 0;
+                        hi = (hi + Math.imul(ah0, bh8)) | 0;
+                        var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;
+                        w8 &= 0x3ffffff;
+                        /* k = 9 */
+                        lo = Math.imul(al9, bl0);
+                        mid = Math.imul(al9, bh0);
+                        mid = (mid + Math.imul(ah9, bl0)) | 0;
+                        hi = Math.imul(ah9, bh0);
+                        lo = (lo + Math.imul(al8, bl1)) | 0;
+                        mid = (mid + Math.imul(al8, bh1)) | 0;
+                        mid = (mid + Math.imul(ah8, bl1)) | 0;
+                        hi = (hi + Math.imul(ah8, bh1)) | 0;
+                        lo = (lo + Math.imul(al7, bl2)) | 0;
+                        mid = (mid + Math.imul(al7, bh2)) | 0;
+                        mid = (mid + Math.imul(ah7, bl2)) | 0;
+                        hi = (hi + Math.imul(ah7, bh2)) | 0;
+                        lo = (lo + Math.imul(al6, bl3)) | 0;
+                        mid = (mid + Math.imul(al6, bh3)) | 0;
+                        mid = (mid + Math.imul(ah6, bl3)) | 0;
+                        hi = (hi + Math.imul(ah6, bh3)) | 0;
+                        lo = (lo + Math.imul(al5, bl4)) | 0;
+                        mid = (mid + Math.imul(al5, bh4)) | 0;
+                        mid = (mid + Math.imul(ah5, bl4)) | 0;
+                        hi = (hi + Math.imul(ah5, bh4)) | 0;
+                        lo = (lo + Math.imul(al4, bl5)) | 0;
+                        mid = (mid + Math.imul(al4, bh5)) | 0;
+                        mid = (mid + Math.imul(ah4, bl5)) | 0;
+                        hi = (hi + Math.imul(ah4, bh5)) | 0;
+                        lo = (lo + Math.imul(al3, bl6)) | 0;
+                        mid = (mid + Math.imul(al3, bh6)) | 0;
+                        mid = (mid + Math.imul(ah3, bl6)) | 0;
+                        hi = (hi + Math.imul(ah3, bh6)) | 0;
+                        lo = (lo + Math.imul(al2, bl7)) | 0;
+                        mid = (mid + Math.imul(al2, bh7)) | 0;
+                        mid = (mid + Math.imul(ah2, bl7)) | 0;
+                        hi = (hi + Math.imul(ah2, bh7)) | 0;
+                        lo = (lo + Math.imul(al1, bl8)) | 0;
+                        mid = (mid + Math.imul(al1, bh8)) | 0;
+                        mid = (mid + Math.imul(ah1, bl8)) | 0;
+                        hi = (hi + Math.imul(ah1, bh8)) | 0;
+                        lo = (lo + Math.imul(al0, bl9)) | 0;
+                        mid = (mid + Math.imul(al0, bh9)) | 0;
+                        mid = (mid + Math.imul(ah0, bl9)) | 0;
+                        hi = (hi + Math.imul(ah0, bh9)) | 0;
+                        var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;
+                        w9 &= 0x3ffffff;
+                        /* k = 10 */
+                        lo = Math.imul(al9, bl1);
+                        mid = Math.imul(al9, bh1);
+                        mid = (mid + Math.imul(ah9, bl1)) | 0;
+                        hi = Math.imul(ah9, bh1);
+                        lo = (lo + Math.imul(al8, bl2)) | 0;
+                        mid = (mid + Math.imul(al8, bh2)) | 0;
+                        mid = (mid + Math.imul(ah8, bl2)) | 0;
+                        hi = (hi + Math.imul(ah8, bh2)) | 0;
+                        lo = (lo + Math.imul(al7, bl3)) | 0;
+                        mid = (mid + Math.imul(al7, bh3)) | 0;
+                        mid = (mid + Math.imul(ah7, bl3)) | 0;
+                        hi = (hi + Math.imul(ah7, bh3)) | 0;
+                        lo = (lo + Math.imul(al6, bl4)) | 0;
+                        mid = (mid + Math.imul(al6, bh4)) | 0;
+                        mid = (mid + Math.imul(ah6, bl4)) | 0;
+                        hi = (hi + Math.imul(ah6, bh4)) | 0;
+                        lo = (lo + Math.imul(al5, bl5)) | 0;
+                        mid = (mid + Math.imul(al5, bh5)) | 0;
+                        mid = (mid + Math.imul(ah5, bl5)) | 0;
+                        hi = (hi + Math.imul(ah5, bh5)) | 0;
+                        lo = (lo + Math.imul(al4, bl6)) | 0;
+                        mid = (mid + Math.imul(al4, bh6)) | 0;
+                        mid = (mid + Math.imul(ah4, bl6)) | 0;
+                        hi = (hi + Math.imul(ah4, bh6)) | 0;
+                        lo = (lo + Math.imul(al3, bl7)) | 0;
+                        mid = (mid + Math.imul(al3, bh7)) | 0;
+                        mid = (mid + Math.imul(ah3, bl7)) | 0;
+                        hi = (hi + Math.imul(ah3, bh7)) | 0;
+                        lo = (lo + Math.imul(al2, bl8)) | 0;
+                        mid = (mid + Math.imul(al2, bh8)) | 0;
+                        mid = (mid + Math.imul(ah2, bl8)) | 0;
+                        hi = (hi + Math.imul(ah2, bh8)) | 0;
+                        lo = (lo + Math.imul(al1, bl9)) | 0;
+                        mid = (mid + Math.imul(al1, bh9)) | 0;
+                        mid = (mid + Math.imul(ah1, bl9)) | 0;
+                        hi = (hi + Math.imul(ah1, bh9)) | 0;
+                        var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;
+                        w10 &= 0x3ffffff;
+                        /* k = 11 */
+                        lo = Math.imul(al9, bl2);
+                        mid = Math.imul(al9, bh2);
+                        mid = (mid + Math.imul(ah9, bl2)) | 0;
+                        hi = Math.imul(ah9, bh2);
+                        lo = (lo + Math.imul(al8, bl3)) | 0;
+                        mid = (mid + Math.imul(al8, bh3)) | 0;
+                        mid = (mid + Math.imul(ah8, bl3)) | 0;
+                        hi = (hi + Math.imul(ah8, bh3)) | 0;
+                        lo = (lo + Math.imul(al7, bl4)) | 0;
+                        mid = (mid + Math.imul(al7, bh4)) | 0;
+                        mid = (mid + Math.imul(ah7, bl4)) | 0;
+                        hi = (hi + Math.imul(ah7, bh4)) | 0;
+                        lo = (lo + Math.imul(al6, bl5)) | 0;
+                        mid = (mid + Math.imul(al6, bh5)) | 0;
+                        mid = (mid + Math.imul(ah6, bl5)) | 0;
+                        hi = (hi + Math.imul(ah6, bh5)) | 0;
+                        lo = (lo + Math.imul(al5, bl6)) | 0;
+                        mid = (mid + Math.imul(al5, bh6)) | 0;
+                        mid = (mid + Math.imul(ah5, bl6)) | 0;
+                        hi = (hi + Math.imul(ah5, bh6)) | 0;
+                        lo = (lo + Math.imul(al4, bl7)) | 0;
+                        mid = (mid + Math.imul(al4, bh7)) | 0;
+                        mid = (mid + Math.imul(ah4, bl7)) | 0;
+                        hi = (hi + Math.imul(ah4, bh7)) | 0;
+                        lo = (lo + Math.imul(al3, bl8)) | 0;
+                        mid = (mid + Math.imul(al3, bh8)) | 0;
+                        mid = (mid + Math.imul(ah3, bl8)) | 0;
+                        hi = (hi + Math.imul(ah3, bh8)) | 0;
+                        lo = (lo + Math.imul(al2, bl9)) | 0;
+                        mid = (mid + Math.imul(al2, bh9)) | 0;
+                        mid = (mid + Math.imul(ah2, bl9)) | 0;
+                        hi = (hi + Math.imul(ah2, bh9)) | 0;
+                        var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;
+                        w11 &= 0x3ffffff;
+                        /* k = 12 */
+                        lo = Math.imul(al9, bl3);
+                        mid = Math.imul(al9, bh3);
+                        mid = (mid + Math.imul(ah9, bl3)) | 0;
+                        hi = Math.imul(ah9, bh3);
+                        lo = (lo + Math.imul(al8, bl4)) | 0;
+                        mid = (mid + Math.imul(al8, bh4)) | 0;
+                        mid = (mid + Math.imul(ah8, bl4)) | 0;
+                        hi = (hi + Math.imul(ah8, bh4)) | 0;
+                        lo = (lo + Math.imul(al7, bl5)) | 0;
+                        mid = (mid + Math.imul(al7, bh5)) | 0;
+                        mid = (mid + Math.imul(ah7, bl5)) | 0;
+                        hi = (hi + Math.imul(ah7, bh5)) | 0;
+                        lo = (lo + Math.imul(al6, bl6)) | 0;
+                        mid = (mid + Math.imul(al6, bh6)) | 0;
+                        mid = (mid + Math.imul(ah6, bl6)) | 0;
+                        hi = (hi + Math.imul(ah6, bh6)) | 0;
+                        lo = (lo + Math.imul(al5, bl7)) | 0;
+                        mid = (mid + Math.imul(al5, bh7)) | 0;
+                        mid = (mid + Math.imul(ah5, bl7)) | 0;
+                        hi = (hi + Math.imul(ah5, bh7)) | 0;
+                        lo = (lo + Math.imul(al4, bl8)) | 0;
+                        mid = (mid + Math.imul(al4, bh8)) | 0;
+                        mid = (mid + Math.imul(ah4, bl8)) | 0;
+                        hi = (hi + Math.imul(ah4, bh8)) | 0;
+                        lo = (lo + Math.imul(al3, bl9)) | 0;
+                        mid = (mid + Math.imul(al3, bh9)) | 0;
+                        mid = (mid + Math.imul(ah3, bl9)) | 0;
+                        hi = (hi + Math.imul(ah3, bh9)) | 0;
+                        var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;
+                        w12 &= 0x3ffffff;
+                        /* k = 13 */
+                        lo = Math.imul(al9, bl4);
+                        mid = Math.imul(al9, bh4);
+                        mid = (mid + Math.imul(ah9, bl4)) | 0;
+                        hi = Math.imul(ah9, bh4);
+                        lo = (lo + Math.imul(al8, bl5)) | 0;
+                        mid = (mid + Math.imul(al8, bh5)) | 0;
+                        mid = (mid + Math.imul(ah8, bl5)) | 0;
+                        hi = (hi + Math.imul(ah8, bh5)) | 0;
+                        lo = (lo + Math.imul(al7, bl6)) | 0;
+                        mid = (mid + Math.imul(al7, bh6)) | 0;
+                        mid = (mid + Math.imul(ah7, bl6)) | 0;
+                        hi = (hi + Math.imul(ah7, bh6)) | 0;
+                        lo = (lo + Math.imul(al6, bl7)) | 0;
+                        mid = (mid + Math.imul(al6, bh7)) | 0;
+                        mid = (mid + Math.imul(ah6, bl7)) | 0;
+                        hi = (hi + Math.imul(ah6, bh7)) | 0;
+                        lo = (lo + Math.imul(al5, bl8)) | 0;
+                        mid = (mid + Math.imul(al5, bh8)) | 0;
+                        mid = (mid + Math.imul(ah5, bl8)) | 0;
+                        hi = (hi + Math.imul(ah5, bh8)) | 0;
+                        lo = (lo + Math.imul(al4, bl9)) | 0;
+                        mid = (mid + Math.imul(al4, bh9)) | 0;
+                        mid = (mid + Math.imul(ah4, bl9)) | 0;
+                        hi = (hi + Math.imul(ah4, bh9)) | 0;
+                        var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;
+                        w13 &= 0x3ffffff;
+                        /* k = 14 */
+                        lo = Math.imul(al9, bl5);
+                        mid = Math.imul(al9, bh5);
+                        mid = (mid + Math.imul(ah9, bl5)) | 0;
+                        hi = Math.imul(ah9, bh5);
+                        lo = (lo + Math.imul(al8, bl6)) | 0;
+                        mid = (mid + Math.imul(al8, bh6)) | 0;
+                        mid = (mid + Math.imul(ah8, bl6)) | 0;
+                        hi = (hi + Math.imul(ah8, bh6)) | 0;
+                        lo = (lo + Math.imul(al7, bl7)) | 0;
+                        mid = (mid + Math.imul(al7, bh7)) | 0;
+                        mid = (mid + Math.imul(ah7, bl7)) | 0;
+                        hi = (hi + Math.imul(ah7, bh7)) | 0;
+                        lo = (lo + Math.imul(al6, bl8)) | 0;
+                        mid = (mid + Math.imul(al6, bh8)) | 0;
+                        mid = (mid + Math.imul(ah6, bl8)) | 0;
+                        hi = (hi + Math.imul(ah6, bh8)) | 0;
+                        lo = (lo + Math.imul(al5, bl9)) | 0;
+                        mid = (mid + Math.imul(al5, bh9)) | 0;
+                        mid = (mid + Math.imul(ah5, bl9)) | 0;
+                        hi = (hi + Math.imul(ah5, bh9)) | 0;
+                        var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;
+                        w14 &= 0x3ffffff;
+                        /* k = 15 */
+                        lo = Math.imul(al9, bl6);
+                        mid = Math.imul(al9, bh6);
+                        mid = (mid + Math.imul(ah9, bl6)) | 0;
+                        hi = Math.imul(ah9, bh6);
+                        lo = (lo + Math.imul(al8, bl7)) | 0;
+                        mid = (mid + Math.imul(al8, bh7)) | 0;
+                        mid = (mid + Math.imul(ah8, bl7)) | 0;
+                        hi = (hi + Math.imul(ah8, bh7)) | 0;
+                        lo = (lo + Math.imul(al7, bl8)) | 0;
+                        mid = (mid + Math.imul(al7, bh8)) | 0;
+                        mid = (mid + Math.imul(ah7, bl8)) | 0;
+                        hi = (hi + Math.imul(ah7, bh8)) | 0;
+                        lo = (lo + Math.imul(al6, bl9)) | 0;
+                        mid = (mid + Math.imul(al6, bh9)) | 0;
+                        mid = (mid + Math.imul(ah6, bl9)) | 0;
+                        hi = (hi + Math.imul(ah6, bh9)) | 0;
+                        var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;
+                        w15 &= 0x3ffffff;
+                        /* k = 16 */
+                        lo = Math.imul(al9, bl7);
+                        mid = Math.imul(al9, bh7);
+                        mid = (mid + Math.imul(ah9, bl7)) | 0;
+                        hi = Math.imul(ah9, bh7);
+                        lo = (lo + Math.imul(al8, bl8)) | 0;
+                        mid = (mid + Math.imul(al8, bh8)) | 0;
+                        mid = (mid + Math.imul(ah8, bl8)) | 0;
+                        hi = (hi + Math.imul(ah8, bh8)) | 0;
+                        lo = (lo + Math.imul(al7, bl9)) | 0;
+                        mid = (mid + Math.imul(al7, bh9)) | 0;
+                        mid = (mid + Math.imul(ah7, bl9)) | 0;
+                        hi = (hi + Math.imul(ah7, bh9)) | 0;
+                        var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;
+                        w16 &= 0x3ffffff;
+                        /* k = 17 */
+                        lo = Math.imul(al9, bl8);
+                        mid = Math.imul(al9, bh8);
+                        mid = (mid + Math.imul(ah9, bl8)) | 0;
+                        hi = Math.imul(ah9, bh8);
+                        lo = (lo + Math.imul(al8, bl9)) | 0;
+                        mid = (mid + Math.imul(al8, bh9)) | 0;
+                        mid = (mid + Math.imul(ah8, bl9)) | 0;
+                        hi = (hi + Math.imul(ah8, bh9)) | 0;
+                        var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;
+                        w17 &= 0x3ffffff;
+                        /* k = 18 */
+                        lo = Math.imul(al9, bl9);
+                        mid = Math.imul(al9, bh9);
+                        mid = (mid + Math.imul(ah9, bl9)) | 0;
+                        hi = Math.imul(ah9, bh9);
+                        var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+                        c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;
+                        w18 &= 0x3ffffff;
+                        o[0] = w0;
+                        o[1] = w1;
+                        o[2] = w2;
+                        o[3] = w3;
+                        o[4] = w4;
+                        o[5] = w5;
+                        o[6] = w6;
+                        o[7] = w7;
+                        o[8] = w8;
+                        o[9] = w9;
+                        o[10] = w10;
+                        o[11] = w11;
+                        o[12] = w12;
+                        o[13] = w13;
+                        o[14] = w14;
+                        o[15] = w15;
+                        o[16] = w16;
+                        o[17] = w17;
+                        o[18] = w18;
+                        if (c !== 0) {
+                            o[19] = c;
+                            out.length++;
+                        }
+                        return out;
+                    };
+
+                    // Polyfill comb
+                    if (!Math.imul) {
+                        comb10MulTo = smallMulTo;
+                    }
+
+                    function bigMulTo(self, num, out) {
+                        out.negative = num.negative ^ self.negative;
+                        out.length = self.length + num.length;
+
+                        var carry = 0;
+                        var hncarry = 0;
+                        for (var k = 0; k < out.length - 1; k++) {
+                            // Sum all words with the same `i + j = k` and accumulate `ncarry`,
+                            // note that ncarry could be >= 0x3ffffff
+                            var ncarry = hncarry;
+                            hncarry = 0;
+                            var rword = carry & 0x3ffffff;
+                            var maxJ = Math.min(k, num.length - 1);
+                            for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+                                var i = k - j;
+                                var a = self.words[i] | 0;
+                                var b = num.words[j] | 0;
+                                var r = a * b;
+
+                                var lo = r & 0x3ffffff;
+                                ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
+                                lo = (lo + rword) | 0;
+                                rword = lo & 0x3ffffff;
+                                ncarry = (ncarry + (lo >>> 26)) | 0;
+
+                                hncarry += ncarry >>> 26;
+                                ncarry &= 0x3ffffff;
+                            }
+                            out.words[k] = rword;
+                            carry = ncarry;
+                            ncarry = hncarry;
+                        }
+                        if (carry !== 0) {
+                            out.words[k] = carry;
+                        } else {
+                            out.length--;
+                        }
+
+                        return out.strip();
+                    }
+
+                    function jumboMulTo(self, num, out) {
+                        var fftm = new FFTM();
+                        return fftm.mulp(self, num, out);
+                    }
+
+                    BN.prototype.mulTo = function mulTo(num, out) {
+                        var res;
+                        var len = this.length + num.length;
+                        if (this.length === 10 && num.length === 10) {
+                            res = comb10MulTo(this, num, out);
+                        } else if (len < 63) {
+                            res = smallMulTo(this, num, out);
+                        } else if (len < 1024) {
+                            res = bigMulTo(this, num, out);
+                        } else {
+                            res = jumboMulTo(this, num, out);
+                        }
+
+                        return res;
+                    };
+
+                    // Cooley-Tukey algorithm for FFT
+                    // slightly revisited to rely on looping instead of recursion
+
+                    function FFTM(x, y) {
+                        this.x = x;
+                        this.y = y;
+                    }
+
+                    FFTM.prototype.makeRBT = function makeRBT(N) {
+                        var t = new Array(N);
+                        var l = BN.prototype._countBits(N) - 1;
+                        for (var i = 0; i < N; i++) {
+                            t[i] = this.revBin(i, l, N);
+                        }
+
+                        return t;
+                    };
+
+                    // Returns binary-reversed representation of `x`
+                    FFTM.prototype.revBin = function revBin(x, l, N) {
+                        if (x === 0 || x === N - 1) return x;
+
+                        var rb = 0;
+                        for (var i = 0; i < l; i++) {
+                            rb |= (x & 1) << (l - i - 1);
+                            x >>= 1;
+                        }
+
+                        return rb;
+                    };
+
+                    // Performs "tweedling" phase, therefore 'emulating'
+                    // behaviour of the recursive algorithm
+                    FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
+                        for (var i = 0; i < N; i++) {
+                            rtws[i] = rws[rbt[i]];
+                            itws[i] = iws[rbt[i]];
+                        }
+                    };
+
+                    FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
+                        this.permute(rbt, rws, iws, rtws, itws, N);
+
+                        for (var s = 1; s < N; s <<= 1) {
+                            var l = s << 1;
+
+                            var rtwdf = Math.cos(2 * Math.PI / l);
+                            var itwdf = Math.sin(2 * Math.PI / l);
+
+                            for (var p = 0; p < N; p += l) {
+                                var rtwdf_ = rtwdf;
+                                var itwdf_ = itwdf;
+
+                                for (var j = 0; j < s; j++) {
+                                    var re = rtws[p + j];
+                                    var ie = itws[p + j];
+
+                                    var ro = rtws[p + j + s];
+                                    var io = itws[p + j + s];
+
+                                    var rx = rtwdf_ * ro - itwdf_ * io;
+
+                                    io = rtwdf_ * io + itwdf_ * ro;
+                                    ro = rx;
+
+                                    rtws[p + j] = re + ro;
+                                    itws[p + j] = ie + io;
+
+                                    rtws[p + j + s] = re - ro;
+                                    itws[p + j + s] = ie - io;
+
+                                    /* jshint maxdepth : false */
+                                    if (j !== l) {
+                                        rx = rtwdf * rtwdf_ - itwdf * itwdf_;
+
+                                        itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
+                                        rtwdf_ = rx;
+                                    }
+                                }
+                            }
+                        }
+                    };
+
+                    FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
+                        var N = Math.max(m, n) | 1;
+                        var odd = N & 1;
+                        var i = 0;
+                        for (N = N / 2 | 0; N; N = N >>> 1) {
+                            i++;
+                        }
+
+                        return 1 << i + 1 + odd;
+                    };
+
+                    FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
+                        if (N <= 1) return;
+
+                        for (var i = 0; i < N / 2; i++) {
+                            var t = rws[i];
+
+                            rws[i] = rws[N - i - 1];
+                            rws[N - i - 1] = t;
+
+                            t = iws[i];
+
+                            iws[i] = -iws[N - i - 1];
+                            iws[N - i - 1] = -t;
+                        }
+                    };
+
+                    FFTM.prototype.normalize13b = function normalize13b(ws, N) {
+                        var carry = 0;
+                        for (var i = 0; i < N / 2; i++) {
+                            var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
+                                Math.round(ws[2 * i] / N) +
+                                carry;
+
+                            ws[i] = w & 0x3ffffff;
+
+                            if (w < 0x4000000) {
+                                carry = 0;
+                            } else {
+                                carry = w / 0x4000000 | 0;
+                            }
+                        }
+
+                        return ws;
+                    };
+
+                    FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
+                        var carry = 0;
+                        for (var i = 0; i < len; i++) {
+                            carry = carry + (ws[i] | 0);
+
+                            rws[2 * i] = carry & 0x1fff;
+                            carry = carry >>> 13;
+                            rws[2 * i + 1] = carry & 0x1fff;
+                            carry = carry >>> 13;
+                        }
+
+                        // Pad with zeroes
+                        for (i = 2 * len; i < N; ++i) {
+                            rws[i] = 0;
+                        }
+
+                        assert(carry === 0);
+                        assert((carry & ~0x1fff) === 0);
+                    };
+
+                    FFTM.prototype.stub = function stub(N) {
+                        var ph = new Array(N);
+                        for (var i = 0; i < N; i++) {
+                            ph[i] = 0;
+                        }
+
+                        return ph;
+                    };
+
+                    FFTM.prototype.mulp = function mulp(x, y, out) {
+                        var N = 2 * this.guessLen13b(x.length, y.length);
+
+                        var rbt = this.makeRBT(N);
+
+                        var _ = this.stub(N);
+
+                        var rws = new Array(N);
+                        var rwst = new Array(N);
+                        var iwst = new Array(N);
+
+                        var nrws = new Array(N);
+                        var nrwst = new Array(N);
+                        var niwst = new Array(N);
+
+                        var rmws = out.words;
+                        rmws.length = N;
+
+                        this.convert13b(x.words, x.length, rws, N);
+                        this.convert13b(y.words, y.length, nrws, N);
+
+                        this.transform(rws, _, rwst, iwst, N, rbt);
+                        this.transform(nrws, _, nrwst, niwst, N, rbt);
+
+                        for (var i = 0; i < N; i++) {
+                            var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
+                            iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
+                            rwst[i] = rx;
+                        }
+
+                        this.conjugate(rwst, iwst, N);
+                        this.transform(rwst, iwst, rmws, _, N, rbt);
+                        this.conjugate(rmws, _, N);
+                        this.normalize13b(rmws, N);
+
+                        out.negative = x.negative ^ y.negative;
+                        out.length = x.length + y.length;
+                        return out.strip();
+                    };
+
+                    // Multiply `this` by `num`
+                    BN.prototype.mul = function mul(num) {
+                        var out = new BN(null);
+                        out.words = new Array(this.length + num.length);
+                        return this.mulTo(num, out);
+                    };
+
+                    // Multiply employing FFT
+                    BN.prototype.mulf = function mulf(num) {
+                        var out = new BN(null);
+                        out.words = new Array(this.length + num.length);
+                        return jumboMulTo(this, num, out);
+                    };
+
+                    // In-place Multiplication
+                    BN.prototype.imul = function imul(num) {
+                        return this.clone().mulTo(num, this);
+                    };
+
+                    BN.prototype.imuln = function imuln(num) {
+                        assert(typeof num === 'number');
+                        assert(num < 0x4000000);
+
+                        // Carry
+                        var carry = 0;
+                        for (var i = 0; i < this.length; i++) {
+                            var w = (this.words[i] | 0) * num;
+                            var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
+                            carry >>= 26;
+                            carry += (w / 0x4000000) | 0;
+                            // NOTE: lo is 27bit maximum
+                            carry += lo >>> 26;
+                            this.words[i] = lo & 0x3ffffff;
+                        }
+
+                        if (carry !== 0) {
+                            this.words[i] = carry;
+                            this.length++;
+                        }
+
+                        return this;
+                    };
+
+                    BN.prototype.muln = function muln(num) {
+                        return this.clone().imuln(num);
+                    };
+
+                    // `this` * `this`
+                    BN.prototype.sqr = function sqr() {
+                        return this.mul(this);
+                    };
+
+                    // `this` * `this` in-place
+                    BN.prototype.isqr = function isqr() {
+                        return this.imul(this.clone());
+                    };
+
+                    // Math.pow(`this`, `num`)
+                    BN.prototype.pow = function pow(num) {
+                        var w = toBitArray(num);
+                        if (w.length === 0) return new BN(1);
+
+                        // Skip leading zeroes
+                        var res = this;
+                        for (var i = 0; i < w.length; i++, res = res.sqr()) {
+                            if (w[i] !== 0) break;
+                        }
+
+                        if (++i < w.length) {
+                            for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
+                                if (w[i] === 0) continue;
+
+                                res = res.mul(q);
+                            }
+                        }
+
+                        return res;
+                    };
+
+                    // Shift-left in-place
+                    BN.prototype.iushln = function iushln(bits) {
+                        assert(typeof bits === 'number' && bits >= 0);
+                        var r = bits % 26;
+                        var s = (bits - r) / 26;
+                        var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
+                        var i;
+
+                        if (r !== 0) {
+                            var carry = 0;
+
+                            for (i = 0; i < this.length; i++) {
+                                var newCarry = this.words[i] & carryMask;
+                                var c = ((this.words[i] | 0) - newCarry) << r;
+                                this.words[i] = c | carry;
+                                carry = newCarry >>> (26 - r);
+                            }
+
+                            if (carry) {
+                                this.words[i] = carry;
+                                this.length++;
+                            }
+                        }
+
+                        if (s !== 0) {
+                            for (i = this.length - 1; i >= 0; i--) {
+                                this.words[i + s] = this.words[i];
+                            }
+
+                            for (i = 0; i < s; i++) {
+                                this.words[i] = 0;
+                            }
+
+                            this.length += s;
+                        }
+
+                        return this.strip();
+                    };
+
+                    BN.prototype.ishln = function ishln(bits) {
+                        // TODO(indutny): implement me
+                        assert(this.negative === 0);
+                        return this.iushln(bits);
+                    };
+
+                    // Shift-right in-place
+                    // NOTE: `hint` is a lowest bit before trailing zeroes
+                    // NOTE: if `extended` is present - it will be filled with destroyed bits
+                    BN.prototype.iushrn = function iushrn(bits, hint, extended) {
+                        assert(typeof bits === 'number' && bits >= 0);
+                        var h;
+                        if (hint) {
+                            h = (hint - (hint % 26)) / 26;
+                        } else {
+                            h = 0;
+                        }
+
+                        var r = bits % 26;
+                        var s = Math.min((bits - r) / 26, this.length);
+                        var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+                        var maskedWords = extended;
+
+                        h -= s;
+                        h = Math.max(0, h);
+
+                        // Extended mode, copy masked part
+                        if (maskedWords) {
+                            for (var i = 0; i < s; i++) {
+                                maskedWords.words[i] = this.words[i];
+                            }
+                            maskedWords.length = s;
+                        }
+
+                        if (s === 0) {
+                            // No-op, we should not move anything at all
+                        } else if (this.length > s) {
+                            this.length -= s;
+                            for (i = 0; i < this.length; i++) {
+                                this.words[i] = this.words[i + s];
+                            }
+                        } else {
+                            this.words[0] = 0;
+                            this.length = 1;
+                        }
+
+                        var carry = 0;
+                        for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
+                            var word = this.words[i] | 0;
+                            this.words[i] = (carry << (26 - r)) | (word >>> r);
+                            carry = word & mask;
+                        }
+
+                        // Push carried bits as a mask
+                        if (maskedWords && carry !== 0) {
+                            maskedWords.words[maskedWords.length++] = carry;
+                        }
+
+                        if (this.length === 0) {
+                            this.words[0] = 0;
+                            this.length = 1;
+                        }
+
+                        return this.strip();
+                    };
+
+                    BN.prototype.ishrn = function ishrn(bits, hint, extended) {
+                        // TODO(indutny): implement me
+                        assert(this.negative === 0);
+                        return this.iushrn(bits, hint, extended);
+                    };
+
+                    // Shift-left
+                    BN.prototype.shln = function shln(bits) {
+                        return this.clone().ishln(bits);
+                    };
+
+                    BN.prototype.ushln = function ushln(bits) {
+                        return this.clone().iushln(bits);
+                    };
+
+                    // Shift-right
+                    BN.prototype.shrn = function shrn(bits) {
+                        return this.clone().ishrn(bits);
+                    };
+
+                    BN.prototype.ushrn = function ushrn(bits) {
+                        return this.clone().iushrn(bits);
+                    };
+
+                    // Test if n bit is set
+                    BN.prototype.testn = function testn(bit) {
+                        assert(typeof bit === 'number' && bit >= 0);
+                        var r = bit % 26;
+                        var s = (bit - r) / 26;
+                        var q = 1 << r;
+
+                        // Fast case: bit is much higher than all existing words
+                        if (this.length <= s) return false;
+
+                        // Check bit and return
+                        var w = this.words[s];
+
+                        return !!(w & q);
+                    };
+
+                    // Return only lowers bits of number (in-place)
+                    BN.prototype.imaskn = function imaskn(bits) {
+                        assert(typeof bits === 'number' && bits >= 0);
+                        var r = bits % 26;
+                        var s = (bits - r) / 26;
+
+                        assert(this.negative === 0, 'imaskn works only with positive numbers');
+
+                        if (this.length <= s) {
+                            return this;
+                        }
+
+                        if (r !== 0) {
+                            s++;
+                        }
+                        this.length = Math.min(s, this.length);
+
+                        if (r !== 0) {
+                            var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+                            this.words[this.length - 1] &= mask;
+                        }
+
+                        return this.strip();
+                    };
+
+                    // Return only lowers bits of number
+                    BN.prototype.maskn = function maskn(bits) {
+                        return this.clone().imaskn(bits);
+                    };
+
+                    // Add plain number `num` to `this`
+                    BN.prototype.iaddn = function iaddn(num) {
+                        assert(typeof num === 'number');
+                        assert(num < 0x4000000);
+                        if (num < 0) return this.isubn(-num);
+
+                        // Possible sign change
+                        if (this.negative !== 0) {
+                            if (this.length === 1 && (this.words[0] | 0) < num) {
+                                this.words[0] = num - (this.words[0] | 0);
+                                this.negative = 0;
+                                return this;
+                            }
+
+                            this.negative = 0;
+                            this.isubn(num);
+                            this.negative = 1;
+                            return this;
+                        }
+
+                        // Add without checks
+                        return this._iaddn(num);
+                    };
+
+                    BN.prototype._iaddn = function _iaddn(num) {
+                        this.words[0] += num;
+
+                        // Carry
+                        for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
+                            this.words[i] -= 0x4000000;
+                            if (i === this.length - 1) {
+                                this.words[i + 1] = 1;
+                            } else {
+                                this.words[i + 1]++;
+                            }
+                        }
+                        this.length = Math.max(this.length, i + 1);
+
+                        return this;
+                    };
+
+                    // Subtract plain number `num` from `this`
+                    BN.prototype.isubn = function isubn(num) {
+                        assert(typeof num === 'number');
+                        assert(num < 0x4000000);
+                        if (num < 0) return this.iaddn(-num);
+
+                        if (this.negative !== 0) {
+                            this.negative = 0;
+                            this.iaddn(num);
+                            this.negative = 1;
+                            return this;
+                        }
+
+                        this.words[0] -= num;
+
+                        if (this.length === 1 && this.words[0] < 0) {
+                            this.words[0] = -this.words[0];
+                            this.negative = 1;
+                        } else {
+                            // Carry
+                            for (var i = 0; i < this.length && this.words[i] < 0; i++) {
+                                this.words[i] += 0x4000000;
+                                this.words[i + 1] -= 1;
+                            }
+                        }
+
+                        return this.strip();
+                    };
+
+                    BN.prototype.addn = function addn(num) {
+                        return this.clone().iaddn(num);
+                    };
+
+                    BN.prototype.subn = function subn(num) {
+                        return this.clone().isubn(num);
+                    };
+
+                    BN.prototype.iabs = function iabs() {
+                        this.negative = 0;
+
+                        return this;
+                    };
+
+                    BN.prototype.abs = function abs() {
+                        return this.clone().iabs();
+                    };
+
+                    BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
+                        var len = num.length + shift;
+                        var i;
+
+                        this._expand(len);
+
+                        var w;
+                        var carry = 0;
+                        for (i = 0; i < num.length; i++) {
+                            w = (this.words[i + shift] | 0) + carry;
+                            var right = (num.words[i] | 0) * mul;
+                            w -= right & 0x3ffffff;
+                            carry = (w >> 26) - ((right / 0x4000000) | 0);
+                            this.words[i + shift] = w & 0x3ffffff;
+                        }
+                        for (; i < this.length - shift; i++) {
+                            w = (this.words[i + shift] | 0) + carry;
+                            carry = w >> 26;
+                            this.words[i + shift] = w & 0x3ffffff;
+                        }
+
+                        if (carry === 0) return this.strip();
+
+                        // Subtraction overflow
+                        assert(carry === -1);
+                        carry = 0;
+                        for (i = 0; i < this.length; i++) {
+                            w = -(this.words[i] | 0) + carry;
+                            carry = w >> 26;
+                            this.words[i] = w & 0x3ffffff;
+                        }
+                        this.negative = 1;
+
+                        return this.strip();
+                    };
+
+                    BN.prototype._wordDiv = function _wordDiv(num, mode) {
+                        var shift = this.length - num.length;
+
+                        var a = this.clone();
+                        var b = num;
+
+                        // Normalize
+                        var bhi = b.words[b.length - 1] | 0;
+                        var bhiBits = this._countBits(bhi);
+                        shift = 26 - bhiBits;
+                        if (shift !== 0) {
+                            b = b.ushln(shift);
+                            a.iushln(shift);
+                            bhi = b.words[b.length - 1] | 0;
+                        }
+
+                        // Initialize quotient
+                        var m = a.length - b.length;
+                        var q;
+
+                        if (mode !== 'mod') {
+                            q = new BN(null);
+                            q.length = m + 1;
+                            q.words = new Array(q.length);
+                            for (var i = 0; i < q.length; i++) {
+                                q.words[i] = 0;
+                            }
+                        }
+
+                        var diff = a.clone()._ishlnsubmul(b, 1, m);
+                        if (diff.negative === 0) {
+                            a = diff;
+                            if (q) {
+                                q.words[m] = 1;
+                            }
+                        }
+
+                        for (var j = m - 1; j >= 0; j--) {
+                            var qj = (a.words[b.length + j] | 0) * 0x4000000 +
+                                (a.words[b.length + j - 1] | 0);
+
+                            // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
+                            // (0x7ffffff)
+                            qj = Math.min((qj / bhi) | 0, 0x3ffffff);
+
+                            a._ishlnsubmul(b, qj, j);
+                            while (a.negative !== 0) {
+                                qj--;
+                                a.negative = 0;
+                                a._ishlnsubmul(b, 1, j);
+                                if (!a.isZero()) {
+                                    a.negative ^= 1;
+                                }
+                            }
+                            if (q) {
+                                q.words[j] = qj;
+                            }
+                        }
+                        if (q) {
+                            q.strip();
+                        }
+                        a.strip();
+
+                        // Denormalize
+                        if (mode !== 'div' && shift !== 0) {
+                            a.iushrn(shift);
+                        }
+
+                        return {
+                            div: q || null,
+                            mod: a
+                        };
+                    };
+
+                    // NOTE: 1) `mode` can be set to `mod` to request mod only,
+                    //       to `div` to request div only, or be absent to
+                    //       request both div & mod
+                    //       2) `positive` is true if unsigned mod is requested
+                    BN.prototype.divmod = function divmod(num, mode, positive) {
+                        assert(!num.isZero());
+
+                        if (this.isZero()) {
+                            return {
+                                div: new BN(0),
+                                mod: new BN(0)
+                            };
+                        }
+
+                        var div, mod, res;
+                        if (this.negative !== 0 && num.negative === 0) {
+                            res = this.neg().divmod(num, mode);
+
+                            if (mode !== 'mod') {
+                                div = res.div.neg();
+                            }
+
+                            if (mode !== 'div') {
+                                mod = res.mod.neg();
+                                if (positive && mod.negative !== 0) {
+                                    mod.iadd(num);
+                                }
+                            }
+
+                            return {
+                                div: div,
+                                mod: mod
+                            };
+                        }
+
+                        if (this.negative === 0 && num.negative !== 0) {
+                            res = this.divmod(num.neg(), mode);
+
+                            if (mode !== 'mod') {
+                                div = res.div.neg();
+                            }
+
+                            return {
+                                div: div,
+                                mod: res.mod
+                            };
+                        }
+
+                        if ((this.negative & num.negative) !== 0) {
+                            res = this.neg().divmod(num.neg(), mode);
+
+                            if (mode !== 'div') {
+                                mod = res.mod.neg();
+                                if (positive && mod.negative !== 0) {
+                                    mod.isub(num);
+                                }
+                            }
+
+                            return {
+                                div: res.div,
+                                mod: mod
+                            };
+                        }
+
+                        // Both numbers are positive at this point
+
+                        // Strip both numbers to approximate shift value
+                        if (num.length > this.length || this.cmp(num) < 0) {
+                            return {
+                                div: new BN(0),
+                                mod: this
+                            };
+                        }
+
+                        // Very short reduction
+                        if (num.length === 1) {
+                            if (mode === 'div') {
+                                return {
+                                    div: this.divn(num.words[0]),
+                                    mod: null
+                                };
+                            }
+
+                            if (mode === 'mod') {
+                                return {
+                                    div: null,
+                                    mod: new BN(this.modn(num.words[0]))
+                                };
+                            }
+
+                            return {
+                                div: this.divn(num.words[0]),
+                                mod: new BN(this.modn(num.words[0]))
+                            };
+                        }
+
+                        return this._wordDiv(num, mode);
+                    };
+
+                    // Find `this` / `num`
+                    BN.prototype.div = function div(num) {
+                        return this.divmod(num, 'div', false).div;
+                    };
+
+                    // Find `this` % `num`
+                    BN.prototype.mod = function mod(num) {
+                        return this.divmod(num, 'mod', false).mod;
+                    };
+
+                    BN.prototype.umod = function umod(num) {
+                        return this.divmod(num, 'mod', true).mod;
+                    };
+
+                    // Find Round(`this` / `num`)
+                    BN.prototype.divRound = function divRound(num) {
+                        var dm = this.divmod(num);
+
+                        // Fast case - exact division
+                        if (dm.mod.isZero()) return dm.div;
+
+                        var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+
+                        var half = num.ushrn(1);
+                        var r2 = num.andln(1);
+                        var cmp = mod.cmp(half);
+
+                        // Round down
+                        if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
+
+                        // Round up
+                        return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
+                    };
+
+                    BN.prototype.modn = function modn(num) {
+                        assert(num <= 0x3ffffff);
+                        var p = (1 << 26) % num;
+
+                        var acc = 0;
+                        for (var i = this.length - 1; i >= 0; i--) {
+                            acc = (p * acc + (this.words[i] | 0)) % num;
+                        }
+
+                        return acc;
+                    };
+
+                    // In-place division by number
+                    BN.prototype.idivn = function idivn(num) {
+                        assert(num <= 0x3ffffff);
+
+                        var carry = 0;
+                        for (var i = this.length - 1; i >= 0; i--) {
+                            var w = (this.words[i] | 0) + carry * 0x4000000;
+                            this.words[i] = (w / num) | 0;
+                            carry = w % num;
+                        }
+
+                        return this.strip();
+                    };
+
+                    BN.prototype.divn = function divn(num) {
+                        return this.clone().idivn(num);
+                    };
+
+                    BN.prototype.egcd = function egcd(p) {
+                        assert(p.negative === 0);
+                        assert(!p.isZero());
+
+                        var x = this;
+                        var y = p.clone();
+
+                        if (x.negative !== 0) {
+                            x = x.umod(p);
+                        } else {
+                            x = x.clone();
+                        }
+
+                        // A * x + B * y = x
+                        var A = new BN(1);
+                        var B = new BN(0);
+
+                        // C * x + D * y = y
+                        var C = new BN(0);
+                        var D = new BN(1);
+
+                        var g = 0;
+
+                        while (x.isEven() && y.isEven()) {
+                            x.iushrn(1);
+                            y.iushrn(1);
+                            ++g;
+                        }
+
+                        var yp = y.clone();
+                        var xp = x.clone();
+
+                        while (!x.isZero()) {
+                            for (var i = 0, im = 1;
+                                (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+                            if (i > 0) {
+                                x.iushrn(i);
+                                while (i-- > 0) {
+                                    if (A.isOdd() || B.isOdd()) {
+                                        A.iadd(yp);
+                                        B.isub(xp);
+                                    }
+
+                                    A.iushrn(1);
+                                    B.iushrn(1);
+                                }
+                            }
+
+                            for (var j = 0, jm = 1;
+                                (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+                            if (j > 0) {
+                                y.iushrn(j);
+                                while (j-- > 0) {
+                                    if (C.isOdd() || D.isOdd()) {
+                                        C.iadd(yp);
+                                        D.isub(xp);
+                                    }
+
+                                    C.iushrn(1);
+                                    D.iushrn(1);
+                                }
+                            }
+
+                            if (x.cmp(y) >= 0) {
+                                x.isub(y);
+                                A.isub(C);
+                                B.isub(D);
+                            } else {
+                                y.isub(x);
+                                C.isub(A);
+                                D.isub(B);
+                            }
+                        }
+
+                        return {
+                            a: C,
+                            b: D,
+                            gcd: y.iushln(g)
+                        };
+                    };
+
+                    // This is reduced incarnation of the binary EEA
+                    // above, designated to invert members of the
+                    // _prime_ fields F(p) at a maximal speed
+                    BN.prototype._invmp = function _invmp(p) {
+                        assert(p.negative === 0);
+                        assert(!p.isZero());
+
+                        var a = this;
+                        var b = p.clone();
+
+                        if (a.negative !== 0) {
+                            a = a.umod(p);
+                        } else {
+                            a = a.clone();
+                        }
+
+                        var x1 = new BN(1);
+                        var x2 = new BN(0);
+
+                        var delta = b.clone();
+
+                        while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
+                            for (var i = 0, im = 1;
+                                (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+                            if (i > 0) {
+                                a.iushrn(i);
+                                while (i-- > 0) {
+                                    if (x1.isOdd()) {
+                                        x1.iadd(delta);
+                                    }
+
+                                    x1.iushrn(1);
+                                }
+                            }
+
+                            for (var j = 0, jm = 1;
+                                (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+                            if (j > 0) {
+                                b.iushrn(j);
+                                while (j-- > 0) {
+                                    if (x2.isOdd()) {
+                                        x2.iadd(delta);
+                                    }
+
+                                    x2.iushrn(1);
+                                }
+                            }
+
+                            if (a.cmp(b) >= 0) {
+                                a.isub(b);
+                                x1.isub(x2);
+                            } else {
+                                b.isub(a);
+                                x2.isub(x1);
+                            }
+                        }
+
+                        var res;
+                        if (a.cmpn(1) === 0) {
+                            res = x1;
+                        } else {
+                            res = x2;
+                        }
+
+                        if (res.cmpn(0) < 0) {
+                            res.iadd(p);
+                        }
+
+                        return res;
+                    };
+
+                    BN.prototype.gcd = function gcd(num) {
+                        if (this.isZero()) return num.abs();
+                        if (num.isZero()) return this.abs();
+
+                        var a = this.clone();
+                        var b = num.clone();
+                        a.negative = 0;
+                        b.negative = 0;
+
+                        // Remove common factor of two
+                        for (var shift = 0; a.isEven() && b.isEven(); shift++) {
+                            a.iushrn(1);
+                            b.iushrn(1);
+                        }
+
+                        do {
+                            while (a.isEven()) {
+                                a.iushrn(1);
+                            }
+                            while (b.isEven()) {
+                                b.iushrn(1);
+                            }
+
+                            var r = a.cmp(b);
+                            if (r < 0) {
+                                // Swap `a` and `b` to make `a` always bigger than `b`
+                                var t = a;
+                                a = b;
+                                b = t;
+                            } else if (r === 0 || b.cmpn(1) === 0) {
+                                break;
+                            }
+
+                            a.isub(b);
+                        } while (true);
+
+                        return b.iushln(shift);
+                    };
+
+                    // Invert number in the field F(num)
+                    BN.prototype.invm = function invm(num) {
+                        return this.egcd(num).a.umod(num);
+                    };
+
+                    BN.prototype.isEven = function isEven() {
+                        return (this.words[0] & 1) === 0;
+                    };
+
+                    BN.prototype.isOdd = function isOdd() {
+                        return (this.words[0] & 1) === 1;
+                    };
+
+                    // And first word and num
+                    BN.prototype.andln = function andln(num) {
+                        return this.words[0] & num;
+                    };
+
+                    // Increment at the bit position in-line
+                    BN.prototype.bincn = function bincn(bit) {
+                        assert(typeof bit === 'number');
+                        var r = bit % 26;
+                        var s = (bit - r) / 26;
+                        var q = 1 << r;
+
+                        // Fast case: bit is much higher than all existing words
+                        if (this.length <= s) {
+                            this._expand(s + 1);
+                            this.words[s] |= q;
+                            return this;
+                        }
+
+                        // Add bit and propagate, if needed
+                        var carry = q;
+                        for (var i = s; carry !== 0 && i < this.length; i++) {
+                            var w = this.words[i] | 0;
+                            w += carry;
+                            carry = w >>> 26;
+                            w &= 0x3ffffff;
+                            this.words[i] = w;
+                        }
+                        if (carry !== 0) {
+                            this.words[i] = carry;
+                            this.length++;
+                        }
+                        return this;
+                    };
+
+                    BN.prototype.isZero = function isZero() {
+                        return this.length === 1 && this.words[0] === 0;
+                    };
+
+                    BN.prototype.cmpn = function cmpn(num) {
+                        var negative = num < 0;
+
+                        if (this.negative !== 0 && !negative) return -1;
+                        if (this.negative === 0 && negative) return 1;
+
+                        this.strip();
+
+                        var res;
+                        if (this.length > 1) {
+                            res = 1;
+                        } else {
+                            if (negative) {
+                                num = -num;
+                            }
+
+                            assert(num <= 0x3ffffff, 'Number is too big');
+
+                            var w = this.words[0] | 0;
+                            res = w === num ? 0 : w < num ? -1 : 1;
+                        }
+                        if (this.negative !== 0) return -res | 0;
+                        return res;
+                    };
+
+                    // Compare two numbers and return:
+                    // 1 - if `this` > `num`
+                    // 0 - if `this` == `num`
+                    // -1 - if `this` < `num`
+                    BN.prototype.cmp = function cmp(num) {
+                        if (this.negative !== 0 && num.negative === 0) return -1;
+                        if (this.negative === 0 && num.negative !== 0) return 1;
+
+                        var res = this.ucmp(num);
+                        if (this.negative !== 0) return -res | 0;
+                        return res;
+                    };
+
+                    // Unsigned comparison
+                    BN.prototype.ucmp = function ucmp(num) {
+                        // At this point both numbers have the same sign
+                        if (this.length > num.length) return 1;
+                        if (this.length < num.length) return -1;
+
+                        var res = 0;
+                        for (var i = this.length - 1; i >= 0; i--) {
+                            var a = this.words[i] | 0;
+                            var b = num.words[i] | 0;
+
+                            if (a === b) continue;
+                            if (a < b) {
+                                res = -1;
+                            } else if (a > b) {
+                                res = 1;
+                            }
+                            break;
+                        }
+                        return res;
+                    };
+
+                    BN.prototype.gtn = function gtn(num) {
+                        return this.cmpn(num) === 1;
+                    };
+
+                    BN.prototype.gt = function gt(num) {
+                        return this.cmp(num) === 1;
+                    };
+
+                    BN.prototype.gten = function gten(num) {
+                        return this.cmpn(num) >= 0;
+                    };
+
+                    BN.prototype.gte = function gte(num) {
+                        return this.cmp(num) >= 0;
+                    };
+
+                    BN.prototype.ltn = function ltn(num) {
+                        return this.cmpn(num) === -1;
+                    };
+
+                    BN.prototype.lt = function lt(num) {
+                        return this.cmp(num) === -1;
+                    };
+
+                    BN.prototype.lten = function lten(num) {
+                        return this.cmpn(num) <= 0;
+                    };
+
+                    BN.prototype.lte = function lte(num) {
+                        return this.cmp(num) <= 0;
+                    };
+
+                    BN.prototype.eqn = function eqn(num) {
+                        return this.cmpn(num) === 0;
+                    };
+
+                    BN.prototype.eq = function eq(num) {
+                        return this.cmp(num) === 0;
+                    };
+
+                    //
+                    // A reduce context, could be using montgomery or something better, depending
+                    // on the `m` itself.
+                    //
+                    BN.red = function red(num) {
+                        return new Red(num);
+                    };
+
+                    BN.prototype.toRed = function toRed(ctx) {
+                        assert(!this.red, 'Already a number in reduction context');
+                        assert(this.negative === 0, 'red works only with positives');
+                        return ctx.convertTo(this)._forceRed(ctx);
+                    };
+
+                    BN.prototype.fromRed = function fromRed() {
+                        assert(this.red, 'fromRed works only with numbers in reduction context');
+                        return this.red.convertFrom(this);
+                    };
+
+                    BN.prototype._forceRed = function _forceRed(ctx) {
+                        this.red = ctx;
+                        return this;
+                    };
+
+                    BN.prototype.forceRed = function forceRed(ctx) {
+                        assert(!this.red, 'Already a number in reduction context');
+                        return this._forceRed(ctx);
+                    };
+
+                    BN.prototype.redAdd = function redAdd(num) {
+                        assert(this.red, 'redAdd works only with red numbers');
+                        return this.red.add(this, num);
+                    };
+
+                    BN.prototype.redIAdd = function redIAdd(num) {
+                        assert(this.red, 'redIAdd works only with red numbers');
+                        return this.red.iadd(this, num);
+                    };
+
+                    BN.prototype.redSub = function redSub(num) {
+                        assert(this.red, 'redSub works only with red numbers');
+                        return this.red.sub(this, num);
+                    };
+
+                    BN.prototype.redISub = function redISub(num) {
+                        assert(this.red, 'redISub works only with red numbers');
+                        return this.red.isub(this, num);
+                    };
+
+                    BN.prototype.redShl = function redShl(num) {
+                        assert(this.red, 'redShl works only with red numbers');
+                        return this.red.shl(this, num);
+                    };
+
+                    BN.prototype.redMul = function redMul(num) {
+                        assert(this.red, 'redMul works only with red numbers');
+                        this.red._verify2(this, num);
+                        return this.red.mul(this, num);
+                    };
+
+                    BN.prototype.redIMul = function redIMul(num) {
+                        assert(this.red, 'redMul works only with red numbers');
+                        this.red._verify2(this, num);
+                        return this.red.imul(this, num);
+                    };
+
+                    BN.prototype.redSqr = function redSqr() {
+                        assert(this.red, 'redSqr works only with red numbers');
+                        this.red._verify1(this);
+                        return this.red.sqr(this);
+                    };
+
+                    BN.prototype.redISqr = function redISqr() {
+                        assert(this.red, 'redISqr works only with red numbers');
+                        this.red._verify1(this);
+                        return this.red.isqr(this);
+                    };
+
+                    // Square root over p
+                    BN.prototype.redSqrt = function redSqrt() {
+                        assert(this.red, 'redSqrt works only with red numbers');
+                        this.red._verify1(this);
+                        return this.red.sqrt(this);
+                    };
+
+                    BN.prototype.redInvm = function redInvm() {
+                        assert(this.red, 'redInvm works only with red numbers');
+                        this.red._verify1(this);
+                        return this.red.invm(this);
+                    };
+
+                    // Return negative clone of `this` % `red modulo`
+                    BN.prototype.redNeg = function redNeg() {
+                        assert(this.red, 'redNeg works only with red numbers');
+                        this.red._verify1(this);
+                        return this.red.neg(this);
+                    };
+
+                    BN.prototype.redPow = function redPow(num) {
+                        assert(this.red && !num.red, 'redPow(normalNum)');
+                        this.red._verify1(this);
+                        return this.red.pow(this, num);
+                    };
+
+                    // Prime numbers with efficient reduction
+                    var primes = {
+                        k256: null,
+                        p224: null,
+                        p192: null,
+                        p25519: null
+                    };
+
+                    // Pseudo-Mersenne prime
+                    function MPrime(name, p) {
+                        // P = 2 ^ N - K
+                        this.name = name;
+                        this.p = new BN(p, 16);
+                        this.n = this.p.bitLength();
+                        this.k = new BN(1).iushln(this.n).isub(this.p);
+
+                        this.tmp = this._tmp();
+                    }
+
+                    MPrime.prototype._tmp = function _tmp() {
+                        var tmp = new BN(null);
+                        tmp.words = new Array(Math.ceil(this.n / 13));
+                        return tmp;
+                    };
+
+                    MPrime.prototype.ireduce = function ireduce(num) {
+                        // Assumes that `num` is less than `P^2`
+                        // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
+                        var r = num;
+                        var rlen;
+
+                        do {
+                            this.split(r, this.tmp);
+                            r = this.imulK(r);
+                            r = r.iadd(this.tmp);
+                            rlen = r.bitLength();
+                        } while (rlen > this.n);
+
+                        var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
+                        if (cmp === 0) {
+                            r.words[0] = 0;
+                            r.length = 1;
+                        } else if (cmp > 0) {
+                            r.isub(this.p);
+                        } else {
+                            r.strip();
+                        }
+
+                        return r;
+                    };
+
+                    MPrime.prototype.split = function split(input, out) {
+                        input.iushrn(this.n, 0, out);
+                    };
+
+                    MPrime.prototype.imulK = function imulK(num) {
+                        return num.imul(this.k);
+                    };
+
+                    function K256() {
+                        MPrime.call(
+                            this,
+                            'k256',
+                            'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f'
+                        );
+                    }
+                    inherits(K256, MPrime);
+
+                    K256.prototype.split = function split(input, output) {
+                        // 256 = 9 * 26 + 22
+                        var mask = 0x3fffff;
+
+                        var outLen = Math.min(input.length, 9);
+                        for (var i = 0; i < outLen; i++) {
+                            output.words[i] = input.words[i];
+                        }
+                        output.length = outLen;
+
+                        if (input.length <= 9) {
+                            input.words[0] = 0;
+                            input.length = 1;
+                            return;
+                        }
+
+                        // Shift by 9 limbs
+                        var prev = input.words[9];
+                        output.words[output.length++] = prev & mask;
+
+                        for (i = 10; i < input.length; i++) {
+                            var next = input.words[i] | 0;
+                            input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);
+                            prev = next;
+                        }
+                        prev >>>= 22;
+                        input.words[i - 10] = prev;
+                        if (prev === 0 && input.length > 10) {
+                            input.length -= 10;
+                        } else {
+                            input.length -= 9;
+                        }
+                    };
+
+                    K256.prototype.imulK = function imulK(num) {
+                        // K = 0x1000003d1 = [ 0x40, 0x3d1 ]
+                        num.words[num.length] = 0;
+                        num.words[num.length + 1] = 0;
+                        num.length += 2;
+
+                        // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
+                        var lo = 0;
+                        for (var i = 0; i < num.length; i++) {
+                            var w = num.words[i] | 0;
+                            lo += w * 0x3d1;
+                            num.words[i] = lo & 0x3ffffff;
+                            lo = w * 0x40 + ((lo / 0x4000000) | 0);
+                        }
+
+                        // Fast length reduction
+                        if (num.words[num.length - 1] === 0) {
+                            num.length--;
+                            if (num.words[num.length - 1] === 0) {
+                                num.length--;
+                            }
+                        }
+                        return num;
+                    };
+
+                    function P224() {
+                        MPrime.call(
+                            this,
+                            'p224',
+                            'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
+                    }
+                    inherits(P224, MPrime);
+
+                    function P192() {
+                        MPrime.call(
+                            this,
+                            'p192',
+                            'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
+                    }
+                    inherits(P192, MPrime);
+
+                    function P25519() {
+                        // 2 ^ 255 - 19
+                        MPrime.call(
+                            this,
+                            '25519',
+                            '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
+                    }
+                    inherits(P25519, MPrime);
+
+                    P25519.prototype.imulK = function imulK(num) {
+                        // K = 0x13
+                        var carry = 0;
+                        for (var i = 0; i < num.length; i++) {
+                            var hi = (num.words[i] | 0) * 0x13 + carry;
+                            var lo = hi & 0x3ffffff;
+                            hi >>>= 26;
+
+                            num.words[i] = lo;
+                            carry = hi;
+                        }
+                        if (carry !== 0) {
+                            num.words[num.length++] = carry;
+                        }
+                        return num;
+                    };
+
+                    // Exported mostly for testing purposes, use plain name instead
+                    BN._prime = function prime(name) {
+                        // Cached version of prime
+                        if (primes[name]) return primes[name];
+
+                        var prime;
+                        if (name === 'k256') {
+                            prime = new K256();
+                        } else if (name === 'p224') {
+                            prime = new P224();
+                        } else if (name === 'p192') {
+                            prime = new P192();
+                        } else if (name === 'p25519') {
+                            prime = new P25519();
+                        } else {
+                            throw new Error('Unknown prime ' + name);
+                        }
+                        primes[name] = prime;
+
+                        return prime;
+                    };
+
+                    //
+                    // Base reduction engine
+                    //
+                    function Red(m) {
+                        if (typeof m === 'string') {
+                            var prime = BN._prime(m);
+                            this.m = prime.p;
+                            this.prime = prime;
+                        } else {
+                            assert(m.gtn(1), 'modulus must be greater than 1');
+                            this.m = m;
+                            this.prime = null;
+                        }
+                    }
+
+                    Red.prototype._verify1 = function _verify1(a) {
+                        assert(a.negative === 0, 'red works only with positives');
+                        assert(a.red, 'red works only with red numbers');
+                    };
+
+                    Red.prototype._verify2 = function _verify2(a, b) {
+                        assert((a.negative | b.negative) === 0, 'red works only with positives');
+                        assert(a.red && a.red === b.red,
+                            'red works only with red numbers');
+                    };
+
+                    Red.prototype.imod = function imod(a) {
+                        if (this.prime) return this.prime.ireduce(a)._forceRed(this);
+                        return a.umod(this.m)._forceRed(this);
+                    };
+
+                    Red.prototype.neg = function neg(a) {
+                        if (a.isZero()) {
+                            return a.clone();
+                        }
+
+                        return this.m.sub(a)._forceRed(this);
+                    };
+
+                    Red.prototype.add = function add(a, b) {
+                        this._verify2(a, b);
+
+                        var res = a.add(b);
+                        if (res.cmp(this.m) >= 0) {
+                            res.isub(this.m);
+                        }
+                        return res._forceRed(this);
+                    };
+
+                    Red.prototype.iadd = function iadd(a, b) {
+                        this._verify2(a, b);
+
+                        var res = a.iadd(b);
+                        if (res.cmp(this.m) >= 0) {
+                            res.isub(this.m);
+                        }
+                        return res;
+                    };
+
+                    Red.prototype.sub = function sub(a, b) {
+                        this._verify2(a, b);
+
+                        var res = a.sub(b);
+                        if (res.cmpn(0) < 0) {
+                            res.iadd(this.m);
+                        }
+                        return res._forceRed(this);
+                    };
+
+                    Red.prototype.isub = function isub(a, b) {
+                        this._verify2(a, b);
+
+                        var res = a.isub(b);
+                        if (res.cmpn(0) < 0) {
+                            res.iadd(this.m);
+                        }
+                        return res;
+                    };
+
+                    Red.prototype.shl = function shl(a, num) {
+                        this._verify1(a);
+                        return this.imod(a.ushln(num));
+                    };
+
+                    Red.prototype.imul = function imul(a, b) {
+                        this._verify2(a, b);
+                        return this.imod(a.imul(b));
+                    };
+
+                    Red.prototype.mul = function mul(a, b) {
+                        this._verify2(a, b);
+                        return this.imod(a.mul(b));
+                    };
+
+                    Red.prototype.isqr = function isqr(a) {
+                        return this.imul(a, a.clone());
+                    };
+
+                    Red.prototype.sqr = function sqr(a) {
+                        return this.mul(a, a);
+                    };
+
+                    Red.prototype.sqrt = function sqrt(a) {
+                        if (a.isZero()) return a.clone();
+
+                        var mod3 = this.m.andln(3);
+                        assert(mod3 % 2 === 1);
+
+                        // Fast case
+                        if (mod3 === 3) {
+                            var pow = this.m.add(new BN(1)).iushrn(2);
+                            return this.pow(a, pow);
+                        }
+
+                        // Tonelli-Shanks algorithm (Totally unoptimized and slow)
+                        //
+                        // Find Q and S, that Q * 2 ^ S = (P - 1)
+                        var q = this.m.subn(1);
+                        var s = 0;
+                        while (!q.isZero() && q.andln(1) === 0) {
+                            s++;
+                            q.iushrn(1);
+                        }
+                        assert(!q.isZero());
+
+                        var one = new BN(1).toRed(this);
+                        var nOne = one.redNeg();
+
+                        // Find quadratic non-residue
+                        // NOTE: Max is such because of generalized Riemann hypothesis.
+                        var lpow = this.m.subn(1).iushrn(1);
+                        var z = this.m.bitLength();
+                        z = new BN(2 * z * z).toRed(this);
+
+                        while (this.pow(z, lpow).cmp(nOne) !== 0) {
+                            z.redIAdd(nOne);
+                        }
+
+                        var c = this.pow(z, q);
+                        var r = this.pow(a, q.addn(1).iushrn(1));
+                        var t = this.pow(a, q);
+                        var m = s;
+                        while (t.cmp(one) !== 0) {
+                            var tmp = t;
+                            for (var i = 0; tmp.cmp(one) !== 0; i++) {
+                                tmp = tmp.redSqr();
+                            }
+                            assert(i < m);
+                            var b = this.pow(c, new BN(1).iushln(m - i - 1));
+
+                            r = r.redMul(b);
+                            c = b.redSqr();
+                            t = t.redMul(c);
+                            m = i;
+                        }
+
+                        return r;
+                    };
+
+                    Red.prototype.invm = function invm(a) {
+                        var inv = a._invmp(this.m);
+                        if (inv.negative !== 0) {
+                            inv.negative = 0;
+                            return this.imod(inv).redNeg();
+                        } else {
+                            return this.imod(inv);
+                        }
+                    };
+
+                    Red.prototype.pow = function pow(a, num) {
+                        if (num.isZero()) return new BN(1).toRed(this);
+                        if (num.cmpn(1) === 0) return a.clone();
+
+                        var windowSize = 4;
+                        var wnd = new Array(1 << windowSize);
+                        wnd[0] = new BN(1).toRed(this);
+                        wnd[1] = a;
+                        for (var i = 2; i < wnd.length; i++) {
+                            wnd[i] = this.mul(wnd[i - 1], a);
+                        }
+
+                        var res = wnd[0];
+                        var current = 0;
+                        var currentLen = 0;
+                        var start = num.bitLength() % 26;
+                        if (start === 0) {
+                            start = 26;
+                        }
+
+                        for (i = num.length - 1; i >= 0; i--) {
+                            var word = num.words[i];
+                            for (var j = start - 1; j >= 0; j--) {
+                                var bit = (word >> j) & 1;
+                                if (res !== wnd[0]) {
+                                    res = this.sqr(res);
+                                }
+
+                                if (bit === 0 && current === 0) {
+                                    currentLen = 0;
+                                    continue;
+                                }
+
+                                current <<= 1;
+                                current |= bit;
+                                currentLen++;
+                                if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
+
+                                res = this.mul(res, wnd[current]);
+                                currentLen = 0;
+                                current = 0;
+                            }
+                            start = 26;
+                        }
+
+                        return res;
+                    };
+
+                    Red.prototype.convertTo = function convertTo(num) {
+                        var r = num.umod(this.m);
+
+                        return r === num ? r.clone() : r;
+                    };
+
+                    Red.prototype.convertFrom = function convertFrom(num) {
+                        var res = num.clone();
+                        res.red = null;
+                        return res;
+                    };
+
+                    //
+                    // Montgomery method engine
+                    //
+
+                    BN.mont = function mont(num) {
+                        return new Mont(num);
+                    };
+
+                    function Mont(m) {
+                        Red.call(this, m);
+
+                        this.shift = this.m.bitLength();
+                        if (this.shift % 26 !== 0) {
+                            this.shift += 26 - (this.shift % 26);
+                        }
+
+                        this.r = new BN(1).iushln(this.shift);
+                        this.r2 = this.imod(this.r.sqr());
+                        this.rinv = this.r._invmp(this.m);
+
+                        this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
+                        this.minv = this.minv.umod(this.r);
+                        this.minv = this.r.sub(this.minv);
+                    }
+                    inherits(Mont, Red);
+
+                    Mont.prototype.convertTo = function convertTo(num) {
+                        return this.imod(num.ushln(this.shift));
+                    };
+
+                    Mont.prototype.convertFrom = function convertFrom(num) {
+                        var r = this.imod(num.mul(this.rinv));
+                        r.red = null;
+                        return r;
+                    };
+
+                    Mont.prototype.imul = function imul(a, b) {
+                        if (a.isZero() || b.isZero()) {
+                            a.words[0] = 0;
+                            a.length = 1;
+                            return a;
+                        }
+
+                        var t = a.imul(b);
+                        var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+                        var u = t.isub(c).iushrn(this.shift);
+                        var res = u;
+
+                        if (u.cmp(this.m) >= 0) {
+                            res = u.isub(this.m);
+                        } else if (u.cmpn(0) < 0) {
+                            res = u.iadd(this.m);
+                        }
+
+                        return res._forceRed(this);
+                    };
+
+                    Mont.prototype.mul = function mul(a, b) {
+                        if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
+
+                        var t = a.mul(b);
+                        var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+                        var u = t.isub(c).iushrn(this.shift);
+                        var res = u;
+                        if (u.cmp(this.m) >= 0) {
+                            res = u.isub(this.m);
+                        } else if (u.cmpn(0) < 0) {
+                            res = u.iadd(this.m);
+                        }
+
+                        return res._forceRed(this);
+                    };
+
+                    Mont.prototype.invm = function invm(a) {
+                        // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R
+                        var res = this.imod(a._invmp(this.m).mul(this.r2));
+                        return res._forceRed(this);
+                    };
+                })(typeof module === 'undefined' || module, this);
+
+            }, {
+                "buffer": 26
+            }],
+            25: [function (require, module, exports) {
+                var r;
+
+                module.exports = function rand(len) {
+                    if (!r)
+                        r = new Rand(null);
+
+                    return r.generate(len);
+                };
+
+                function Rand(rand) {
+                    this.rand = rand;
+                }
+                module.exports.Rand = Rand;
+
+                Rand.prototype.generate = function generate(len) {
+                    return this._rand(len);
+                };
+
+                // Emulate crypto API using randy
+                Rand.prototype._rand = function _rand(n) {
+                    if (this.rand.getBytes)
+                        return this.rand.getBytes(n);
+
+                    var res = new Uint8Array(n);
+                    for (var i = 0; i < res.length; i++)
+                        res[i] = this.rand.getByte();
+                    return res;
+                };
+
+                if (typeof self === 'object') {
+                    if (self.crypto && self.crypto.getRandomValues) {
+                        // Modern browsers
+                        Rand.prototype._rand = function _rand(n) {
+                            var arr = new Uint8Array(n);
+                            self.crypto.getRandomValues(arr);
+                            return arr;
+                        };
+                    } else if (self.msCrypto && self.msCrypto.getRandomValues) {
+                        // IE
+                        Rand.prototype._rand = function _rand(n) {
+                            var arr = new Uint8Array(n);
+                            self.msCrypto.getRandomValues(arr);
+                            return arr;
+                        };
+
+                        // Safari's WebWorkers do not have `crypto`
+                    } else if (typeof window === 'object') {
+                        // Old junk
+                        Rand.prototype._rand = function () {
+                            throw new Error('Not implemented yet');
+                        };
+                    }
+                } else {
+                    // Node.js or Web worker with no crypto support
+                    try {
+                        var crypto = require('crypto');
+                        if (typeof crypto.randomBytes !== 'function')
+                            throw new Error('Not supported');
+
+                        Rand.prototype._rand = function _rand(n) {
+                            return crypto.randomBytes(n);
+                        };
+                    } catch (e) {}
+                }
+
+            }, {
+                "crypto": 26
+            }],
+            26: [function (require, module, exports) {
+                arguments[4][8][0].apply(exports, arguments)
+            }, {
+                "dup": 8
+            }],
+            27: [function (require, module, exports) {
+                // based on the aes implimentation in triple sec
+                // https://github.com/keybase/triplesec
+                // which is in turn based on the one from crypto-js
+                // https://code.google.com/p/crypto-js/
+
+                var Buffer = require('safe-buffer').Buffer
+
+                function asUInt32Array(buf) {
+                    if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)
+
+                    var len = (buf.length / 4) | 0
+                    var out = new Array(len)
+
+                    for (var i = 0; i < len; i++) {
+                        out[i] = buf.readUInt32BE(i * 4)
+                    }
+
+                    return out
+                }
+
+                function scrubVec(v) {
+                    for (var i = 0; i < v.length; v++) {
+                        v[i] = 0
+                    }
+                }
+
+                function cryptBlock(M, keySchedule, SUB_MIX, SBOX, nRounds) {
+                    var SUB_MIX0 = SUB_MIX[0]
+                    var SUB_MIX1 = SUB_MIX[1]
+                    var SUB_MIX2 = SUB_MIX[2]
+                    var SUB_MIX3 = SUB_MIX[3]
+
+                    var s0 = M[0] ^ keySchedule[0]
+                    var s1 = M[1] ^ keySchedule[1]
+                    var s2 = M[2] ^ keySchedule[2]
+                    var s3 = M[3] ^ keySchedule[3]
+                    var t0, t1, t2, t3
+                    var ksRow = 4
+
+                    for (var round = 1; round < nRounds; round++) {
+                        t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[(s1 >>> 16) & 0xff] ^ SUB_MIX2[(s2 >>> 8) &
+                            0xff] ^ SUB_MIX3[s3 & 0xff] ^ keySchedule[ksRow++]
+                        t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[(s2 >>> 16) & 0xff] ^ SUB_MIX2[(s3 >>> 8) &
+                            0xff] ^ SUB_MIX3[s0 & 0xff] ^ keySchedule[ksRow++]
+                        t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[(s3 >>> 16) & 0xff] ^ SUB_MIX2[(s0 >>> 8) &
+                            0xff] ^ SUB_MIX3[s1 & 0xff] ^ keySchedule[ksRow++]
+                        t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[(s0 >>> 16) & 0xff] ^ SUB_MIX2[(s1 >>> 8) &
+                            0xff] ^ SUB_MIX3[s2 & 0xff] ^ keySchedule[ksRow++]
+                        s0 = t0
+                        s1 = t1
+                        s2 = t2
+                        s3 = t3
+                    }
+
+                    t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) &
+                        0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]
+                    t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) &
+                        0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]
+                    t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) &
+                        0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]
+                    t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) &
+                        0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]
+                    t0 = t0 >>> 0
+                    t1 = t1 >>> 0
+                    t2 = t2 >>> 0
+                    t3 = t3 >>> 0
+
+                    return [t0, t1, t2, t3]
+                }
+
+                // AES constants
+                var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]
+                var G = (function () {
+                    // Compute double table
+                    var d = new Array(256)
+                    for (var j = 0; j < 256; j++) {
+                        if (j < 128) {
+                            d[j] = j << 1
+                        } else {
+                            d[j] = (j << 1) ^ 0x11b
+                        }
+                    }
+
+                    var SBOX = []
+                    var INV_SBOX = []
+                    var SUB_MIX = [
+                        [],
+                        [],
+                        [],
+                        []
+                    ]
+                    var INV_SUB_MIX = [
+                        [],
+                        [],
+                        [],
+                        []
+                    ]
+
+                    // Walk GF(2^8)
+                    var x = 0
+                    var xi = 0
+                    for (var i = 0; i < 256; ++i) {
+                        // Compute sbox
+                        var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4)
+                        sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63
+                        SBOX[x] = sx
+                        INV_SBOX[sx] = x
+
+                        // Compute multiplication
+                        var x2 = d[x]
+                        var x4 = d[x2]
+                        var x8 = d[x4]
+
+                        // Compute sub bytes, mix columns tables
+                        var t = (d[sx] * 0x101) ^ (sx * 0x1010100)
+                        SUB_MIX[0][x] = (t << 24) | (t >>> 8)
+                        SUB_MIX[1][x] = (t << 16) | (t >>> 16)
+                        SUB_MIX[2][x] = (t << 8) | (t >>> 24)
+                        SUB_MIX[3][x] = t
+
+                        // Compute inv sub bytes, inv mix columns tables
+                        t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)
+                        INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8)
+                        INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16)
+                        INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24)
+                        INV_SUB_MIX[3][sx] = t
+
+                        if (x === 0) {
+                            x = xi = 1
+                        } else {
+                            x = x2 ^ d[d[d[x8 ^ x2]]]
+                            xi ^= d[d[xi]]
+                        }
+                    }
+
+                    return {
+                        SBOX: SBOX,
+                        INV_SBOX: INV_SBOX,
+                        SUB_MIX: SUB_MIX,
+                        INV_SUB_MIX: INV_SUB_MIX
+                    }
+                })()
+
+                function AES(key) {
+                    this._key = asUInt32Array(key)
+                    this._reset()
+                }
+
+                AES.blockSize = 4 * 4
+                AES.keySize = 256 / 8
+                AES.prototype.blockSize = AES.blockSize
+                AES.prototype.keySize = AES.keySize
+                AES.prototype._reset = function () {
+                    var keyWords = this._key
+                    var keySize = keyWords.length
+                    var nRounds = keySize + 6
+                    var ksRows = (nRounds + 1) * 4
+
+                    var keySchedule = []
+                    for (var k = 0; k < keySize; k++) {
+                        keySchedule[k] = keyWords[k]
+                    }
+
+                    for (k = keySize; k < ksRows; k++) {
+                        var t = keySchedule[k - 1]
+
+                        if (k % keySize === 0) {
+                            t = (t << 8) | (t >>> 24)
+                            t =
+                                (G.SBOX[t >>> 24] << 24) |
+                                (G.SBOX[(t >>> 16) & 0xff] << 16) |
+                                (G.SBOX[(t >>> 8) & 0xff] << 8) |
+                                (G.SBOX[t & 0xff])
+
+                            t ^= RCON[(k / keySize) | 0] << 24
+                        } else if (keySize > 6 && k % keySize === 4) {
+                            t =
+                                (G.SBOX[t >>> 24] << 24) |
+                                (G.SBOX[(t >>> 16) & 0xff] << 16) |
+                                (G.SBOX[(t >>> 8) & 0xff] << 8) |
+                                (G.SBOX[t & 0xff])
+                        }
+
+                        keySchedule[k] = keySchedule[k - keySize] ^ t
+                    }
+
+                    var invKeySchedule = []
+                    for (var ik = 0; ik < ksRows; ik++) {
+                        var ksR = ksRows - ik
+                        var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)]
+
+                        if (ik < 4 || ksR <= 4) {
+                            invKeySchedule[ik] = tt
+                        } else {
+                            invKeySchedule[ik] =
+                                G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^
+                                G.INV_SUB_MIX[1][G.SBOX[(tt >>> 16) & 0xff]] ^
+                                G.INV_SUB_MIX[2][G.SBOX[(tt >>> 8) & 0xff]] ^
+                                G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]]
+                        }
+                    }
+
+                    this._nRounds = nRounds
+                    this._keySchedule = keySchedule
+                    this._invKeySchedule = invKeySchedule
+                }
+
+                AES.prototype.encryptBlockRaw = function (M) {
+                    M = asUInt32Array(M)
+                    return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds)
+                }
+
+                AES.prototype.encryptBlock = function (M) {
+                    var out = this.encryptBlockRaw(M)
+                    var buf = Buffer.allocUnsafe(16)
+                    buf.writeUInt32BE(out[0], 0)
+                    buf.writeUInt32BE(out[1], 4)
+                    buf.writeUInt32BE(out[2], 8)
+                    buf.writeUInt32BE(out[3], 12)
+                    return buf
+                }
+
+                AES.prototype.decryptBlock = function (M) {
+                    M = asUInt32Array(M)
+
+                    // swap
+                    var m1 = M[1]
+                    M[1] = M[3]
+                    M[3] = m1
+
+                    var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds)
+                    var buf = Buffer.allocUnsafe(16)
+                    buf.writeUInt32BE(out[0], 0)
+                    buf.writeUInt32BE(out[3], 4)
+                    buf.writeUInt32BE(out[2], 8)
+                    buf.writeUInt32BE(out[1], 12)
+                    return buf
+                }
+
+                AES.prototype.scrub = function () {
+                    scrubVec(this._keySchedule)
+                    scrubVec(this._invKeySchedule)
+                    scrubVec(this._key)
+                }
+
+                module.exports.AES = AES
+
+            }, {
+                "safe-buffer": 148
+            }],
+            28: [function (require, module, exports) {
+                var aes = require('./aes')
+                var Buffer = require('safe-buffer').Buffer
+                var Transform = require('cipher-base')
+                var inherits = require('inherits')
+                var GHASH = require('./ghash')
+                var xor = require('buffer-xor')
+                var incr32 = require('./incr32')
+
+                function xorTest(a, b) {
+                    var out = 0
+                    if (a.length !== b.length) out++
+
+                    var len = Math.min(a.length, b.length)
+                    for (var i = 0; i < len; ++i) {
+                        out += (a[i] ^ b[i])
+                    }
+
+                    return out
+                }
+
+                function calcIv(self, iv, ck) {
+                    if (iv.length === 12) {
+                        self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])])
+                        return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])])
+                    }
+                    var ghash = new GHASH(ck)
+                    var len = iv.length
+                    var toPad = len % 16
+                    ghash.update(iv)
+                    if (toPad) {
+                        toPad = 16 - toPad
+                        ghash.update(Buffer.alloc(toPad, 0))
+                    }
+                    ghash.update(Buffer.alloc(8, 0))
+                    var ivBits = len * 8
+                    var tail = Buffer.alloc(8)
+                    tail.writeUIntBE(ivBits, 0, 8)
+                    ghash.update(tail)
+                    self._finID = ghash.state
+                    var out = Buffer.from(self._finID)
+                    incr32(out)
+                    return out
+                }
+
+                function StreamCipher(mode, key, iv, decrypt) {
+                    Transform.call(this)
+
+                    var h = Buffer.alloc(4, 0)
+
+                    this._cipher = new aes.AES(key)
+                    var ck = this._cipher.encryptBlock(h)
+                    this._ghash = new GHASH(ck)
+                    iv = calcIv(this, iv, ck)
+
+                    this._prev = Buffer.from(iv)
+                    this._cache = Buffer.allocUnsafe(0)
+                    this._secCache = Buffer.allocUnsafe(0)
+                    this._decrypt = decrypt
+                    this._alen = 0
+                    this._len = 0
+                    this._mode = mode
+
+                    this._authTag = null
+                    this._called = false
+                }
+
+                inherits(StreamCipher, Transform)
+
+                StreamCipher.prototype._update = function (chunk) {
+                    if (!this._called && this._alen) {
+                        var rump = 16 - (this._alen % 16)
+                        if (rump < 16) {
+                            rump = Buffer.alloc(rump, 0)
+                            this._ghash.update(rump)
+                        }
+                    }
+
+                    this._called = true
+                    var out = this._mode.encrypt(this, chunk)
+                    if (this._decrypt) {
+                        this._ghash.update(chunk)
+                    } else {
+                        this._ghash.update(out)
+                    }
+                    this._len += chunk.length
+                    return out
+                }
+
+                StreamCipher.prototype._final = function () {
+                    if (this._decrypt && !this._authTag) throw new Error(
+                        'Unsupported state or unable to authenticate data')
+
+                    var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(
+                        this._finID))
+                    if (this._decrypt && xorTest(tag, this._authTag)) throw new Error(
+                        'Unsupported state or unable to authenticate data')
+
+                    this._authTag = tag
+                    this._cipher.scrub()
+                }
+
+                StreamCipher.prototype.getAuthTag = function getAuthTag() {
+                    if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error(
+                        'Attempting to get auth tag in unsupported state')
+
+                    return this._authTag
+                }
+
+                StreamCipher.prototype.setAuthTag = function setAuthTag(tag) {
+                    if (!this._decrypt) throw new Error(
+                        'Attempting to set auth tag in unsupported state')
+
+                    this._authTag = tag
+                }
+
+                StreamCipher.prototype.setAAD = function setAAD(buf) {
+                    if (this._called) throw new Error('Attempting to set AAD in unsupported state')
+
+                    this._ghash.update(buf)
+                    this._alen += buf.length
+                }
+
+                module.exports = StreamCipher
+
+            }, {
+                "./aes": 27,
+                "./ghash": 32,
+                "./incr32": 33,
+                "buffer-xor": 54,
+                "cipher-base": 56,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            29: [function (require, module, exports) {
+                var ciphers = require('./encrypter')
+                var deciphers = require('./decrypter')
+                var modes = require('./modes/list.json')
+
+                function getCiphers() {
+                    return Object.keys(modes)
+                }
+
+                exports.createCipher = exports.Cipher = ciphers.createCipher
+                exports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv
+                exports.createDecipher = exports.Decipher = deciphers.createDecipher
+                exports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv
+                exports.listCiphers = exports.getCiphers = getCiphers
+
+            }, {
+                "./decrypter": 30,
+                "./encrypter": 31,
+                "./modes/list.json": 41
+            }],
+            30: [function (require, module, exports) {
+                var AuthCipher = require('./authCipher')
+                var Buffer = require('safe-buffer').Buffer
+                var MODES = require('./modes')
+                var StreamCipher = require('./streamCipher')
+                var Transform = require('cipher-base')
+                var aes = require('./aes')
+                var ebtk = require('evp_bytestokey')
+                var inherits = require('inherits')
+
+                function Decipher(mode, key, iv) {
+                    Transform.call(this)
+
+                    this._cache = new Splitter()
+                    this._last = void 0
+                    this._cipher = new aes.AES(key)
+                    this._prev = Buffer.from(iv)
+                    this._mode = mode
+                    this._autopadding = true
+                }
+
+                inherits(Decipher, Transform)
+
+                Decipher.prototype._update = function (data) {
+                    this._cache.add(data)
+                    var chunk
+                    var thing
+                    var out = []
+                    while ((chunk = this._cache.get(this._autopadding))) {
+                        thing = this._mode.decrypt(this, chunk)
+                        out.push(thing)
+                    }
+                    return Buffer.concat(out)
+                }
+
+                Decipher.prototype._final = function () {
+                    var chunk = this._cache.flush()
+                    if (this._autopadding) {
+                        return unpad(this._mode.decrypt(this, chunk))
+                    } else if (chunk) {
+                        throw new Error('data not multiple of block length')
+                    }
+                }
+
+                Decipher.prototype.setAutoPadding = function (setTo) {
+                    this._autopadding = !!setTo
+                    return this
+                }
+
+                function Splitter() {
+                    this.cache = Buffer.allocUnsafe(0)
+                }
+
+                Splitter.prototype.add = function (data) {
+                    this.cache = Buffer.concat([this.cache, data])
+                }
+
+                Splitter.prototype.get = function (autoPadding) {
+                    var out
+                    if (autoPadding) {
+                        if (this.cache.length > 16) {
+                            out = this.cache.slice(0, 16)
+                            this.cache = this.cache.slice(16)
+                            return out
+                        }
+                    } else {
+                        if (this.cache.length >= 16) {
+                            out = this.cache.slice(0, 16)
+                            this.cache = this.cache.slice(16)
+                            return out
+                        }
+                    }
+
+                    return null
+                }
+
+                Splitter.prototype.flush = function () {
+                    if (this.cache.length) return this.cache
+                }
+
+                function unpad(last) {
+                    var padded = last[15]
+                    if (padded < 1 || padded > 16) {
+                        throw new Error('unable to decrypt data')
+                    }
+                    var i = -1
+                    while (++i < padded) {
+                        if (last[(i + (16 - padded))] !== padded) {
+                            throw new Error('unable to decrypt data')
+                        }
+                    }
+                    if (padded === 16) return
+
+                    return last.slice(0, 16 - padded)
+                }
+
+                function createDecipheriv(suite, password, iv) {
+                    var config = MODES[suite.toLowerCase()]
+                    if (!config) throw new TypeError('invalid suite type')
+
+                    if (typeof iv === 'string') iv = Buffer.from(iv)
+                    if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError(
+                        'invalid iv length ' + iv.length)
+
+                    if (typeof password === 'string') password = Buffer.from(password)
+                    if (password.length !== config.key / 8) throw new TypeError('invalid key length ' +
+                        password.length)
+
+                    if (config.type === 'stream') {
+                        return new StreamCipher(config.module, password, iv, true)
+                    } else if (config.type === 'auth') {
+                        return new AuthCipher(config.module, password, iv, true)
+                    }
+
+                    return new Decipher(config.module, password, iv)
+                }
+
+                function createDecipher(suite, password) {
+                    var config = MODES[suite.toLowerCase()]
+                    if (!config) throw new TypeError('invalid suite type')
+
+                    var keys = ebtk(password, false, config.key, config.iv)
+                    return createDecipheriv(suite, keys.key, keys.iv)
+                }
+
+                exports.createDecipher = createDecipher
+                exports.createDecipheriv = createDecipheriv
+
+            }, {
+                "./aes": 27,
+                "./authCipher": 28,
+                "./modes": 40,
+                "./streamCipher": 43,
+                "cipher-base": 56,
+                "evp_bytestokey": 91,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            31: [function (require, module, exports) {
+                var MODES = require('./modes')
+                var AuthCipher = require('./authCipher')
+                var Buffer = require('safe-buffer').Buffer
+                var StreamCipher = require('./streamCipher')
+                var Transform = require('cipher-base')
+                var aes = require('./aes')
+                var ebtk = require('evp_bytestokey')
+                var inherits = require('inherits')
+
+                function Cipher(mode, key, iv) {
+                    Transform.call(this)
+
+                    this._cache = new Splitter()
+                    this._cipher = new aes.AES(key)
+                    this._prev = Buffer.from(iv)
+                    this._mode = mode
+                    this._autopadding = true
+                }
+
+                inherits(Cipher, Transform)
+
+                Cipher.prototype._update = function (data) {
+                    this._cache.add(data)
+                    var chunk
+                    var thing
+                    var out = []
+
+                    while ((chunk = this._cache.get())) {
+                        thing = this._mode.encrypt(this, chunk)
+                        out.push(thing)
+                    }
+
+                    return Buffer.concat(out)
+                }
+
+                var PADDING = Buffer.alloc(16, 0x10)
+
+                Cipher.prototype._final = function () {
+                    var chunk = this._cache.flush()
+                    if (this._autopadding) {
+                        chunk = this._mode.encrypt(this, chunk)
+                        this._cipher.scrub()
+                        return chunk
+                    }
+
+                    if (!chunk.equals(PADDING)) {
+                        this._cipher.scrub()
+                        throw new Error('data not multiple of block length')
+                    }
+                }
+
+                Cipher.prototype.setAutoPadding = function (setTo) {
+                    this._autopadding = !!setTo
+                    return this
+                }
+
+                function Splitter() {
+                    this.cache = Buffer.allocUnsafe(0)
+                }
+
+                Splitter.prototype.add = function (data) {
+                    this.cache = Buffer.concat([this.cache, data])
+                }
+
+                Splitter.prototype.get = function () {
+                    if (this.cache.length > 15) {
+                        var out = this.cache.slice(0, 16)
+                        this.cache = this.cache.slice(16)
+                        return out
+                    }
+                    return null
+                }
+
+                Splitter.prototype.flush = function () {
+                    var len = 16 - this.cache.length
+                    var padBuff = Buffer.allocUnsafe(len)
+
+                    var i = -1
+                    while (++i < len) {
+                        padBuff.writeUInt8(len, i)
+                    }
+
+                    return Buffer.concat([this.cache, padBuff])
+                }
+
+                function createCipheriv(suite, password, iv) {
+                    var config = MODES[suite.toLowerCase()]
+                    if (!config) throw new TypeError('invalid suite type')
+
+                    if (typeof password === 'string') password = Buffer.from(password)
+                    if (password.length !== config.key / 8) throw new TypeError('invalid key length ' +
+                        password.length)
+
+                    if (typeof iv === 'string') iv = Buffer.from(iv)
+                    if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError(
+                        'invalid iv length ' + iv.length)
+
+                    if (config.type === 'stream') {
+                        return new StreamCipher(config.module, password, iv)
+                    } else if (config.type === 'auth') {
+                        return new AuthCipher(config.module, password, iv)
+                    }
+
+                    return new Cipher(config.module, password, iv)
+                }
+
+                function createCipher(suite, password) {
+                    var config = MODES[suite.toLowerCase()]
+                    if (!config) throw new TypeError('invalid suite type')
+
+                    var keys = ebtk(password, false, config.key, config.iv)
+                    return createCipheriv(suite, keys.key, keys.iv)
+                }
+
+                exports.createCipheriv = createCipheriv
+                exports.createCipher = createCipher
+
+            }, {
+                "./aes": 27,
+                "./authCipher": 28,
+                "./modes": 40,
+                "./streamCipher": 43,
+                "cipher-base": 56,
+                "evp_bytestokey": 91,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            32: [function (require, module, exports) {
+                var Buffer = require('safe-buffer').Buffer
+                var ZEROES = Buffer.alloc(16, 0)
+
+                function toArray(buf) {
+                    return [
+                        buf.readUInt32BE(0),
+                        buf.readUInt32BE(4),
+                        buf.readUInt32BE(8),
+                        buf.readUInt32BE(12)
+                    ]
+                }
+
+                function fromArray(out) {
+                    var buf = Buffer.allocUnsafe(16)
+                    buf.writeUInt32BE(out[0] >>> 0, 0)
+                    buf.writeUInt32BE(out[1] >>> 0, 4)
+                    buf.writeUInt32BE(out[2] >>> 0, 8)
+                    buf.writeUInt32BE(out[3] >>> 0, 12)
+                    return buf
+                }
+
+                function GHASH(key) {
+                    this.h = key
+                    this.state = Buffer.alloc(16, 0)
+                    this.cache = Buffer.allocUnsafe(0)
+                }
+
+                // from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html
+                // by Juho Vähä-Herttua
+                GHASH.prototype.ghash = function (block) {
+                    var i = -1
+                    while (++i < block.length) {
+                        this.state[i] ^= block[i]
+                    }
+                    this._multiply()
+                }
+
+                GHASH.prototype._multiply = function () {
+                    var Vi = toArray(this.h)
+                    var Zi = [0, 0, 0, 0]
+                    var j, xi, lsbVi
+                    var i = -1
+                    while (++i < 128) {
+                        xi = (this.state[~~(i / 8)] & (1 << (7 - (i % 8)))) !== 0
+                        if (xi) {
+                            // Z_i+1 = Z_i ^ V_i
+                            Zi[0] ^= Vi[0]
+                            Zi[1] ^= Vi[1]
+                            Zi[2] ^= Vi[2]
+                            Zi[3] ^= Vi[3]
+                        }
+
+                        // Store the value of LSB(V_i)
+                        lsbVi = (Vi[3] & 1) !== 0
+
+                        // V_i+1 = V_i >> 1
+                        for (j = 3; j > 0; j--) {
+                            Vi[j] = (Vi[j] >>> 1) | ((Vi[j - 1] & 1) << 31)
+                        }
+                        Vi[0] = Vi[0] >>> 1
+
+                        // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R
+                        if (lsbVi) {
+                            Vi[0] = Vi[0] ^ (0xe1 << 24)
+                        }
+                    }
+                    this.state = fromArray(Zi)
+                }
+
+                GHASH.prototype.update = function (buf) {
+                    this.cache = Buffer.concat([this.cache, buf])
+                    var chunk
+                    while (this.cache.length >= 16) {
+                        chunk = this.cache.slice(0, 16)
+                        this.cache = this.cache.slice(16)
+                        this.ghash(chunk)
+                    }
+                }
+
+                GHASH.prototype.final = function (abl, bl) {
+                    if (this.cache.length) {
+                        this.ghash(Buffer.concat([this.cache, ZEROES], 16))
+                    }
+
+                    this.ghash(fromArray([0, abl, 0, bl]))
+                    return this.state
+                }
+
+                module.exports = GHASH
+
+            }, {
+                "safe-buffer": 148
+            }],
+            33: [function (require, module, exports) {
+                function incr32(iv) {
+                    var len = iv.length
+                    var item
+                    while (len--) {
+                        item = iv.readUInt8(len)
+                        if (item === 255) {
+                            iv.writeUInt8(0, len)
+                        } else {
+                            item++
+                            iv.writeUInt8(item, len)
+                            break
+                        }
+                    }
+                }
+                module.exports = incr32
+
+            }, {}],
+            34: [function (require, module, exports) {
+                var xor = require('buffer-xor')
+
+                exports.encrypt = function (self, block) {
+                    var data = xor(block, self._prev)
+
+                    self._prev = self._cipher.encryptBlock(data)
+                    return self._prev
+                }
+
+                exports.decrypt = function (self, block) {
+                    var pad = self._prev
+
+                    self._prev = block
+                    var out = self._cipher.decryptBlock(block)
+
+                    return xor(out, pad)
+                }
+
+            }, {
+                "buffer-xor": 54
+            }],
+            35: [function (require, module, exports) {
+                var Buffer = require('safe-buffer').Buffer
+                var xor = require('buffer-xor')
+
+                function encryptStart(self, data, decrypt) {
+                    var len = data.length
+                    var out = xor(data, self._cache)
+                    self._cache = self._cache.slice(len)
+                    self._prev = Buffer.concat([self._prev, decrypt ? data : out])
+                    return out
+                }
+
+                exports.encrypt = function (self, data, decrypt) {
+                    var out = Buffer.allocUnsafe(0)
+                    var len
+
+                    while (data.length) {
+                        if (self._cache.length === 0) {
+                            self._cache = self._cipher.encryptBlock(self._prev)
+                            self._prev = Buffer.allocUnsafe(0)
+                        }
+
+                        if (self._cache.length <= data.length) {
+                            len = self._cache.length
+                            out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)])
+                            data = data.slice(len)
+                        } else {
+                            out = Buffer.concat([out, encryptStart(self, data, decrypt)])
+                            break
+                        }
+                    }
+
+                    return out
+                }
+
+            }, {
+                "buffer-xor": 54,
+                "safe-buffer": 148
+            }],
+            36: [function (require, module, exports) {
+                var Buffer = require('safe-buffer').Buffer
+
+                function encryptByte(self, byteParam, decrypt) {
+                    var pad
+                    var i = -1
+                    var len = 8
+                    var out = 0
+                    var bit, value
+                    while (++i < len) {
+                        pad = self._cipher.encryptBlock(self._prev)
+                        bit = (byteParam & (1 << (7 - i))) ? 0x80 : 0
+                        value = pad[0] ^ bit
+                        out += ((value & 0x80) >> (i % 8))
+                        self._prev = shiftIn(self._prev, decrypt ? bit : value)
+                    }
+                    return out
+                }
+
+                function shiftIn(buffer, value) {
+                    var len = buffer.length
+                    var i = -1
+                    var out = Buffer.allocUnsafe(buffer.length)
+                    buffer = Buffer.concat([buffer, Buffer.from([value])])
+
+                    while (++i < len) {
+                        out[i] = buffer[i] << 1 | buffer[i + 1] >> (7)
+                    }
+
+                    return out
+                }
+
+                exports.encrypt = function (self, chunk, decrypt) {
+                    var len = chunk.length
+                    var out = Buffer.allocUnsafe(len)
+                    var i = -1
+
+                    while (++i < len) {
+                        out[i] = encryptByte(self, chunk[i], decrypt)
+                    }
+
+                    return out
+                }
+
+            }, {
+                "safe-buffer": 148
+            }],
+            37: [function (require, module, exports) {
+                var Buffer = require('safe-buffer').Buffer
+
+                function encryptByte(self, byteParam, decrypt) {
+                    var pad = self._cipher.encryptBlock(self._prev)
+                    var out = pad[0] ^ byteParam
+
+                    self._prev = Buffer.concat([
+                        self._prev.slice(1),
+                        Buffer.from([decrypt ? byteParam : out])
+                    ])
+
+                    return out
+                }
+
+                exports.encrypt = function (self, chunk, decrypt) {
+                    var len = chunk.length
+                    var out = Buffer.allocUnsafe(len)
+                    var i = -1
+
+                    while (++i < len) {
+                        out[i] = encryptByte(self, chunk[i], decrypt)
+                    }
+
+                    return out
+                }
+
+            }, {
+                "safe-buffer": 148
+            }],
+            38: [function (require, module, exports) {
+                var xor = require('buffer-xor')
+                var Buffer = require('safe-buffer').Buffer
+                var incr32 = require('../incr32')
+
+                function getBlock(self) {
+                    var out = self._cipher.encryptBlockRaw(self._prev)
+                    incr32(self._prev)
+                    return out
+                }
+
+                var blockSize = 16
+                exports.encrypt = function (self, chunk) {
+                    var chunkNum = Math.ceil(chunk.length / blockSize)
+                    var start = self._cache.length
+                    self._cache = Buffer.concat([
+                        self._cache,
+                        Buffer.allocUnsafe(chunkNum * blockSize)
+                    ])
+                    for (var i = 0; i < chunkNum; i++) {
+                        var out = getBlock(self)
+                        var offset = start + i * blockSize
+                        self._cache.writeUInt32BE(out[0], offset + 0)
+                        self._cache.writeUInt32BE(out[1], offset + 4)
+                        self._cache.writeUInt32BE(out[2], offset + 8)
+                        self._cache.writeUInt32BE(out[3], offset + 12)
+                    }
+                    var pad = self._cache.slice(0, chunk.length)
+                    self._cache = self._cache.slice(chunk.length)
+                    return xor(chunk, pad)
+                }
+
+            }, {
+                "../incr32": 33,
+                "buffer-xor": 54,
+                "safe-buffer": 148
+            }],
+            39: [function (require, module, exports) {
+                exports.encrypt = function (self, block) {
+                    return self._cipher.encryptBlock(block)
+                }
+
+                exports.decrypt = function (self, block) {
+                    return self._cipher.decryptBlock(block)
+                }
+
+            }, {}],
+            40: [function (require, module, exports) {
+                var modeModules = {
+                    ECB: require('./ecb'),
+                    CBC: require('./cbc'),
+                    CFB: require('./cfb'),
+                    CFB8: require('./cfb8'),
+                    CFB1: require('./cfb1'),
+                    OFB: require('./ofb'),
+                    CTR: require('./ctr'),
+                    GCM: require('./ctr')
+                }
+
+                var modes = require('./list.json')
+
+                for (var key in modes) {
+                    modes[key].module = modeModules[modes[key].mode]
+                }
+
+                module.exports = modes
+
+            }, {
+                "./cbc": 34,
+                "./cfb": 35,
+                "./cfb1": 36,
+                "./cfb8": 37,
+                "./ctr": 38,
+                "./ecb": 39,
+                "./list.json": 41,
+                "./ofb": 42
+            }],
+            41: [function (require, module, exports) {
+                module.exports = {
+                    "aes-128-ecb": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 0,
+                        "mode": "ECB",
+                        "type": "block"
+                    },
+                    "aes-192-ecb": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 0,
+                        "mode": "ECB",
+                        "type": "block"
+                    },
+                    "aes-256-ecb": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 0,
+                        "mode": "ECB",
+                        "type": "block"
+                    },
+                    "aes-128-cbc": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 16,
+                        "mode": "CBC",
+                        "type": "block"
+                    },
+                    "aes-192-cbc": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 16,
+                        "mode": "CBC",
+                        "type": "block"
+                    },
+                    "aes-256-cbc": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 16,
+                        "mode": "CBC",
+                        "type": "block"
+                    },
+                    "aes128": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 16,
+                        "mode": "CBC",
+                        "type": "block"
+                    },
+                    "aes192": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 16,
+                        "mode": "CBC",
+                        "type": "block"
+                    },
+                    "aes256": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 16,
+                        "mode": "CBC",
+                        "type": "block"
+                    },
+                    "aes-128-cfb": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 16,
+                        "mode": "CFB",
+                        "type": "stream"
+                    },
+                    "aes-192-cfb": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 16,
+                        "mode": "CFB",
+                        "type": "stream"
+                    },
+                    "aes-256-cfb": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 16,
+                        "mode": "CFB",
+                        "type": "stream"
+                    },
+                    "aes-128-cfb8": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 16,
+                        "mode": "CFB8",
+                        "type": "stream"
+                    },
+                    "aes-192-cfb8": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 16,
+                        "mode": "CFB8",
+                        "type": "stream"
+                    },
+                    "aes-256-cfb8": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 16,
+                        "mode": "CFB8",
+                        "type": "stream"
+                    },
+                    "aes-128-cfb1": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 16,
+                        "mode": "CFB1",
+                        "type": "stream"
+                    },
+                    "aes-192-cfb1": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 16,
+                        "mode": "CFB1",
+                        "type": "stream"
+                    },
+                    "aes-256-cfb1": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 16,
+                        "mode": "CFB1",
+                        "type": "stream"
+                    },
+                    "aes-128-ofb": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 16,
+                        "mode": "OFB",
+                        "type": "stream"
+                    },
+                    "aes-192-ofb": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 16,
+                        "mode": "OFB",
+                        "type": "stream"
+                    },
+                    "aes-256-ofb": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 16,
+                        "mode": "OFB",
+                        "type": "stream"
+                    },
+                    "aes-128-ctr": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 16,
+                        "mode": "CTR",
+                        "type": "stream"
+                    },
+                    "aes-192-ctr": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 16,
+                        "mode": "CTR",
+                        "type": "stream"
+                    },
+                    "aes-256-ctr": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 16,
+                        "mode": "CTR",
+                        "type": "stream"
+                    },
+                    "aes-128-gcm": {
+                        "cipher": "AES",
+                        "key": 128,
+                        "iv": 12,
+                        "mode": "GCM",
+                        "type": "auth"
+                    },
+                    "aes-192-gcm": {
+                        "cipher": "AES",
+                        "key": 192,
+                        "iv": 12,
+                        "mode": "GCM",
+                        "type": "auth"
+                    },
+                    "aes-256-gcm": {
+                        "cipher": "AES",
+                        "key": 256,
+                        "iv": 12,
+                        "mode": "GCM",
+                        "type": "auth"
+                    }
+                }
+
+            }, {}],
+            42: [function (require, module, exports) {
+                (function (Buffer) {
+                    var xor = require('buffer-xor')
+
+                    function getBlock(self) {
+                        self._prev = self._cipher.encryptBlock(self._prev)
+                        return self._prev
+                    }
+
+                    exports.encrypt = function (self, chunk) {
+                        while (self._cache.length < chunk.length) {
+                            self._cache = Buffer.concat([self._cache, getBlock(self)])
+                        }
+
+                        var pad = self._cache.slice(0, chunk.length)
+                        self._cache = self._cache.slice(chunk.length)
+                        return xor(chunk, pad)
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "buffer": 55,
+                "buffer-xor": 54
+            }],
+            43: [function (require, module, exports) {
+                var aes = require('./aes')
+                var Buffer = require('safe-buffer').Buffer
+                var Transform = require('cipher-base')
+                var inherits = require('inherits')
+
+                function StreamCipher(mode, key, iv, decrypt) {
+                    Transform.call(this)
+
+                    this._cipher = new aes.AES(key)
+                    this._prev = Buffer.from(iv)
+                    this._cache = Buffer.allocUnsafe(0)
+                    this._secCache = Buffer.allocUnsafe(0)
+                    this._decrypt = decrypt
+                    this._mode = mode
+                }
+
+                inherits(StreamCipher, Transform)
+
+                StreamCipher.prototype._update = function (chunk) {
+                    return this._mode.encrypt(this, chunk, this._decrypt)
+                }
+
+                StreamCipher.prototype._final = function () {
+                    this._cipher.scrub()
+                }
+
+                module.exports = StreamCipher
+
+            }, {
+                "./aes": 27,
+                "cipher-base": 56,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            44: [function (require, module, exports) {
+                var DES = require('browserify-des')
+                var aes = require('browserify-aes/browser')
+                var aesModes = require('browserify-aes/modes')
+                var desModes = require('browserify-des/modes')
+                var ebtk = require('evp_bytestokey')
+
+                function createCipher(suite, password) {
+                    suite = suite.toLowerCase()
+
+                    var keyLen, ivLen
+                    if (aesModes[suite]) {
+                        keyLen = aesModes[suite].key
+                        ivLen = aesModes[suite].iv
+                    } else if (desModes[suite]) {
+                        keyLen = desModes[suite].key * 8
+                        ivLen = desModes[suite].iv
+                    } else {
+                        throw new TypeError('invalid suite type')
+                    }
+
+                    var keys = ebtk(password, false, keyLen, ivLen)
+                    return createCipheriv(suite, keys.key, keys.iv)
+                }
+
+                function createDecipher(suite, password) {
+                    suite = suite.toLowerCase()
+
+                    var keyLen, ivLen
+                    if (aesModes[suite]) {
+                        keyLen = aesModes[suite].key
+                        ivLen = aesModes[suite].iv
+                    } else if (desModes[suite]) {
+                        keyLen = desModes[suite].key * 8
+                        ivLen = desModes[suite].iv
+                    } else {
+                        throw new TypeError('invalid suite type')
+                    }
+
+                    var keys = ebtk(password, false, keyLen, ivLen)
+                    return createDecipheriv(suite, keys.key, keys.iv)
+                }
+
+                function createCipheriv(suite, key, iv) {
+                    suite = suite.toLowerCase()
+                    if (aesModes[suite]) return aes.createCipheriv(suite, key, iv)
+                    if (desModes[suite]) return new DES({
+                        key: key,
+                        iv: iv,
+                        mode: suite
+                    })
+
+                    throw new TypeError('invalid suite type')
+                }
+
+                function createDecipheriv(suite, key, iv) {
+                    suite = suite.toLowerCase()
+                    if (aesModes[suite]) return aes.createDecipheriv(suite, key, iv)
+                    if (desModes[suite]) return new DES({
+                        key: key,
+                        iv: iv,
+                        mode: suite,
+                        decrypt: true
+                    })
+
+                    throw new TypeError('invalid suite type')
+                }
+
+                function getCiphers() {
+                    return Object.keys(desModes).concat(aes.getCiphers())
+                }
+
+                exports.createCipher = exports.Cipher = createCipher
+                exports.createCipheriv = exports.Cipheriv = createCipheriv
+                exports.createDecipher = exports.Decipher = createDecipher
+                exports.createDecipheriv = exports.Decipheriv = createDecipheriv
+                exports.listCiphers = exports.getCiphers = getCiphers
+
+            }, {
+                "browserify-aes/browser": 29,
+                "browserify-aes/modes": 40,
+                "browserify-des": 45,
+                "browserify-des/modes": 46,
+                "evp_bytestokey": 91
+            }],
+            45: [function (require, module, exports) {
+                (function (Buffer) {
+                    var CipherBase = require('cipher-base')
+                    var des = require('des.js')
+                    var inherits = require('inherits')
+
+                    var modes = {
+                        'des-ede3-cbc': des.CBC.instantiate(des.EDE),
+                        'des-ede3': des.EDE,
+                        'des-ede-cbc': des.CBC.instantiate(des.EDE),
+                        'des-ede': des.EDE,
+                        'des-cbc': des.CBC.instantiate(des.DES),
+                        'des-ecb': des.DES
+                    }
+                    modes.des = modes['des-cbc']
+                    modes.des3 = modes['des-ede3-cbc']
+                    module.exports = DES
+                    inherits(DES, CipherBase)
+
+                    function DES(opts) {
+                        CipherBase.call(this)
+                        var modeName = opts.mode.toLowerCase()
+                        var mode = modes[modeName]
+                        var type
+                        if (opts.decrypt) {
+                            type = 'decrypt'
+                        } else {
+                            type = 'encrypt'
+                        }
+                        var key = opts.key
+                        if (modeName === 'des-ede' || modeName === 'des-ede-cbc') {
+                            key = Buffer.concat([key, key.slice(0, 8)])
+                        }
+                        var iv = opts.iv
+                        this._des = mode.create({
+                            key: key,
+                            iv: iv,
+                            type: type
+                        })
+                    }
+                    DES.prototype._update = function (data) {
+                        return new Buffer(this._des.update(data))
+                    }
+                    DES.prototype._final = function () {
+                        return new Buffer(this._des.final())
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "buffer": 55,
+                "cipher-base": 56,
+                "des.js": 64,
+                "inherits": 107
+            }],
+            46: [function (require, module, exports) {
+                exports['des-ecb'] = {
+                    key: 8,
+                    iv: 0
+                }
+                exports['des-cbc'] = exports.des = {
+                    key: 8,
+                    iv: 8
+                }
+                exports['des-ede3-cbc'] = exports.des3 = {
+                    key: 24,
+                    iv: 8
+                }
+                exports['des-ede3'] = {
+                    key: 24,
+                    iv: 0
+                }
+                exports['des-ede-cbc'] = {
+                    key: 16,
+                    iv: 8
+                }
+                exports['des-ede'] = {
+                    key: 16,
+                    iv: 0
+                }
+
+            }, {}],
+            47: [function (require, module, exports) {
+                (function (Buffer) {
+                    var bn = require('bn.js');
+                    var randomBytes = require('randombytes');
+                    module.exports = crt;
+
+                    function blind(priv) {
+                        var r = getr(priv);
+                        var blinder = r.toRed(bn.mont(priv.modulus))
+                            .redPow(new bn(priv.publicExponent)).fromRed();
+                        return {
+                            blinder: blinder,
+                            unblinder: r.invm(priv.modulus)
+                        };
+                    }
+
+                    function crt(msg, priv) {
+                        var blinds = blind(priv);
+                        var len = priv.modulus.byteLength();
+                        var mod = bn.mont(priv.modulus);
+                        var blinded = new bn(msg).mul(blinds.blinder).umod(priv.modulus);
+                        var c1 = blinded.toRed(bn.mont(priv.prime1));
+                        var c2 = blinded.toRed(bn.mont(priv.prime2));
+                        var qinv = priv.coefficient;
+                        var p = priv.prime1;
+                        var q = priv.prime2;
+                        var m1 = c1.redPow(priv.exponent1);
+                        var m2 = c2.redPow(priv.exponent2);
+                        m1 = m1.fromRed();
+                        m2 = m2.fromRed();
+                        var h = m1.isub(m2).imul(qinv).umod(p);
+                        h.imul(q);
+                        m2.iadd(h);
+                        return new Buffer(m2.imul(blinds.unblinder).umod(priv.modulus).toArray(false,
+                            len));
+                    }
+                    crt.getr = getr;
+
+                    function getr(priv) {
+                        var len = priv.modulus.byteLength();
+                        var r = new bn(randomBytes(len));
+                        while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2)) {
+                            r = new bn(randomBytes(len));
+                        }
+                        return r;
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "bn.js": 24,
+                "buffer": 55,
+                "randombytes": 132
+            }],
+            48: [function (require, module, exports) {
+                module.exports = require('./browser/algorithms.json')
+
+            }, {
+                "./browser/algorithms.json": 49
+            }],
+            49: [function (require, module, exports) {
+                module.exports = {
+                    "sha224WithRSAEncryption": {
+                        "sign": "rsa",
+                        "hash": "sha224",
+                        "id": "302d300d06096086480165030402040500041c"
+                    },
+                    "RSA-SHA224": {
+                        "sign": "ecdsa/rsa",
+                        "hash": "sha224",
+                        "id": "302d300d06096086480165030402040500041c"
+                    },
+                    "sha256WithRSAEncryption": {
+                        "sign": "rsa",
+                        "hash": "sha256",
+                        "id": "3031300d060960864801650304020105000420"
+                    },
+                    "RSA-SHA256": {
+                        "sign": "ecdsa/rsa",
+                        "hash": "sha256",
+                        "id": "3031300d060960864801650304020105000420"
+                    },
+                    "sha384WithRSAEncryption": {
+                        "sign": "rsa",
+                        "hash": "sha384",
+                        "id": "3041300d060960864801650304020205000430"
+                    },
+                    "RSA-SHA384": {
+                        "sign": "ecdsa/rsa",
+                        "hash": "sha384",
+                        "id": "3041300d060960864801650304020205000430"
+                    },
+                    "sha512WithRSAEncryption": {
+                        "sign": "rsa",
+                        "hash": "sha512",
+                        "id": "3051300d060960864801650304020305000440"
+                    },
+                    "RSA-SHA512": {
+                        "sign": "ecdsa/rsa",
+                        "hash": "sha512",
+                        "id": "3051300d060960864801650304020305000440"
+                    },
+                    "RSA-SHA1": {
+                        "sign": "rsa",
+                        "hash": "sha1",
+                        "id": "3021300906052b0e03021a05000414"
+                    },
+                    "ecdsa-with-SHA1": {
+                        "sign": "ecdsa",
+                        "hash": "sha1",
+                        "id": ""
+                    },
+                    "sha256": {
+                        "sign": "ecdsa",
+                        "hash": "sha256",
+                        "id": ""
+                    },
+                    "sha224": {
+                        "sign": "ecdsa",
+                        "hash": "sha224",
+                        "id": ""
+                    },
+                    "sha384": {
+                        "sign": "ecdsa",
+                        "hash": "sha384",
+                        "id": ""
+                    },
+                    "sha512": {
+                        "sign": "ecdsa",
+                        "hash": "sha512",
+                        "id": ""
+                    },
+                    "DSA-SHA": {
+                        "sign": "dsa",
+                        "hash": "sha1",
+                        "id": ""
+                    },
+                    "DSA-SHA1": {
+                        "sign": "dsa",
+                        "hash": "sha1",
+                        "id": ""
+                    },
+                    "DSA": {
+                        "sign": "dsa",
+                        "hash": "sha1",
+                        "id": ""
+                    },
+                    "DSA-WITH-SHA224": {
+                        "sign": "dsa",
+                        "hash": "sha224",
+                        "id": ""
+                    },
+                    "DSA-SHA224": {
+                        "sign": "dsa",
+                        "hash": "sha224",
+                        "id": ""
+                    },
+                    "DSA-WITH-SHA256": {
+                        "sign": "dsa",
+                        "hash": "sha256",
+                        "id": ""
+                    },
+                    "DSA-SHA256": {
+                        "sign": "dsa",
+                        "hash": "sha256",
+                        "id": ""
+                    },
+                    "DSA-WITH-SHA384": {
+                        "sign": "dsa",
+                        "hash": "sha384",
+                        "id": ""
+                    },
+                    "DSA-SHA384": {
+                        "sign": "dsa",
+                        "hash": "sha384",
+                        "id": ""
+                    },
+                    "DSA-WITH-SHA512": {
+                        "sign": "dsa",
+                        "hash": "sha512",
+                        "id": ""
+                    },
+                    "DSA-SHA512": {
+                        "sign": "dsa",
+                        "hash": "sha512",
+                        "id": ""
+                    },
+                    "DSA-RIPEMD160": {
+                        "sign": "dsa",
+                        "hash": "rmd160",
+                        "id": ""
+                    },
+                    "ripemd160WithRSA": {
+                        "sign": "rsa",
+                        "hash": "rmd160",
+                        "id": "3021300906052b2403020105000414"
+                    },
+                    "RSA-RIPEMD160": {
+                        "sign": "rsa",
+                        "hash": "rmd160",
+                        "id": "3021300906052b2403020105000414"
+                    },
+                    "md5WithRSAEncryption": {
+                        "sign": "rsa",
+                        "hash": "md5",
+                        "id": "3020300c06082a864886f70d020505000410"
+                    },
+                    "RSA-MD5": {
+                        "sign": "rsa",
+                        "hash": "md5",
+                        "id": "3020300c06082a864886f70d020505000410"
+                    }
+                }
+
+            }, {}],
+            50: [function (require, module, exports) {
+                module.exports = {
+                    "1.3.132.0.10": "secp256k1",
+                    "1.3.132.0.33": "p224",
+                    "1.2.840.10045.3.1.1": "p192",
+                    "1.2.840.10045.3.1.7": "p256",
+                    "1.3.132.0.34": "p384",
+                    "1.3.132.0.35": "p521"
+                }
+
+            }, {}],
+            51: [function (require, module, exports) {
+                (function (Buffer) {
+                    var createHash = require('create-hash')
+                    var stream = require('stream')
+                    var inherits = require('inherits')
+                    var sign = require('./sign')
+                    var verify = require('./verify')
+
+                    var algorithms = require('./algorithms.json')
+                    Object.keys(algorithms).forEach(function (key) {
+                        algorithms[key].id = new Buffer(algorithms[key].id, 'hex')
+                        algorithms[key.toLowerCase()] = algorithms[key]
+                    })
+
+                    function Sign(algorithm) {
+                        stream.Writable.call(this)
+
+                        var data = algorithms[algorithm]
+                        if (!data) throw new Error('Unknown message digest')
+
+                        this._hashType = data.hash
+                        this._hash = createHash(data.hash)
+                        this._tag = data.id
+                        this._signType = data.sign
+                    }
+                    inherits(Sign, stream.Writable)
+
+                    Sign.prototype._write = function _write(data, _, done) {
+                        this._hash.update(data)
+                        done()
+                    }
+
+                    Sign.prototype.update = function update(data, enc) {
+                        if (typeof data === 'string') data = new Buffer(data, enc)
+
+                        this._hash.update(data)
+                        return this
+                    }
+
+                    Sign.prototype.sign = function signMethod(key, enc) {
+                        this.end()
+                        var hash = this._hash.digest()
+                        var sig = sign(hash, key, this._hashType, this._signType, this._tag)
+
+                        return enc ? sig.toString(enc) : sig
+                    }
+
+                    function Verify(algorithm) {
+                        stream.Writable.call(this)
+
+                        var data = algorithms[algorithm]
+                        if (!data) throw new Error('Unknown message digest')
+
+                        this._hash = createHash(data.hash)
+                        this._tag = data.id
+                        this._signType = data.sign
+                    }
+                    inherits(Verify, stream.Writable)
+
+                    Verify.prototype._write = function _write(data, _, done) {
+                        this._hash.update(data)
+                        done()
+                    }
+
+                    Verify.prototype.update = function update(data, enc) {
+                        if (typeof data === 'string') data = new Buffer(data, enc)
+
+                        this._hash.update(data)
+                        return this
+                    }
+
+                    Verify.prototype.verify = function verifyMethod(key, sig, enc) {
+                        if (typeof sig === 'string') sig = new Buffer(sig, enc)
+
+                        this.end()
+                        var hash = this._hash.digest()
+                        return verify(sig, hash, key, this._signType, this._tag)
+                    }
+
+                    function createSign(algorithm) {
+                        return new Sign(algorithm)
+                    }
+
+                    function createVerify(algorithm) {
+                        return new Verify(algorithm)
+                    }
+
+                    module.exports = {
+                        Sign: createSign,
+                        Verify: createVerify,
+                        createSign: createSign,
+                        createVerify: createVerify
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "./algorithms.json": 49,
+                "./sign": 52,
+                "./verify": 53,
+                "buffer": 55,
+                "create-hash": 59,
+                "inherits": 107,
+                "stream": 157
+            }],
+            52: [function (require, module, exports) {
+                (function (Buffer) {
+                    // much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
+                    var createHmac = require('create-hmac')
+                    var crt = require('browserify-rsa')
+                    var EC = require('elliptic').ec
+                    var BN = require('bn.js')
+                    var parseKeys = require('parse-asn1')
+                    var curves = require('./curves.json')
+
+                    function sign(hash, key, hashType, signType, tag) {
+                        var priv = parseKeys(key)
+                        if (priv.curve) {
+                            // rsa keys can be interpreted as ecdsa ones in openssl
+                            if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error(
+                                'wrong private key type')
+                            return ecSign(hash, priv)
+                        } else if (priv.type === 'dsa') {
+                            if (signType !== 'dsa') throw new Error('wrong private key type')
+                            return dsaSign(hash, priv, hashType)
+                        } else {
+                            if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error(
+                                'wrong private key type')
+                        }
+                        hash = Buffer.concat([tag, hash])
+                        var len = priv.modulus.byteLength()
+                        var pad = [0, 1]
+                        while (hash.length + pad.length + 1 < len) pad.push(0xff)
+                        pad.push(0x00)
+                        var i = -1
+                        while (++i < hash.length) pad.push(hash[i])
+
+                        var out = crt(pad, priv)
+                        return out
+                    }
+
+                    function ecSign(hash, priv) {
+                        var curveId = curves[priv.curve.join('.')]
+                        if (!curveId) throw new Error('unknown curve ' + priv.curve.join('.'))
+
+                        var curve = new EC(curveId)
+                        var key = curve.keyFromPrivate(priv.privateKey)
+                        var out = key.sign(hash)
+
+                        return new Buffer(out.toDER())
+                    }
+
+                    function dsaSign(hash, priv, algo) {
+                        var x = priv.params.priv_key
+                        var p = priv.params.p
+                        var q = priv.params.q
+                        var g = priv.params.g
+                        var r = new BN(0)
+                        var k
+                        var H = bits2int(hash, q).mod(q)
+                        var s = false
+                        var kv = getKey(x, q, hash, algo)
+                        while (s === false) {
+                            k = makeKey(q, kv, algo)
+                            r = makeR(g, k, p, q)
+                            s = k.invm(q).imul(H.add(x.mul(r))).mod(q)
+                            if (s.cmpn(0) === 0) {
+                                s = false
+                                r = new BN(0)
+                            }
+                        }
+                        return toDER(r, s)
+                    }
+
+                    function toDER(r, s) {
+                        r = r.toArray()
+                        s = s.toArray()
+
+                        // Pad values
+                        if (r[0] & 0x80) r = [0].concat(r)
+                        if (s[0] & 0x80) s = [0].concat(s)
+
+                        var total = r.length + s.length + 4
+                        var res = [0x30, total, 0x02, r.length]
+                        res = res.concat(r, [0x02, s.length], s)
+                        return new Buffer(res)
+                    }
+
+                    function getKey(x, q, hash, algo) {
+                        x = new Buffer(x.toArray())
+                        if (x.length < q.byteLength()) {
+                            var zeros = new Buffer(q.byteLength() - x.length)
+                            zeros.fill(0)
+                            x = Buffer.concat([zeros, x])
+                        }
+                        var hlen = hash.length
+                        var hbits = bits2octets(hash, q)
+                        var v = new Buffer(hlen)
+                        v.fill(1)
+                        var k = new Buffer(hlen)
+                        k.fill(0)
+                        k = createHmac(algo, k).update(v).update(new Buffer([0])).update(x).update(
+                            hbits).digest()
+                        v = createHmac(algo, k).update(v).digest()
+                        k = createHmac(algo, k).update(v).update(new Buffer([1])).update(x).update(
+                            hbits).digest()
+                        v = createHmac(algo, k).update(v).digest()
+                        return {
+                            k: k,
+                            v: v
+                        }
+                    }
+
+                    function bits2int(obits, q) {
+                        var bits = new BN(obits)
+                        var shift = (obits.length << 3) - q.bitLength()
+                        if (shift > 0) bits.ishrn(shift)
+                        return bits
+                    }
+
+                    function bits2octets(bits, q) {
+                        bits = bits2int(bits, q)
+                        bits = bits.mod(q)
+                        var out = new Buffer(bits.toArray())
+                        if (out.length < q.byteLength()) {
+                            var zeros = new Buffer(q.byteLength() - out.length)
+                            zeros.fill(0)
+                            out = Buffer.concat([zeros, out])
+                        }
+                        return out
+                    }
+
+                    function makeKey(q, kv, algo) {
+                        var t
+                        var k
+
+                        do {
+                            t = new Buffer(0)
+
+                            while (t.length * 8 < q.bitLength()) {
+                                kv.v = createHmac(algo, kv.k).update(kv.v).digest()
+                                t = Buffer.concat([t, kv.v])
+                            }
+
+                            k = bits2int(t, q)
+                            kv.k = createHmac(algo, kv.k).update(kv.v).update(new Buffer([0])).digest()
+                            kv.v = createHmac(algo, kv.k).update(kv.v).digest()
+                        } while (k.cmp(q) !== -1)
+
+                        return k
+                    }
+
+                    function makeR(g, k, p, q) {
+                        return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q)
+                    }
+
+                    module.exports = sign
+                    module.exports.getKey = getKey
+                    module.exports.makeKey = makeKey
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "./curves.json": 50,
+                "bn.js": 24,
+                "browserify-rsa": 47,
+                "buffer": 55,
+                "create-hmac": 61,
+                "elliptic": 74,
+                "parse-asn1": 118
+            }],
+            53: [function (require, module, exports) {
+                (function (Buffer) {
+                    // much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
+                    var BN = require('bn.js')
+                    var EC = require('elliptic').ec
+                    var parseKeys = require('parse-asn1')
+                    var curves = require('./curves.json')
+
+                    function verify(sig, hash, key, signType, tag) {
+                        var pub = parseKeys(key)
+                        if (pub.type === 'ec') {
+                            // rsa keys can be interpreted as ecdsa ones in openssl
+                            if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error(
+                                'wrong public key type')
+                            return ecVerify(sig, hash, pub)
+                        } else if (pub.type === 'dsa') {
+                            if (signType !== 'dsa') throw new Error('wrong public key type')
+                            return dsaVerify(sig, hash, pub)
+                        } else {
+                            if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error(
+                                'wrong public key type')
+                        }
+                        hash = Buffer.concat([tag, hash])
+                        var len = pub.modulus.byteLength()
+                        var pad = [1]
+                        var padNum = 0
+                        while (hash.length + pad.length + 2 < len) {
+                            pad.push(0xff)
+                            padNum++
+                        }
+                        pad.push(0x00)
+                        var i = -1
+                        while (++i < hash.length) {
+                            pad.push(hash[i])
+                        }
+                        pad = new Buffer(pad)
+                        var red = BN.mont(pub.modulus)
+                        sig = new BN(sig).toRed(red)
+
+                        sig = sig.redPow(new BN(pub.publicExponent))
+                        sig = new Buffer(sig.fromRed().toArray())
+                        var out = padNum < 8 ? 1 : 0
+                        len = Math.min(sig.length, pad.length)
+                        if (sig.length !== pad.length) out = 1
+
+                        i = -1
+                        while (++i < len) out |= sig[i] ^ pad[i]
+                        return out === 0
+                    }
+
+                    function ecVerify(sig, hash, pub) {
+                        var curveId = curves[pub.data.algorithm.curve.join('.')]
+                        if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join(
+                            '.'))
+
+                        var curve = new EC(curveId)
+                        var pubkey = pub.data.subjectPrivateKey.data
+
+                        return curve.verify(hash, sig, pubkey)
+                    }
+
+                    function dsaVerify(sig, hash, pub) {
+                        var p = pub.data.p
+                        var q = pub.data.q
+                        var g = pub.data.g
+                        var y = pub.data.pub_key
+                        var unpacked = parseKeys.signature.decode(sig, 'der')
+                        var s = unpacked.s
+                        var r = unpacked.r
+                        checkValue(s, q)
+                        checkValue(r, q)
+                        var montp = BN.mont(p)
+                        var w = s.invm(q)
+                        var v = g.toRed(montp)
+                            .redPow(new BN(hash).mul(w).mod(q))
+                            .fromRed()
+                            .mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed())
+                            .mod(p)
+                            .mod(q)
+                        return v.cmp(r) === 0
+                    }
+
+                    function checkValue(b, q) {
+                        if (b.cmpn(0) <= 0) throw new Error('invalid sig')
+                        if (b.cmp(q) >= q) throw new Error('invalid sig')
+                    }
+
+                    module.exports = verify
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "./curves.json": 50,
+                "bn.js": 24,
+                "buffer": 55,
+                "elliptic": 74,
+                "parse-asn1": 118
+            }],
+            54: [function (require, module, exports) {
+                (function (Buffer) {
+                    module.exports = function xor(a, b) {
+                        var length = Math.min(a.length, b.length)
+                        var buffer = new Buffer(length)
+
+                        for (var i = 0; i < length; ++i) {
+                            buffer[i] = a[i] ^ b[i]
+                        }
+
+                        return buffer
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "buffer": 55
+            }],
+            55: [function (require, module, exports) {
+                /*!
+                * The buffer module from node.js, for the browser.
+                *
+                * @author   Feross Aboukhadijeh <https://feross.org>
+                * @license  MIT
+                */
+                /* eslint-disable no-proto */
+
+                'use strict'
+
+                var base64 = require('base64-js')
+                var ieee754 = require('ieee754')
+
+                exports.Buffer = Buffer
+                exports.SlowBuffer = SlowBuffer
+                exports.INSPECT_MAX_BYTES = 50
+
+                var K_MAX_LENGTH = 0x7fffffff
+                exports.kMaxLength = K_MAX_LENGTH
+
+                /**
+                * If `Buffer.TYPED_ARRAY_SUPPORT`:
+                *   === true    Use Uint8Array implementation (fastest)
+                *   === false   Print warning and recommend using `buffer` v4.x which has an 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+.
+                *
+                * We report that the browser does not support typed arrays if the are not subclassable
+                * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
+                * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
+                * for __proto__ and has a buggy typed array implementation.
+                */
+                Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
+
+                if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
+                    typeof console.error === 'function') {
+                    console.error(
+                        'This browser lacks typed array (Uint8Array) support which is required by ' +
+                        '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
+                    )
+                }
+
+                function typedArraySupport() {
+                    // Can typed array instances can be augmented?
+                    try {
+                        var arr = new Uint8Array(1)
+                        arr.__proto__ = {
+                            __proto__: Uint8Array.prototype,
+                            foo: function () {
+                                return 42
+                            }
+                        }
+                        return arr.foo() === 42
+                    } catch (e) {
+                        return false
+                    }
+                }
+
+                Object.defineProperty(Buffer.prototype, 'parent', {
+                    get: function () {
+                        if (!(this instanceof Buffer)) {
+                            return undefined
+                        }
+                        return this.buffer
+                    }
+                })
+
+                Object.defineProperty(Buffer.prototype, 'offset', {
+                    get: function () {
+                        if (!(this instanceof Buffer)) {
+                            return undefined
+                        }
+                        return this.byteOffset
+                    }
+                })
+
+                function createBuffer(length) {
+                    if (length > K_MAX_LENGTH) {
+                        throw new RangeError('Invalid typed array length')
+                    }
+                    // Return an augmented `Uint8Array` instance
+                    var buf = new Uint8Array(length)
+                    buf.__proto__ = Buffer.prototype
+                    return buf
+                }
+
+                /**
+                * 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, encodingOrOffset, length) {
+                    // Common case.
+                    if (typeof arg === 'number') {
+                        if (typeof encodingOrOffset === 'string') {
+                            throw new Error(
+                                'If encoding is specified then the first argument must be a string'
+                            )
+                        }
+                        return allocUnsafe(arg)
+                    }
+                    return from(arg, encodingOrOffset, length)
+                }
+
+                // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+                if (typeof Symbol !== 'undefined' && Symbol.species &&
+                    Buffer[Symbol.species] === Buffer) {
+                    Object.defineProperty(Buffer, Symbol.species, {
+                        value: null,
+                        configurable: true,
+                        enumerable: false,
+                        writable: false
+                    })
+                }
+
+                Buffer.poolSize = 8192 // not used by this implementation
+
+                function from(value, encodingOrOffset, length) {
+                    if (typeof value === 'number') {
+                        throw new TypeError('"value" argument must not be a number')
+                    }
+
+                    if (isArrayBuffer(value) || (value && isArrayBuffer(value.buffer))) {
+                        return fromArrayBuffer(value, encodingOrOffset, length)
+                    }
+
+                    if (typeof value === 'string') {
+                        return fromString(value, encodingOrOffset)
+                    }
+
+                    return fromObject(value)
+                }
+
+                /**
+                * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+                * if value is a number.
+                * Buffer.from(str[, encoding])
+                * Buffer.from(array)
+                * Buffer.from(buffer)
+                * Buffer.from(arrayBuffer[, byteOffset[, length]])
+                **/
+                Buffer.from = function (value, encodingOrOffset, length) {
+                    return from(value, encodingOrOffset, length)
+                }
+
+                // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
+                // https://github.com/feross/buffer/pull/148
+                Buffer.prototype.__proto__ = Uint8Array.prototype
+                Buffer.__proto__ = Uint8Array
+
+                function assertSize(size) {
+                    if (typeof size !== 'number') {
+                        throw new TypeError('"size" argument must be of type number')
+                    } else if (size < 0) {
+                        throw new RangeError('"size" argument must not be negative')
+                    }
+                }
+
+                function alloc(size, fill, encoding) {
+                    assertSize(size)
+                    if (size <= 0) {
+                        return createBuffer(size)
+                    }
+                    if (fill !== undefined) {
+                        // Only pay attention to encoding if it's a string. This
+                        // prevents accidentally sending in a number that would
+                        // be interpretted as a start offset.
+                        return typeof encoding === 'string' ?
+                            createBuffer(size).fill(fill, encoding) :
+                            createBuffer(size).fill(fill)
+                    }
+                    return createBuffer(size)
+                }
+
+                /**
+                * Creates a new filled Buffer instance.
+                * alloc(size[, fill[, encoding]])
+                **/
+                Buffer.alloc = function (size, fill, encoding) {
+                    return alloc(size, fill, encoding)
+                }
+
+                function allocUnsafe(size) {
+                    assertSize(size)
+                    return createBuffer(size < 0 ? 0 : checked(size) | 0)
+                }
+
+                /**
+                * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+                * */
+                Buffer.allocUnsafe = function (size) {
+                    return allocUnsafe(size)
+                }
+                /**
+                * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+                */
+                Buffer.allocUnsafeSlow = function (size) {
+                    return allocUnsafe(size)
+                }
+
+                function fromString(string, encoding) {
+                    if (typeof encoding !== 'string' || encoding === '') {
+                        encoding = 'utf8'
+                    }
+
+                    if (!Buffer.isEncoding(encoding)) {
+                        throw new TypeError('Unknown encoding: ' + encoding)
+                    }
+
+                    var length = byteLength(string, encoding) | 0
+                    var buf = createBuffer(length)
+
+                    var actual = buf.write(string, encoding)
+
+                    if (actual !== length) {
+                        // Writing a hex string, for example, that contains invalid characters will
+                        // cause everything after the first invalid character to be ignored. (e.g.
+                        // 'abxxcd' will be treated as 'ab')
+                        buf = buf.slice(0, actual)
+                    }
+
+                    return buf
+                }
+
+                function fromArrayLike(array) {
+                    var length = array.length < 0 ? 0 : checked(array.length) | 0
+                    var buf = createBuffer(length)
+                    for (var i = 0; i < length; i += 1) {
+                        buf[i] = array[i] & 255
+                    }
+                    return buf
+                }
+
+                function fromArrayBuffer(array, byteOffset, length) {
+                    if (byteOffset < 0 || array.byteLength < byteOffset) {
+                        throw new RangeError('"offset" is outside of buffer bounds')
+                    }
+
+                    if (array.byteLength < byteOffset + (length || 0)) {
+                        throw new RangeError('"length" is outside of buffer bounds')
+                    }
+
+                    var buf
+                    if (byteOffset === undefined && length === undefined) {
+                        buf = new Uint8Array(array)
+                    } else if (length === undefined) {
+                        buf = new Uint8Array(array, byteOffset)
+                    } else {
+                        buf = new Uint8Array(array, byteOffset, length)
+                    }
+
+                    // Return an augmented `Uint8Array` instance
+                    buf.__proto__ = Buffer.prototype
+                    return buf
+                }
+
+                function fromObject(obj) {
+                    if (Buffer.isBuffer(obj)) {
+                        var len = checked(obj.length) | 0
+                        var buf = createBuffer(len)
+
+                        if (buf.length === 0) {
+                            return buf
+                        }
+
+                        obj.copy(buf, 0, 0, len)
+                        return buf
+                    }
+
+                    if (obj) {
+                        if (ArrayBuffer.isView(obj) || 'length' in obj) {
+                            if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
+                                return createBuffer(0)
+                            }
+                            return fromArrayLike(obj)
+                        }
+
+                        if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+                            return fromArrayLike(obj.data)
+                        }
+                    }
+
+                    throw new TypeError(
+                        'The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object.'
+                    )
+                }
+
+                function checked(length) {
+                    // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
+                    // length is NaN (which is otherwise coerced to zero.)
+                    if (length >= K_MAX_LENGTH) {
+                        throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+                            'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
+                    }
+                    return length | 0
+                }
+
+                function SlowBuffer(length) {
+                    if (+length != length) { // eslint-disable-line eqeqeq
+                        length = 0
+                    }
+                    return Buffer.alloc(+length)
+                }
+
+                Buffer.isBuffer = function isBuffer(b) {
+                    return b != null && b._isBuffer === true
+                }
+
+                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
+
+                    for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+                        if (a[i] !== b[i]) {
+                            x = a[i]
+                            y = b[i]
+                            break
+                        }
+                    }
+
+                    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 'latin1':
+                        case 'binary':
+                        case 'base64':
+                        case 'ucs2':
+                        case 'ucs-2':
+                        case 'utf16le':
+                        case 'utf-16le':
+                            return true
+                        default:
+                            return false
+                    }
+                }
+
+                Buffer.concat = function concat(list, length) {
+                    if (!Array.isArray(list)) {
+                        throw new TypeError('"list" argument must be an Array of Buffers')
+                    }
+
+                    if (list.length === 0) {
+                        return Buffer.alloc(0)
+                    }
+
+                    var i
+                    if (length === undefined) {
+                        length = 0
+                        for (i = 0; i < list.length; ++i) {
+                            length += list[i].length
+                        }
+                    }
+
+                    var buffer = Buffer.allocUnsafe(length)
+                    var pos = 0
+                    for (i = 0; i < list.length; ++i) {
+                        var buf = list[i]
+                        if (ArrayBuffer.isView(buf)) {
+                            buf = Buffer.from(buf)
+                        }
+                        if (!Buffer.isBuffer(buf)) {
+                            throw new TypeError('"list" argument must be an Array of Buffers')
+                        }
+                        buf.copy(buffer, pos)
+                        pos += buf.length
+                    }
+                    return buffer
+                }
+
+                function byteLength(string, encoding) {
+                    if (Buffer.isBuffer(string)) {
+                        return string.length
+                    }
+                    if (ArrayBuffer.isView(string) || isArrayBuffer(string)) {
+                        return string.byteLength
+                    }
+                    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 'latin1':
+                            case 'binary':
+                                return len
+                            case 'utf8':
+                            case 'utf-8':
+                            case undefined:
+                                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
+
+                    // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+                    // property of a typed array.
+
+                    // This behaves neither like String nor Uint8Array in that we set start/end
+                    // to their upper/lower bounds if the value passed is out of range.
+                    // undefined is handled specially as per ECMA-262 6th Edition,
+                    // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+                    if (start === undefined || start < 0) {
+                        start = 0
+                    }
+                    // Return early if start > this.length. Done here to prevent potential uint32
+                    // coercion fail below.
+                    if (start > this.length) {
+                        return ''
+                    }
+
+                    if (end === undefined || end > this.length) {
+                        end = this.length
+                    }
+
+                    if (end <= 0) {
+                        return ''
+                    }
+
+                    // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+                    end >>>= 0
+                    start >>>= 0
+
+                    if (end <= start) {
+                        return ''
+                    }
+
+                    if (!encoding) encoding = 'utf8'
+
+                    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 'latin1':
+                            case 'binary':
+                                return latin1Slice(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
+                        }
+                    }
+                }
+
+                // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+                // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+                // reliably in a browserify context because there could be multiple different
+                // copies of the 'buffer' package in use. This method works even for Buffer
+                // instances that were created from another copy of the `buffer` package.
+                // See: https://github.com/feross/buffer/issues/154
+                Buffer.prototype._isBuffer = true
+
+                function swap(b, n, m) {
+                    var i = b[n]
+                    b[n] = b[m]
+                    b[m] = i
+                }
+
+                Buffer.prototype.swap16 = function swap16() {
+                    var len = this.length
+                    if (len % 2 !== 0) {
+                        throw new RangeError('Buffer size must be a multiple of 16-bits')
+                    }
+                    for (var i = 0; i < len; i += 2) {
+                        swap(this, i, i + 1)
+                    }
+                    return this
+                }
+
+                Buffer.prototype.swap32 = function swap32() {
+                    var len = this.length
+                    if (len % 4 !== 0) {
+                        throw new RangeError('Buffer size must be a multiple of 32-bits')
+                    }
+                    for (var i = 0; i < len; i += 4) {
+                        swap(this, i, i + 3)
+                        swap(this, i + 1, i + 2)
+                    }
+                    return this
+                }
+
+                Buffer.prototype.swap64 = function swap64() {
+                    var len = this.length
+                    if (len % 8 !== 0) {
+                        throw new RangeError('Buffer size must be a multiple of 64-bits')
+                    }
+                    for (var i = 0; i < len; i += 8) {
+                        swap(this, i, i + 7)
+                        swap(this, i + 1, i + 6)
+                        swap(this, i + 2, i + 5)
+                        swap(this, i + 3, i + 4)
+                    }
+                    return this
+                }
+
+                Buffer.prototype.toString = function toString() {
+                    var length = this.length
+                    if (length === 0) return ''
+                    if (arguments.length === 0) return utf8Slice(this, 0, length)
+                    return slowToString.apply(this, arguments)
+                }
+
+                Buffer.prototype.toLocaleString = Buffer.prototype.toString
+
+                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(target, start, end, thisStart, thisEnd) {
+                    if (!Buffer.isBuffer(target)) {
+                        throw new TypeError('Argument must be a Buffer')
+                    }
+
+                    if (start === undefined) {
+                        start = 0
+                    }
+                    if (end === undefined) {
+                        end = target ? target.length : 0
+                    }
+                    if (thisStart === undefined) {
+                        thisStart = 0
+                    }
+                    if (thisEnd === undefined) {
+                        thisEnd = this.length
+                    }
+
+                    if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+                        throw new RangeError('out of range index')
+                    }
+
+                    if (thisStart >= thisEnd && start >= end) {
+                        return 0
+                    }
+                    if (thisStart >= thisEnd) {
+                        return -1
+                    }
+                    if (start >= end) {
+                        return 1
+                    }
+
+                    start >>>= 0
+                    end >>>= 0
+                    thisStart >>>= 0
+                    thisEnd >>>= 0
+
+                    if (this === target) return 0
+
+                    var x = thisEnd - thisStart
+                    var y = end - start
+                    var len = Math.min(x, y)
+
+                    var thisCopy = this.slice(thisStart, thisEnd)
+                    var targetCopy = target.slice(start, end)
+
+                    for (var i = 0; i < len; ++i) {
+                        if (thisCopy[i] !== targetCopy[i]) {
+                            x = thisCopy[i]
+                            y = targetCopy[i]
+                            break
+                        }
+                    }
+
+                    if (x < y) return -1
+                    if (y < x) return 1
+                    return 0
+                }
+
+                // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+                // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+                //
+                // Arguments:
+                // - buffer - a Buffer to search
+                // - val - a string, Buffer, or number
+                // - byteOffset - an index into `buffer`; will be clamped to an int32
+                // - encoding - an optional encoding, relevant is val is a string
+                // - dir - true for indexOf, false for lastIndexOf
+                function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+                    // Empty buffer means no match
+                    if (buffer.length === 0) return -1
+
+                    // Normalize byteOffset
+                    if (typeof byteOffset === 'string') {
+                        encoding = byteOffset
+                        byteOffset = 0
+                    } else if (byteOffset > 0x7fffffff) {
+                        byteOffset = 0x7fffffff
+                    } else if (byteOffset < -0x80000000) {
+                        byteOffset = -0x80000000
+                    }
+                    byteOffset = +byteOffset // Coerce to Number.
+                    if (numberIsNaN(byteOffset)) {
+                        // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+                        byteOffset = dir ? 0 : (buffer.length - 1)
+                    }
+
+                    // Normalize byteOffset: negative offsets start from the end of the buffer
+                    if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+                    if (byteOffset >= buffer.length) {
+                        if (dir) return -1
+                        else byteOffset = buffer.length - 1
+                    } else if (byteOffset < 0) {
+                        if (dir) byteOffset = 0
+                        else return -1
+                    }
+
+                    // Normalize val
+                    if (typeof val === 'string') {
+                        val = Buffer.from(val, encoding)
+                    }
+
+                    // Finally, search either indexOf (if dir is true) or lastIndexOf
+                    if (Buffer.isBuffer(val)) {
+                        // Special case: looking for empty string/buffer always fails
+                        if (val.length === 0) {
+                            return -1
+                        }
+                        return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+                    } else if (typeof val === 'number') {
+                        val = val & 0xFF // Search for a byte value [0-255]
+                        if (typeof Uint8Array.prototype.indexOf === 'function') {
+                            if (dir) {
+                                return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+                            } else {
+                                return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+                            }
+                        }
+                        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)
+                    }
+
+                    throw new TypeError('val must be string, number or Buffer')
+                }
+
+                function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+                    var indexSize = 1
+                    var arrLength = arr.length
+                    var valLength = val.length
+
+                    if (encoding !== undefined) {
+                        encoding = String(encoding).toLowerCase()
+                        if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+                            encoding === 'utf16le' || encoding === 'utf-16le') {
+                            if (arr.length < 2 || val.length < 2) {
+                                return -1
+                            }
+                            indexSize = 2
+                            arrLength /= 2
+                            valLength /= 2
+                            byteOffset /= 2
+                        }
+                    }
+
+                    function read(buf, i) {
+                        if (indexSize === 1) {
+                            return buf[i]
+                        } else {
+                            return buf.readUInt16BE(i * indexSize)
+                        }
+                    }
+
+                    var i
+                    if (dir) {
+                        var foundIndex = -1
+                        for (i = byteOffset; i < arrLength; i++) {
+                            if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+                                if (foundIndex === -1) foundIndex = i
+                                if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+                            } else {
+                                if (foundIndex !== -1) i -= i - foundIndex
+                                foundIndex = -1
+                            }
+                        }
+                    } else {
+                        if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+                        for (i = byteOffset; i >= 0; i--) {
+                            var found = true
+                            for (var j = 0; j < valLength; j++) {
+                                if (read(arr, i + j) !== read(val, j)) {
+                                    found = false
+                                    break
+                                }
+                            }
+                            if (found) return i
+                        }
+                    }
+
+                    return -1
+                }
+
+                Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+                    return this.indexOf(val, byteOffset, encoding) !== -1
+                }
+
+                Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+                    return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+                }
+
+                Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+                    return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+                }
+
+                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
+                        }
+                    }
+
+                    var strLen = string.length
+
+                    if (length > strLen / 2) {
+                        length = strLen / 2
+                    }
+                    for (var i = 0; i < length; ++i) {
+                        var parsed = parseInt(string.substr(i * 2, 2), 16)
+                        if (numberIsNaN(parsed)) return i
+                        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 latin1Write(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
+                        }
+                    } else {
+                        throw new Error(
+                            'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+                        )
+                    }
+
+                    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 'latin1':
+                            case 'binary':
+                                return latin1Write(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 latin1Slice(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 = this.subarray(start, end)
+                    // Return an augmented `Uint8Array` instance
+                    newBuf.__proto__ = Buffer.prototype
+                    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) {
+                    offset = offset >>> 0
+                    if (!noAssert) checkOffset(offset, 1, this.length)
+                    return this[offset]
+                }
+
+                Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+                    offset = offset >>> 0
+                    if (!noAssert) checkOffset(offset, 2, this.length)
+                    return this[offset] | (this[offset + 1] << 8)
+                }
+
+                Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+                    offset = offset >>> 0
+                    if (!noAssert) checkOffset(offset, 2, this.length)
+                    return (this[offset] << 8) | this[offset + 1]
+                }
+
+                Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+                    offset = offset >>> 0
+                    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) {
+                    offset = offset >>> 0
+                    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) {
+                    offset = offset >>> 0
+                    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) {
+                    offset = offset >>> 0
+                    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) {
+                    offset = offset >>> 0
+                    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) {
+                    offset = offset >>> 0
+                    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) {
+                    offset = offset >>> 0
+                    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) {
+                    offset = offset >>> 0
+                    if (!noAssert) checkOffset(offset, 4, this.length)
+                    return ieee754.read(this, offset, true, 23, 4)
+                }
+
+                Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+                    offset = offset >>> 0
+                    if (!noAssert) checkOffset(offset, 4, this.length)
+                    return ieee754.read(this, offset, false, 23, 4)
+                }
+
+                Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+                    offset = offset >>> 0
+                    if (!noAssert) checkOffset(offset, 8, this.length)
+                    return ieee754.read(this, offset, true, 52, 8)
+                }
+
+                Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+                    offset = offset >>> 0
+                    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" argument must be a Buffer instance')
+                    if (value > max || value < min) throw new RangeError(
+                        '"value" argument 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) {
+                        var maxBytes = Math.pow(2, 8 * byteLength) - 1
+                        checkInt(this, value, offset, byteLength, maxBytes, 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) {
+                        var maxBytes = Math.pow(2, 8 * byteLength) - 1
+                        checkInt(this, value, offset, byteLength, maxBytes, 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)
+                    this[offset] = (value & 0xff)
+                    return offset + 1
+                }
+
+                Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+                    value = +value
+                    offset = offset >>> 0
+                    if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+                    this[offset] = (value & 0xff)
+                    this[offset + 1] = (value >>> 8)
+                    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)
+                    this[offset] = (value >>> 8)
+                    this[offset + 1] = (value & 0xff)
+                    return offset + 2
+                }
+
+                Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+                    value = +value
+                    offset = offset >>> 0
+                    if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+                    this[offset + 3] = (value >>> 24)
+                    this[offset + 2] = (value >>> 16)
+                    this[offset + 1] = (value >>> 8)
+                    this[offset] = (value & 0xff)
+                    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)
+                    this[offset] = (value >>> 24)
+                    this[offset + 1] = (value >>> 16)
+                    this[offset + 2] = (value >>> 8)
+                    this[offset + 3] = (value & 0xff)
+                    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 = 0
+                    this[offset] = value & 0xFF
+                    while (++i < byteLength && (mul *= 0x100)) {
+                        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+                            sub = 1
+                        }
+                        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 = 0
+                    this[offset + i] = value & 0xFF
+                    while (--i >= 0 && (mul *= 0x100)) {
+                        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+                            sub = 1
+                        }
+                        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 (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)
+                    this[offset] = (value & 0xff)
+                    this[offset + 1] = (value >>> 8)
+                    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)
+                    this[offset] = (value >>> 8)
+                    this[offset + 1] = (value & 0xff)
+                    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)
+                    this[offset] = (value & 0xff)
+                    this[offset + 1] = (value >>> 8)
+                    this[offset + 2] = (value >>> 16)
+                    this[offset + 3] = (value >>> 24)
+                    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
+                    this[offset] = (value >>> 24)
+                    this[offset + 1] = (value >>> 16)
+                    this[offset + 2] = (value >>> 8)
+                    this[offset + 3] = (value & 0xff)
+                    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) {
+                    value = +value
+                    offset = offset >>> 0
+                    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) {
+                    value = +value
+                    offset = offset >>> 0
+                    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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
+                    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('Index out of range')
+                    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
+
+                    if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
+                        // Use built-in when available, missing from IE11
+                        this.copyWithin(targetStart, start, end)
+                    } else if (this === target && start < targetStart && targetStart < end) {
+                        // descending copy from end
+                        for (var i = len - 1; i >= 0; --i) {
+                            target[i + targetStart] = this[i + start]
+                        }
+                    } else {
+                        Uint8Array.prototype.set.call(
+                            target,
+                            this.subarray(start, end),
+                            targetStart
+                        )
+                    }
+
+                    return len
+                }
+
+                // Usage:
+                //    buffer.fill(number[, offset[, end]])
+                //    buffer.fill(buffer[, offset[, end]])
+                //    buffer.fill(string[, offset[, end]][, encoding])
+                Buffer.prototype.fill = function fill(val, start, end, encoding) {
+                    // Handle string cases:
+                    if (typeof val === 'string') {
+                        if (typeof start === 'string') {
+                            encoding = start
+                            start = 0
+                            end = this.length
+                        } else if (typeof end === 'string') {
+                            encoding = end
+                            end = this.length
+                        }
+                        if (encoding !== undefined && typeof encoding !== 'string') {
+                            throw new TypeError('encoding must be a string')
+                        }
+                        if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+                            throw new TypeError('Unknown encoding: ' + encoding)
+                        }
+                        if (val.length === 1) {
+                            var code = val.charCodeAt(0)
+                            if ((encoding === 'utf8' && code < 128) ||
+                                encoding === 'latin1') {
+                                // Fast path: If `val` fits into a single byte, use that numeric value.
+                                val = code
+                            }
+                        }
+                    } else if (typeof val === 'number') {
+                        val = val & 255
+                    }
+
+                    // Invalid ranges are not set to a default, so can range check early.
+                    if (start < 0 || this.length < start || this.length < end) {
+                        throw new RangeError('Out of range index')
+                    }
+
+                    if (end <= start) {
+                        return this
+                    }
+
+                    start = start >>> 0
+                    end = end === undefined ? this.length : end >>> 0
+
+                    if (!val) val = 0
+
+                    var i
+                    if (typeof val === 'number') {
+                        for (i = start; i < end; ++i) {
+                            this[i] = val
+                        }
+                    } else {
+                        var bytes = Buffer.isBuffer(val) ?
+                            val :
+                            new Buffer(val, encoding)
+                        var len = bytes.length
+                        if (len === 0) {
+                            throw new TypeError('The value "' + val +
+                                '" is invalid for argument "value"')
+                        }
+                        for (i = 0; i < end - start; ++i) {
+                            this[i + start] = bytes[i % len]
+                        }
+                    }
+
+                    return this
+                }
+
+                // HELPER FUNCTIONS
+                // ================
+
+                var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
+
+                function base64clean(str) {
+                    // Node takes equal signs as end of the Base64 encoding
+                    str = str.split('=')[0]
+                    // Node strips out invalid characters like \n and \t from the string, base64-js does not
+                    str = str.trim().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 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
+                }
+
+                // ArrayBuffers from another context (i.e. an iframe) do not pass the `instanceof` check
+                // but they should be treated as valid. See: https://github.com/feross/buffer/issues/166
+                function isArrayBuffer(obj) {
+                    return obj instanceof ArrayBuffer ||
+                        (obj != null && obj.constructor != null && obj.constructor.name === 'ArrayBuffer' &&
+                            typeof obj.byteLength === 'number')
+                }
+
+                function numberIsNaN(obj) {
+                    return obj !== obj // eslint-disable-line no-self-compare
+                }
+
+            }, {
+                "base64-js": 23,
+                "ieee754": 106
+            }],
+            56: [function (require, module, exports) {
+                var Buffer = require('safe-buffer').Buffer
+                var Transform = require('stream').Transform
+                var StringDecoder = require('string_decoder').StringDecoder
+                var inherits = require('inherits')
+
+                function CipherBase(hashMode) {
+                    Transform.call(this)
+                    this.hashMode = typeof hashMode === 'string'
+                    if (this.hashMode) {
+                        this[hashMode] = this._finalOrDigest
+                    } else {
+                        this.final = this._finalOrDigest
+                    }
+                    if (this._final) {
+                        this.__final = this._final
+                        this._final = null
+                    }
+                    this._decoder = null
+                    this._encoding = null
+                }
+                inherits(CipherBase, Transform)
+
+                CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
+                    if (typeof data === 'string') {
+                        data = Buffer.from(data, inputEnc)
+                    }
+
+                    var outData = this._update(data)
+                    if (this.hashMode) return this
+
+                    if (outputEnc) {
+                        outData = this._toString(outData, outputEnc)
+                    }
+
+                    return outData
+                }
+
+                CipherBase.prototype.setAutoPadding = function () {}
+                CipherBase.prototype.getAuthTag = function () {
+                    throw new Error('trying to get auth tag in unsupported state')
+                }
+
+                CipherBase.prototype.setAuthTag = function () {
+                    throw new Error('trying to set auth tag in unsupported state')
+                }
+
+                CipherBase.prototype.setAAD = function () {
+                    throw new Error('trying to set aad in unsupported state')
+                }
+
+                CipherBase.prototype._transform = function (data, _, next) {
+                    var err
+                    try {
+                        if (this.hashMode) {
+                            this._update(data)
+                        } else {
+                            this.push(this._update(data))
+                        }
+                    } catch (e) {
+                        err = e
+                    } finally {
+                        next(err)
+                    }
+                }
+                CipherBase.prototype._flush = function (done) {
+                    var err
+                    try {
+                        this.push(this.__final())
+                    } catch (e) {
+                        err = e
+                    }
+
+                    done(err)
+                }
+                CipherBase.prototype._finalOrDigest = function (outputEnc) {
+                    var outData = this.__final() || Buffer.alloc(0)
+                    if (outputEnc) {
+                        outData = this._toString(outData, outputEnc, true)
+                    }
+                    return outData
+                }
+
+                CipherBase.prototype._toString = function (value, enc, fin) {
+                    if (!this._decoder) {
+                        this._decoder = new StringDecoder(enc)
+                        this._encoding = enc
+                    }
+
+                    if (this._encoding !== enc) throw new Error('can\'t switch encodings')
+
+                    var out = this._decoder.write(value)
+                    if (fin) {
+                        out += this._decoder.end()
+                    }
+
+                    return out
+                }
+
+                module.exports = CipherBase
+
+            }, {
+                "inherits": 107,
+                "safe-buffer": 148,
+                "stream": 157,
+                "string_decoder": 158
+            }],
+            57: [function (require, module, exports) {
+                (function (Buffer) {
+                    // Copyright Joyent, Inc. and other Node contributors.
+                    //
+                    // Permission is hereby granted, free of charge, to any person obtaining a
+                    // copy of this software and associated documentation files (the
+                    // "Software"), to deal in the Software without restriction, including
+                    // without limitation the rights to use, copy, modify, merge, publish,
+                    // distribute, sublicense, and/or sell copies of the Software, and to permit
+                    // persons to whom the Software is furnished to do so, subject to the
+                    // following conditions:
+                    //
+                    // The above copyright notice and this permission notice shall be included
+                    // in all copies or substantial portions of the Software.
+                    //
+                    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                    // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                    // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                    // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                    // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                    // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                    // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                    // NOTE: These type checking functions intentionally don't use `instanceof`
+                    // because it is fragile and can be easily faked with `Object.create()`.
+
+                    function isArray(arg) {
+                        if (Array.isArray) {
+                            return Array.isArray(arg);
+                        }
+                        return objectToString(arg) === '[object Array]';
+                    }
+                    exports.isArray = isArray;
+
+                    function isBoolean(arg) {
+                        return typeof arg === 'boolean';
+                    }
+                    exports.isBoolean = isBoolean;
+
+                    function isNull(arg) {
+                        return arg === null;
+                    }
+                    exports.isNull = isNull;
+
+                    function isNullOrUndefined(arg) {
+                        return arg == null;
+                    }
+                    exports.isNullOrUndefined = isNullOrUndefined;
+
+                    function isNumber(arg) {
+                        return typeof arg === 'number';
+                    }
+                    exports.isNumber = isNumber;
+
+                    function isString(arg) {
+                        return typeof arg === 'string';
+                    }
+                    exports.isString = isString;
+
+                    function isSymbol(arg) {
+                        return typeof arg === 'symbol';
+                    }
+                    exports.isSymbol = isSymbol;
+
+                    function isUndefined(arg) {
+                        return arg === void 0;
+                    }
+                    exports.isUndefined = isUndefined;
+
+                    function isRegExp(re) {
+                        return objectToString(re) === '[object RegExp]';
+                    }
+                    exports.isRegExp = isRegExp;
+
+                    function isObject(arg) {
+                        return typeof arg === 'object' && arg !== null;
+                    }
+                    exports.isObject = isObject;
+
+                    function isDate(d) {
+                        return objectToString(d) === '[object Date]';
+                    }
+                    exports.isDate = isDate;
+
+                    function isError(e) {
+                        return (objectToString(e) === '[object Error]' || e instanceof Error);
+                    }
+                    exports.isError = isError;
+
+                    function isFunction(arg) {
+                        return typeof arg === 'function';
+                    }
+                    exports.isFunction = isFunction;
+
+                    function isPrimitive(arg) {
+                        return arg === null ||
+                            typeof arg === 'boolean' ||
+                            typeof arg === 'number' ||
+                            typeof arg === 'string' ||
+                            typeof arg === 'symbol' || // ES6 symbol
+                            typeof arg === 'undefined';
+                    }
+                    exports.isPrimitive = isPrimitive;
+
+                    exports.isBuffer = Buffer.isBuffer;
+
+                    function objectToString(o) {
+                        return Object.prototype.toString.call(o);
+                    }
+
+                }).call(this, {
+                    "isBuffer": require("../../is-buffer/index.js")
+                })
+            }, {
+                "../../is-buffer/index.js": 108
+            }],
+            58: [function (require, module, exports) {
+                (function (Buffer) {
+                    var elliptic = require('elliptic')
+                    var BN = require('bn.js')
+
+                    module.exports = function createECDH(curve) {
+                        return new ECDH(curve)
+                    }
+
+                    var aliases = {
+                        secp256k1: {
+                            name: 'secp256k1',
+                            byteLength: 32
+                        },
+                        secp224r1: {
+                            name: 'p224',
+                            byteLength: 28
+                        },
+                        prime256v1: {
+                            name: 'p256',
+                            byteLength: 32
+                        },
+                        prime192v1: {
+                            name: 'p192',
+                            byteLength: 24
+                        },
+                        ed25519: {
+                            name: 'ed25519',
+                            byteLength: 32
+                        },
+                        secp384r1: {
+                            name: 'p384',
+                            byteLength: 48
+                        },
+                        secp521r1: {
+                            name: 'p521',
+                            byteLength: 66
+                        }
+                    }
+
+                    aliases.p224 = aliases.secp224r1
+                    aliases.p256 = aliases.secp256r1 = aliases.prime256v1
+                    aliases.p192 = aliases.secp192r1 = aliases.prime192v1
+                    aliases.p384 = aliases.secp384r1
+                    aliases.p521 = aliases.secp521r1
+
+                    function ECDH(curve) {
+                        this.curveType = aliases[curve]
+                        if (!this.curveType) {
+                            this.curveType = {
+                                name: curve
+                            }
+                        }
+                        this.curve = new elliptic.ec(this.curveType.name) // eslint-disable-line new-cap
+                        this.keys = void 0
+                    }
+
+                    ECDH.prototype.generateKeys = function (enc, format) {
+                        this.keys = this.curve.genKeyPair()
+                        return this.getPublicKey(enc, format)
+                    }
+
+                    ECDH.prototype.computeSecret = function (other, inenc, enc) {
+                        inenc = inenc || 'utf8'
+                        if (!Buffer.isBuffer(other)) {
+                            other = new Buffer(other, inenc)
+                        }
+                        var otherPub = this.curve.keyFromPublic(other).getPublic()
+                        var out = otherPub.mul(this.keys.getPrivate()).getX()
+                        return formatReturnValue(out, enc, this.curveType.byteLength)
+                    }
+
+                    ECDH.prototype.getPublicKey = function (enc, format) {
+                        var key = this.keys.getPublic(format === 'compressed', true)
+                        if (format === 'hybrid') {
+                            if (key[key.length - 1] % 2) {
+                                key[0] = 7
+                            } else {
+                                key[0] = 6
+                            }
+                        }
+                        return formatReturnValue(key, enc)
+                    }
+
+                    ECDH.prototype.getPrivateKey = function (enc) {
+                        return formatReturnValue(this.keys.getPrivate(), enc)
+                    }
+
+                    ECDH.prototype.setPublicKey = function (pub, enc) {
+                        enc = enc || 'utf8'
+                        if (!Buffer.isBuffer(pub)) {
+                            pub = new Buffer(pub, enc)
+                        }
+                        this.keys._importPublic(pub)
+                        return this
+                    }
+
+                    ECDH.prototype.setPrivateKey = function (priv, enc) {
+                        enc = enc || 'utf8'
+                        if (!Buffer.isBuffer(priv)) {
+                            priv = new Buffer(priv, enc)
+                        }
+
+                        var _priv = new BN(priv)
+                        _priv = _priv.toString(16)
+                        this.keys = this.curve.genKeyPair()
+                        this.keys._importPrivate(_priv)
+                        return this
+                    }
+
+                    function formatReturnValue(bn, enc, len) {
+                        if (!Array.isArray(bn)) {
+                            bn = bn.toArray()
+                        }
+                        var buf = new Buffer(bn)
+                        if (len && buf.length < len) {
+                            var zeros = new Buffer(len - buf.length)
+                            zeros.fill(0)
+                            buf = Buffer.concat([zeros, buf])
+                        }
+                        if (!enc) {
+                            return buf
+                        } else {
+                            return buf.toString(enc)
+                        }
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "bn.js": 24,
+                "buffer": 55,
+                "elliptic": 74
+            }],
+            59: [function (require, module, exports) {
+                'use strict'
+                var inherits = require('inherits')
+                var MD5 = require('md5.js')
+                var RIPEMD160 = require('ripemd160')
+                var sha = require('sha.js')
+                var Base = require('cipher-base')
+
+                function Hash(hash) {
+                    Base.call(this, 'digest')
+
+                    this._hash = hash
+                }
+
+                inherits(Hash, Base)
+
+                Hash.prototype._update = function (data) {
+                    this._hash.update(data)
+                }
+
+                Hash.prototype._final = function () {
+                    return this._hash.digest()
+                }
+
+                module.exports = function createHash(alg) {
+                    alg = alg.toLowerCase()
+                    if (alg === 'md5') return new MD5()
+                    if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()
+
+                    return new Hash(sha(alg))
+                }
+
+            }, {
+                "cipher-base": 56,
+                "inherits": 107,
+                "md5.js": 110,
+                "ripemd160": 147,
+                "sha.js": 150
+            }],
+            60: [function (require, module, exports) {
+                var MD5 = require('md5.js')
+
+                module.exports = function (buffer) {
+                    return new MD5().update(buffer).digest()
+                }
+
+            }, {
+                "md5.js": 110
+            }],
+            61: [function (require, module, exports) {
+                'use strict'
+                var inherits = require('inherits')
+                var Legacy = require('./legacy')
+                var Base = require('cipher-base')
+                var Buffer = require('safe-buffer').Buffer
+                var md5 = require('create-hash/md5')
+                var RIPEMD160 = require('ripemd160')
+
+                var sha = require('sha.js')
+
+                var ZEROS = Buffer.alloc(128)
+
+                function Hmac(alg, key) {
+                    Base.call(this, 'digest')
+                    if (typeof key === 'string') {
+                        key = Buffer.from(key)
+                    }
+
+                    var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64
+
+                    this._alg = alg
+                    this._key = key
+                    if (key.length > blocksize) {
+                        var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
+                        key = hash.update(key).digest()
+                    } else if (key.length < blocksize) {
+                        key = Buffer.concat([key, ZEROS], blocksize)
+                    }
+
+                    var ipad = this._ipad = Buffer.allocUnsafe(blocksize)
+                    var opad = this._opad = Buffer.allocUnsafe(blocksize)
+
+                    for (var i = 0; i < blocksize; i++) {
+                        ipad[i] = key[i] ^ 0x36
+                        opad[i] = key[i] ^ 0x5C
+                    }
+                    this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
+                    this._hash.update(ipad)
+                }
+
+                inherits(Hmac, Base)
+
+                Hmac.prototype._update = function (data) {
+                    this._hash.update(data)
+                }
+
+                Hmac.prototype._final = function () {
+                    var h = this._hash.digest()
+                    var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)
+                    return hash.update(this._opad).update(h).digest()
+                }
+
+                module.exports = function createHmac(alg, key) {
+                    alg = alg.toLowerCase()
+                    if (alg === 'rmd160' || alg === 'ripemd160') {
+                        return new Hmac('rmd160', key)
+                    }
+                    if (alg === 'md5') {
+                        return new Legacy(md5, key)
+                    }
+                    return new Hmac(alg, key)
+                }
+
+            }, {
+                "./legacy": 62,
+                "cipher-base": 56,
+                "create-hash/md5": 60,
+                "inherits": 107,
+                "ripemd160": 147,
+                "safe-buffer": 148,
+                "sha.js": 150
+            }],
+            62: [function (require, module, exports) {
+                'use strict'
+                var inherits = require('inherits')
+                var Buffer = require('safe-buffer').Buffer
+
+                var Base = require('cipher-base')
+
+                var ZEROS = Buffer.alloc(128)
+                var blocksize = 64
+
+                function Hmac(alg, key) {
+                    Base.call(this, 'digest')
+                    if (typeof key === 'string') {
+                        key = Buffer.from(key)
+                    }
+
+                    this._alg = alg
+                    this._key = key
+
+                    if (key.length > blocksize) {
+                        key = alg(key)
+                    } else if (key.length < blocksize) {
+                        key = Buffer.concat([key, ZEROS], blocksize)
+                    }
+
+                    var ipad = this._ipad = Buffer.allocUnsafe(blocksize)
+                    var opad = this._opad = Buffer.allocUnsafe(blocksize)
+
+                    for (var i = 0; i < blocksize; i++) {
+                        ipad[i] = key[i] ^ 0x36
+                        opad[i] = key[i] ^ 0x5C
+                    }
+
+                    this._hash = [ipad]
+                }
+
+                inherits(Hmac, Base)
+
+                Hmac.prototype._update = function (data) {
+                    this._hash.push(data)
+                }
+
+                Hmac.prototype._final = function () {
+                    var h = this._alg(Buffer.concat(this._hash))
+                    return this._alg(Buffer.concat([this._opad, h]))
+                }
+                module.exports = Hmac
+
+            }, {
+                "cipher-base": 56,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            63: [function (require, module, exports) {
+                'use strict'
+
+                exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require(
+                    'randombytes')
+                exports.createHash = exports.Hash = require('create-hash')
+                exports.createHmac = exports.Hmac = require('create-hmac')
+
+                var algos = require('browserify-sign/algos')
+                var algoKeys = Object.keys(algos)
+                var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(
+                    algoKeys)
+                exports.getHashes = function () {
+                    return hashes
+                }
+
+                var p = require('pbkdf2')
+                exports.pbkdf2 = p.pbkdf2
+                exports.pbkdf2Sync = p.pbkdf2Sync
+
+                var aes = require('browserify-cipher')
+
+                exports.Cipher = aes.Cipher
+                exports.createCipher = aes.createCipher
+                exports.Cipheriv = aes.Cipheriv
+                exports.createCipheriv = aes.createCipheriv
+                exports.Decipher = aes.Decipher
+                exports.createDecipher = aes.createDecipher
+                exports.Decipheriv = aes.Decipheriv
+                exports.createDecipheriv = aes.createDecipheriv
+                exports.getCiphers = aes.getCiphers
+                exports.listCiphers = aes.listCiphers
+
+                var dh = require('diffie-hellman')
+
+                exports.DiffieHellmanGroup = dh.DiffieHellmanGroup
+                exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup
+                exports.getDiffieHellman = dh.getDiffieHellman
+                exports.createDiffieHellman = dh.createDiffieHellman
+                exports.DiffieHellman = dh.DiffieHellman
+
+                var sign = require('browserify-sign')
+
+                exports.createSign = sign.createSign
+                exports.Sign = sign.Sign
+                exports.createVerify = sign.createVerify
+                exports.Verify = sign.Verify
+
+                exports.createECDH = require('create-ecdh')
+
+                var publicEncrypt = require('public-encrypt')
+
+                exports.publicEncrypt = publicEncrypt.publicEncrypt
+                exports.privateEncrypt = publicEncrypt.privateEncrypt
+                exports.publicDecrypt = publicEncrypt.publicDecrypt
+                exports.privateDecrypt = publicEncrypt.privateDecrypt
+
+                // the least I can do is make error messages for the rest of the node.js/crypto api.
+                // ;[
+                //   'createCredentials'
+                // ].forEach(function (name) {
+                //   exports[name] = function () {
+                //     throw new Error([
+                //       'sorry, ' + name + ' is not implemented yet',
+                //       'we accept pull requests',
+                //       'https://github.com/crypto-browserify/crypto-browserify'
+                //     ].join('\n'))
+                //   }
+                // })
+
+                var rf = require('randomfill')
+
+                exports.randomFill = rf.randomFill
+                exports.randomFillSync = rf.randomFillSync
+
+                exports.createCredentials = function () {
+                    throw new Error([
+                        'sorry, createCredentials is not implemented yet',
+                        'we accept pull requests',
+                        'https://github.com/crypto-browserify/crypto-browserify'
+                    ].join('\n'))
+                }
+
+                exports.constants = {
+                    'DH_CHECK_P_NOT_SAFE_PRIME': 2,
+                    'DH_CHECK_P_NOT_PRIME': 1,
+                    'DH_UNABLE_TO_CHECK_GENERATOR': 4,
+                    'DH_NOT_SUITABLE_GENERATOR': 8,
+                    'NPN_ENABLED': 1,
+                    'ALPN_ENABLED': 1,
+                    'RSA_PKCS1_PADDING': 1,
+                    'RSA_SSLV23_PADDING': 2,
+                    'RSA_NO_PADDING': 3,
+                    'RSA_PKCS1_OAEP_PADDING': 4,
+                    'RSA_X931_PADDING': 5,
+                    'RSA_PKCS1_PSS_PADDING': 6,
+                    'POINT_CONVERSION_COMPRESSED': 2,
+                    'POINT_CONVERSION_UNCOMPRESSED': 4,
+                    'POINT_CONVERSION_HYBRID': 6
+                }
+
+            }, {
+                "browserify-cipher": 44,
+                "browserify-sign": 51,
+                "browserify-sign/algos": 48,
+                "create-ecdh": 58,
+                "create-hash": 59,
+                "create-hmac": 61,
+                "diffie-hellman": 70,
+                "pbkdf2": 119,
+                "public-encrypt": 126,
+                "randombytes": 132,
+                "randomfill": 133
+            }],
+            64: [function (require, module, exports) {
+                'use strict';
+
+                exports.utils = require('./des/utils');
+                exports.Cipher = require('./des/cipher');
+                exports.DES = require('./des/des');
+                exports.CBC = require('./des/cbc');
+                exports.EDE = require('./des/ede');
+
+            }, {
+                "./des/cbc": 65,
+                "./des/cipher": 66,
+                "./des/des": 67,
+                "./des/ede": 68,
+                "./des/utils": 69
+            }],
+            65: [function (require, module, exports) {
+                'use strict';
+
+                var assert = require('minimalistic-assert');
+                var inherits = require('inherits');
+
+                var proto = {};
+
+                function CBCState(iv) {
+                    assert.equal(iv.length, 8, 'Invalid IV length');
+
+                    this.iv = new Array(8);
+                    for (var i = 0; i < this.iv.length; i++)
+                        this.iv[i] = iv[i];
+                }
+
+                function instantiate(Base) {
+                    function CBC(options) {
+                        Base.call(this, options);
+                        this._cbcInit();
+                    }
+                    inherits(CBC, Base);
+
+                    var keys = Object.keys(proto);
+                    for (var i = 0; i < keys.length; i++) {
+                        var key = keys[i];
+                        CBC.prototype[key] = proto[key];
+                    }
+
+                    CBC.create = function create(options) {
+                        return new CBC(options);
+                    };
+
+                    return CBC;
+                }
+
+                exports.instantiate = instantiate;
+
+                proto._cbcInit = function _cbcInit() {
+                    var state = new CBCState(this.options.iv);
+                    this._cbcState = state;
+                };
+
+                proto._update = function _update(inp, inOff, out, outOff) {
+                    var state = this._cbcState;
+                    var superProto = this.constructor.super_.prototype;
+
+                    var iv = state.iv;
+                    if (this.type === 'encrypt') {
+                        for (var i = 0; i < this.blockSize; i++)
+                            iv[i] ^= inp[inOff + i];
+
+                        superProto._update.call(this, iv, 0, out, outOff);
+
+                        for (var i = 0; i < this.blockSize; i++)
+                            iv[i] = out[outOff + i];
+                    } else {
+                        superProto._update.call(this, inp, inOff, out, outOff);
+
+                        for (var i = 0; i < this.blockSize; i++)
+                            out[outOff + i] ^= iv[i];
+
+                        for (var i = 0; i < this.blockSize; i++)
+                            iv[i] = inp[inOff + i];
+                    }
+                };
+
+            }, {
+                "inherits": 107,
+                "minimalistic-assert": 112
+            }],
+            66: [function (require, module, exports) {
+                'use strict';
+
+                var assert = require('minimalistic-assert');
+
+                function Cipher(options) {
+                    this.options = options;
+
+                    this.type = this.options.type;
+                    this.blockSize = 8;
+                    this._init();
+
+                    this.buffer = new Array(this.blockSize);
+                    this.bufferOff = 0;
+                }
+                module.exports = Cipher;
+
+                Cipher.prototype._init = function _init() {
+                    // Might be overrided
+                };
+
+                Cipher.prototype.update = function update(data) {
+                    if (data.length === 0)
+                        return [];
+
+                    if (this.type === 'decrypt')
+                        return this._updateDecrypt(data);
+                    else
+                        return this._updateEncrypt(data);
+                };
+
+                Cipher.prototype._buffer = function _buffer(data, off) {
+                    // Append data to buffer
+                    var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);
+                    for (var i = 0; i < min; i++)
+                        this.buffer[this.bufferOff + i] = data[off + i];
+                    this.bufferOff += min;
+
+                    // Shift next
+                    return min;
+                };
+
+                Cipher.prototype._flushBuffer = function _flushBuffer(out, off) {
+                    this._update(this.buffer, 0, out, off);
+                    this.bufferOff = 0;
+                    return this.blockSize;
+                };
+
+                Cipher.prototype._updateEncrypt = function _updateEncrypt(data) {
+                    var inputOff = 0;
+                    var outputOff = 0;
+
+                    var count = ((this.bufferOff + data.length) / this.blockSize) | 0;
+                    var out = new Array(count * this.blockSize);
+
+                    if (this.bufferOff !== 0) {
+                        inputOff += this._buffer(data, inputOff);
+
+                        if (this.bufferOff === this.buffer.length)
+                            outputOff += this._flushBuffer(out, outputOff);
+                    }
+
+                    // Write blocks
+                    var max = data.length - ((data.length - inputOff) % this.blockSize);
+                    for (; inputOff < max; inputOff += this.blockSize) {
+                        this._update(data, inputOff, out, outputOff);
+                        outputOff += this.blockSize;
+                    }
+
+                    // Queue rest
+                    for (; inputOff < data.length; inputOff++, this.bufferOff++)
+                        this.buffer[this.bufferOff] = data[inputOff];
+
+                    return out;
+                };
+
+                Cipher.prototype._updateDecrypt = function _updateDecrypt(data) {
+                    var inputOff = 0;
+                    var outputOff = 0;
+
+                    var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1;
+                    var out = new Array(count * this.blockSize);
+
+                    // TODO(indutny): optimize it, this is far from optimal
+                    for (; count > 0; count--) {
+                        inputOff += this._buffer(data, inputOff);
+                        outputOff += this._flushBuffer(out, outputOff);
+                    }
+
+                    // Buffer rest of the input
+                    inputOff += this._buffer(data, inputOff);
+
+                    return out;
+                };
+
+                Cipher.prototype.final = function final(buffer) {
+                    var first;
+                    if (buffer)
+                        first = this.update(buffer);
+
+                    var last;
+                    if (this.type === 'encrypt')
+                        last = this._finalEncrypt();
+                    else
+                        last = this._finalDecrypt();
+
+                    if (first)
+                        return first.concat(last);
+                    else
+                        return last;
+                };
+
+                Cipher.prototype._pad = function _pad(buffer, off) {
+                    if (off === 0)
+                        return false;
+
+                    while (off < buffer.length)
+                        buffer[off++] = 0;
+
+                    return true;
+                };
+
+                Cipher.prototype._finalEncrypt = function _finalEncrypt() {
+                    if (!this._pad(this.buffer, this.bufferOff))
+                        return [];
+
+                    var out = new Array(this.blockSize);
+                    this._update(this.buffer, 0, out, 0);
+                    return out;
+                };
+
+                Cipher.prototype._unpad = function _unpad(buffer) {
+                    return buffer;
+                };
+
+                Cipher.prototype._finalDecrypt = function _finalDecrypt() {
+                    assert.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt');
+                    var out = new Array(this.blockSize);
+                    this._flushBuffer(out, 0);
+
+                    return this._unpad(out);
+                };
+
+            }, {
+                "minimalistic-assert": 112
+            }],
+            67: [function (require, module, exports) {
+                'use strict';
+
+                var assert = require('minimalistic-assert');
+                var inherits = require('inherits');
+
+                var des = require('../des');
+                var utils = des.utils;
+                var Cipher = des.Cipher;
+
+                function DESState() {
+                    this.tmp = new Array(2);
+                    this.keys = null;
+                }
+
+                function DES(options) {
+                    Cipher.call(this, options);
+
+                    var state = new DESState();
+                    this._desState = state;
+
+                    this.deriveKeys(state, options.key);
+                }
+                inherits(DES, Cipher);
+                module.exports = DES;
+
+                DES.create = function create(options) {
+                    return new DES(options);
+                };
+
+                var shiftTable = [
+                    1, 1, 2, 2, 2, 2, 2, 2,
+                    1, 2, 2, 2, 2, 2, 2, 1
+                ];
+
+                DES.prototype.deriveKeys = function deriveKeys(state, key) {
+                    state.keys = new Array(16 * 2);
+
+                    assert.equal(key.length, this.blockSize, 'Invalid key length');
+
+                    var kL = utils.readUInt32BE(key, 0);
+                    var kR = utils.readUInt32BE(key, 4);
+
+                    utils.pc1(kL, kR, state.tmp, 0);
+                    kL = state.tmp[0];
+                    kR = state.tmp[1];
+                    for (var i = 0; i < state.keys.length; i += 2) {
+                        var shift = shiftTable[i >>> 1];
+                        kL = utils.r28shl(kL, shift);
+                        kR = utils.r28shl(kR, shift);
+                        utils.pc2(kL, kR, state.keys, i);
+                    }
+                };
+
+                DES.prototype._update = function _update(inp, inOff, out, outOff) {
+                    var state = this._desState;
+
+                    var l = utils.readUInt32BE(inp, inOff);
+                    var r = utils.readUInt32BE(inp, inOff + 4);
+
+                    // Initial Permutation
+                    utils.ip(l, r, state.tmp, 0);
+                    l = state.tmp[0];
+                    r = state.tmp[1];
+
+                    if (this.type === 'encrypt')
+                        this._encrypt(state, l, r, state.tmp, 0);
+                    else
+                        this._decrypt(state, l, r, state.tmp, 0);
+
+                    l = state.tmp[0];
+                    r = state.tmp[1];
+
+                    utils.writeUInt32BE(out, l, outOff);
+                    utils.writeUInt32BE(out, r, outOff + 4);
+                };
+
+                DES.prototype._pad = function _pad(buffer, off) {
+                    var value = buffer.length - off;
+                    for (var i = off; i < buffer.length; i++)
+                        buffer[i] = value;
+
+                    return true;
+                };
+
+                DES.prototype._unpad = function _unpad(buffer) {
+                    var pad = buffer[buffer.length - 1];
+                    for (var i = buffer.length - pad; i < buffer.length; i++)
+                        assert.equal(buffer[i], pad);
+
+                    return buffer.slice(0, buffer.length - pad);
+                };
+
+                DES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) {
+                    var l = lStart;
+                    var r = rStart;
+
+                    // Apply f() x16 times
+                    for (var i = 0; i < state.keys.length; i += 2) {
+                        var keyL = state.keys[i];
+                        var keyR = state.keys[i + 1];
+
+                        // f(r, k)
+                        utils.expand(r, state.tmp, 0);
+
+                        keyL ^= state.tmp[0];
+                        keyR ^= state.tmp[1];
+                        var s = utils.substitute(keyL, keyR);
+                        var f = utils.permute(s);
+
+                        var t = r;
+                        r = (l ^ f) >>> 0;
+                        l = t;
+                    }
+
+                    // Reverse Initial Permutation
+                    utils.rip(r, l, out, off);
+                };
+
+                DES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) {
+                    var l = rStart;
+                    var r = lStart;
+
+                    // Apply f() x16 times
+                    for (var i = state.keys.length - 2; i >= 0; i -= 2) {
+                        var keyL = state.keys[i];
+                        var keyR = state.keys[i + 1];
+
+                        // f(r, k)
+                        utils.expand(l, state.tmp, 0);
+
+                        keyL ^= state.tmp[0];
+                        keyR ^= state.tmp[1];
+                        var s = utils.substitute(keyL, keyR);
+                        var f = utils.permute(s);
+
+                        var t = l;
+                        l = (r ^ f) >>> 0;
+                        r = t;
+                    }
+
+                    // Reverse Initial Permutation
+                    utils.rip(l, r, out, off);
+                };
+
+            }, {
+                "../des": 64,
+                "inherits": 107,
+                "minimalistic-assert": 112
+            }],
+            68: [function (require, module, exports) {
+                'use strict';
+
+                var assert = require('minimalistic-assert');
+                var inherits = require('inherits');
+
+                var des = require('../des');
+                var Cipher = des.Cipher;
+                var DES = des.DES;
+
+                function EDEState(type, key) {
+                    assert.equal(key.length, 24, 'Invalid key length');
+
+                    var k1 = key.slice(0, 8);
+                    var k2 = key.slice(8, 16);
+                    var k3 = key.slice(16, 24);
+
+                    if (type === 'encrypt') {
+                        this.ciphers = [
+                            DES.create({
+                                type: 'encrypt',
+                                key: k1
+                            }),
+                            DES.create({
+                                type: 'decrypt',
+                                key: k2
+                            }),
+                            DES.create({
+                                type: 'encrypt',
+                                key: k3
+                            })
+                        ];
+                    } else {
+                        this.ciphers = [
+                            DES.create({
+                                type: 'decrypt',
+                                key: k3
+                            }),
+                            DES.create({
+                                type: 'encrypt',
+                                key: k2
+                            }),
+                            DES.create({
+                                type: 'decrypt',
+                                key: k1
+                            })
+                        ];
+                    }
+                }
+
+                function EDE(options) {
+                    Cipher.call(this, options);
+
+                    var state = new EDEState(this.type, this.options.key);
+                    this._edeState = state;
+                }
+                inherits(EDE, Cipher);
+
+                module.exports = EDE;
+
+                EDE.create = function create(options) {
+                    return new EDE(options);
+                };
+
+                EDE.prototype._update = function _update(inp, inOff, out, outOff) {
+                    var state = this._edeState;
+
+                    state.ciphers[0]._update(inp, inOff, out, outOff);
+                    state.ciphers[1]._update(out, outOff, out, outOff);
+                    state.ciphers[2]._update(out, outOff, out, outOff);
+                };
+
+                EDE.prototype._pad = DES.prototype._pad;
+                EDE.prototype._unpad = DES.prototype._unpad;
+
+            }, {
+                "../des": 64,
+                "inherits": 107,
+                "minimalistic-assert": 112
+            }],
+            69: [function (require, module, exports) {
+                'use strict';
+
+                exports.readUInt32BE = function readUInt32BE(bytes, off) {
+                    var res = (bytes[0 + off] << 24) |
+                        (bytes[1 + off] << 16) |
+                        (bytes[2 + off] << 8) |
+                        bytes[3 + off];
+                    return res >>> 0;
+                };
+
+                exports.writeUInt32BE = function writeUInt32BE(bytes, value, off) {
+                    bytes[0 + off] = value >>> 24;
+                    bytes[1 + off] = (value >>> 16) & 0xff;
+                    bytes[2 + off] = (value >>> 8) & 0xff;
+                    bytes[3 + off] = value & 0xff;
+                };
+
+                exports.ip = function ip(inL, inR, out, off) {
+                    var outL = 0;
+                    var outR = 0;
+
+                    for (var i = 6; i >= 0; i -= 2) {
+                        for (var j = 0; j <= 24; j += 8) {
+                            outL <<= 1;
+                            outL |= (inR >>> (j + i)) & 1;
+                        }
+                        for (var j = 0; j <= 24; j += 8) {
+                            outL <<= 1;
+                            outL |= (inL >>> (j + i)) & 1;
+                        }
+                    }
+
+                    for (var i = 6; i >= 0; i -= 2) {
+                        for (var j = 1; j <= 25; j += 8) {
+                            outR <<= 1;
+                            outR |= (inR >>> (j + i)) & 1;
+                        }
+                        for (var j = 1; j <= 25; j += 8) {
+                            outR <<= 1;
+                            outR |= (inL >>> (j + i)) & 1;
+                        }
+                    }
+
+                    out[off + 0] = outL >>> 0;
+                    out[off + 1] = outR >>> 0;
+                };
+
+                exports.rip = function rip(inL, inR, out, off) {
+                    var outL = 0;
+                    var outR = 0;
+
+                    for (var i = 0; i < 4; i++) {
+                        for (var j = 24; j >= 0; j -= 8) {
+                            outL <<= 1;
+                            outL |= (inR >>> (j + i)) & 1;
+                            outL <<= 1;
+                            outL |= (inL >>> (j + i)) & 1;
+                        }
+                    }
+                    for (var i = 4; i < 8; i++) {
+                        for (var j = 24; j >= 0; j -= 8) {
+                            outR <<= 1;
+                            outR |= (inR >>> (j + i)) & 1;
+                            outR <<= 1;
+                            outR |= (inL >>> (j + i)) & 1;
+                        }
+                    }
+
+                    out[off + 0] = outL >>> 0;
+                    out[off + 1] = outR >>> 0;
+                };
+
+                exports.pc1 = function pc1(inL, inR, out, off) {
+                    var outL = 0;
+                    var outR = 0;
+
+                    // 7, 15, 23, 31, 39, 47, 55, 63
+                    // 6, 14, 22, 30, 39, 47, 55, 63
+                    // 5, 13, 21, 29, 39, 47, 55, 63
+                    // 4, 12, 20, 28
+                    for (var i = 7; i >= 5; i--) {
+                        for (var j = 0; j <= 24; j += 8) {
+                            outL <<= 1;
+                            outL |= (inR >> (j + i)) & 1;
+                        }
+                        for (var j = 0; j <= 24; j += 8) {
+                            outL <<= 1;
+                            outL |= (inL >> (j + i)) & 1;
+                        }
+                    }
+                    for (var j = 0; j <= 24; j += 8) {
+                        outL <<= 1;
+                        outL |= (inR >> (j + i)) & 1;
+                    }
+
+                    // 1, 9, 17, 25, 33, 41, 49, 57
+                    // 2, 10, 18, 26, 34, 42, 50, 58
+                    // 3, 11, 19, 27, 35, 43, 51, 59
+                    // 36, 44, 52, 60
+                    for (var i = 1; i <= 3; i++) {
+                        for (var j = 0; j <= 24; j += 8) {
+                            outR <<= 1;
+                            outR |= (inR >> (j + i)) & 1;
+                        }
+                        for (var j = 0; j <= 24; j += 8) {
+                            outR <<= 1;
+                            outR |= (inL >> (j + i)) & 1;
+                        }
+                    }
+                    for (var j = 0; j <= 24; j += 8) {
+                        outR <<= 1;
+                        outR |= (inL >> (j + i)) & 1;
+                    }
+
+                    out[off + 0] = outL >>> 0;
+                    out[off + 1] = outR >>> 0;
+                };
+
+                exports.r28shl = function r28shl(num, shift) {
+                    return ((num << shift) & 0xfffffff) | (num >>> (28 - shift));
+                };
+
+                var pc2table = [
+                    // inL => outL
+                    14, 11, 17, 4, 27, 23, 25, 0,
+                    13, 22, 7, 18, 5, 9, 16, 24,
+                    2, 20, 12, 21, 1, 8, 15, 26,
+
+                    // inR => outR
+                    15, 4, 25, 19, 9, 1, 26, 16,
+                    5, 11, 23, 8, 12, 7, 17, 0,
+                    22, 3, 10, 14, 6, 20, 27, 24
+                ];
+
+                exports.pc2 = function pc2(inL, inR, out, off) {
+                    var outL = 0;
+                    var outR = 0;
+
+                    var len = pc2table.length >>> 1;
+                    for (var i = 0; i < len; i++) {
+                        outL <<= 1;
+                        outL |= (inL >>> pc2table[i]) & 0x1;
+                    }
+                    for (var i = len; i < pc2table.length; i++) {
+                        outR <<= 1;
+                        outR |= (inR >>> pc2table[i]) & 0x1;
+                    }
+
+                    out[off + 0] = outL >>> 0;
+                    out[off + 1] = outR >>> 0;
+                };
+
+                exports.expand = function expand(r, out, off) {
+                    var outL = 0;
+                    var outR = 0;
+
+                    outL = ((r & 1) << 5) | (r >>> 27);
+                    for (var i = 23; i >= 15; i -= 4) {
+                        outL <<= 6;
+                        outL |= (r >>> i) & 0x3f;
+                    }
+                    for (var i = 11; i >= 3; i -= 4) {
+                        outR |= (r >>> i) & 0x3f;
+                        outR <<= 6;
+                    }
+                    outR |= ((r & 0x1f) << 1) | (r >>> 31);
+
+                    out[off + 0] = outL >>> 0;
+                    out[off + 1] = outR >>> 0;
+                };
+
+                var sTable = [
+                    14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1,
+                    3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8,
+                    4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7,
+                    15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13,
+
+                    15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14,
+                    9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5,
+                    0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2,
+                    5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9,
+
+                    10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10,
+                    1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1,
+                    13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7,
+                    11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12,
+
+                    7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3,
+                    1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9,
+                    10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8,
+                    15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14,
+
+                    2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1,
+                    8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6,
+                    4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13,
+                    15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3,
+
+                    12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5,
+                    0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8,
+                    9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10,
+                    7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13,
+
+                    4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10,
+                    3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6,
+                    1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7,
+                    10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12,
+
+                    13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4,
+                    10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2,
+                    7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13,
+                    0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11
+                ];
+
+                exports.substitute = function substitute(inL, inR) {
+                    var out = 0;
+                    for (var i = 0; i < 4; i++) {
+                        var b = (inL >>> (18 - i * 6)) & 0x3f;
+                        var sb = sTable[i * 0x40 + b];
+
+                        out <<= 4;
+                        out |= sb;
+                    }
+                    for (var i = 0; i < 4; i++) {
+                        var b = (inR >>> (18 - i * 6)) & 0x3f;
+                        var sb = sTable[4 * 0x40 + i * 0x40 + b];
+
+                        out <<= 4;
+                        out |= sb;
+                    }
+                    return out >>> 0;
+                };
+
+                var permuteTable = [
+                    16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22,
+                    30, 24, 8, 18, 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7
+                ];
+
+                exports.permute = function permute(num) {
+                    var out = 0;
+                    for (var i = 0; i < permuteTable.length; i++) {
+                        out <<= 1;
+                        out |= (num >>> permuteTable[i]) & 0x1;
+                    }
+                    return out >>> 0;
+                };
+
+                exports.padSplit = function padSplit(num, size, group) {
+                    var str = num.toString(2);
+                    while (str.length < size)
+                        str = '0' + str;
+
+                    var out = [];
+                    for (var i = 0; i < size; i += group)
+                        out.push(str.slice(i, i + group));
+                    return out.join(' ');
+                };
+
+            }, {}],
+            70: [function (require, module, exports) {
+                (function (Buffer) {
+                    var generatePrime = require('./lib/generatePrime')
+                    var primes = require('./lib/primes.json')
+
+                    var DH = require('./lib/dh')
+
+                    function getDiffieHellman(mod) {
+                        var prime = new Buffer(primes[mod].prime, 'hex')
+                        var gen = new Buffer(primes[mod].gen, 'hex')
+
+                        return new DH(prime, gen)
+                    }
+
+                    var ENCODINGS = {
+                        'binary': true,
+                        'hex': true,
+                        'base64': true
+                    }
+
+                    function createDiffieHellman(prime, enc, generator, genc) {
+                        if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) {
+                            return createDiffieHellman(prime, 'binary', enc, generator)
+                        }
+
+                        enc = enc || 'binary'
+                        genc = genc || 'binary'
+                        generator = generator || new Buffer([2])
+
+                        if (!Buffer.isBuffer(generator)) {
+                            generator = new Buffer(generator, genc)
+                        }
+
+                        if (typeof prime === 'number') {
+                            return new DH(generatePrime(prime, generator), generator, true)
+                        }
+
+                        if (!Buffer.isBuffer(prime)) {
+                            prime = new Buffer(prime, enc)
+                        }
+
+                        return new DH(prime, generator, true)
+                    }
+
+                    exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman =
+                        getDiffieHellman
+                    exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "./lib/dh": 71,
+                "./lib/generatePrime": 72,
+                "./lib/primes.json": 73,
+                "buffer": 55
+            }],
+            71: [function (require, module, exports) {
+                (function (Buffer) {
+                    var BN = require('bn.js');
+                    var MillerRabin = require('miller-rabin');
+                    var millerRabin = new MillerRabin();
+                    var TWENTYFOUR = new BN(24);
+                    var ELEVEN = new BN(11);
+                    var TEN = new BN(10);
+                    var THREE = new BN(3);
+                    var SEVEN = new BN(7);
+                    var primes = require('./generatePrime');
+                    var randomBytes = require('randombytes');
+                    module.exports = DH;
+
+                    function setPublicKey(pub, enc) {
+                        enc = enc || 'utf8';
+                        if (!Buffer.isBuffer(pub)) {
+                            pub = new Buffer(pub, enc);
+                        }
+                        this._pub = new BN(pub);
+                        return this;
+                    }
+
+                    function setPrivateKey(priv, enc) {
+                        enc = enc || 'utf8';
+                        if (!Buffer.isBuffer(priv)) {
+                            priv = new Buffer(priv, enc);
+                        }
+                        this._priv = new BN(priv);
+                        return this;
+                    }
+
+                    var primeCache = {};
+
+                    function checkPrime(prime, generator) {
+                        var gen = generator.toString('hex');
+                        var hex = [gen, prime.toString(16)].join('_');
+                        if (hex in primeCache) {
+                            return primeCache[hex];
+                        }
+                        var error = 0;
+
+                        if (prime.isEven() ||
+                            !primes.simpleSieve ||
+                            !primes.fermatTest(prime) ||
+                            !millerRabin.test(prime)) {
+                            //not a prime so +1
+                            error += 1;
+
+                            if (gen === '02' || gen === '05') {
+                                // we'd be able to check the generator
+                                // it would fail so +8
+                                error += 8;
+                            } else {
+                                //we wouldn't be able to test the generator
+                                // so +4
+                                error += 4;
+                            }
+                            primeCache[hex] = error;
+                            return error;
+                        }
+                        if (!millerRabin.test(prime.shrn(1))) {
+                            //not a safe prime
+                            error += 2;
+                        }
+                        var rem;
+                        switch (gen) {
+                            case '02':
+                                if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) {
+                                    // unsuidable generator
+                                    error += 8;
+                                }
+                                break;
+                            case '05':
+                                rem = prime.mod(TEN);
+                                if (rem.cmp(THREE) && rem.cmp(SEVEN)) {
+                                    // prime mod 10 needs to equal 3 or 7
+                                    error += 8;
+                                }
+                                break;
+                            default:
+                                error += 4;
+                        }
+                        primeCache[hex] = error;
+                        return error;
+                    }
+
+                    function DH(prime, generator, malleable) {
+                        this.setGenerator(generator);
+                        this.__prime = new BN(prime);
+                        this._prime = BN.mont(this.__prime);
+                        this._primeLen = prime.length;
+                        this._pub = undefined;
+                        this._priv = undefined;
+                        this._primeCode = undefined;
+                        if (malleable) {
+                            this.setPublicKey = setPublicKey;
+                            this.setPrivateKey = setPrivateKey;
+                        } else {
+                            this._primeCode = 8;
+                        }
+                    }
+                    Object.defineProperty(DH.prototype, 'verifyError', {
+                        enumerable: true,
+                        get: function () {
+                            if (typeof this._primeCode !== 'number') {
+                                this._primeCode = checkPrime(this.__prime, this.__gen);
+                            }
+                            return this._primeCode;
+                        }
+                    });
+                    DH.prototype.generateKeys = function () {
+                        if (!this._priv) {
+                            this._priv = new BN(randomBytes(this._primeLen));
+                        }
+                        this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed();
+                        return this.getPublicKey();
+                    };
+
+                    DH.prototype.computeSecret = function (other) {
+                        other = new BN(other);
+                        other = other.toRed(this._prime);
+                        var secret = other.redPow(this._priv).fromRed();
+                        var out = new Buffer(secret.toArray());
+                        var prime = this.getPrime();
+                        if (out.length < prime.length) {
+                            var front = new Buffer(prime.length - out.length);
+                            front.fill(0);
+                            out = Buffer.concat([front, out]);
+                        }
+                        return out;
+                    };
+
+                    DH.prototype.getPublicKey = function getPublicKey(enc) {
+                        return formatReturnValue(this._pub, enc);
+                    };
+
+                    DH.prototype.getPrivateKey = function getPrivateKey(enc) {
+                        return formatReturnValue(this._priv, enc);
+                    };
+
+                    DH.prototype.getPrime = function (enc) {
+                        return formatReturnValue(this.__prime, enc);
+                    };
+
+                    DH.prototype.getGenerator = function (enc) {
+                        return formatReturnValue(this._gen, enc);
+                    };
+
+                    DH.prototype.setGenerator = function (gen, enc) {
+                        enc = enc || 'utf8';
+                        if (!Buffer.isBuffer(gen)) {
+                            gen = new Buffer(gen, enc);
+                        }
+                        this.__gen = gen;
+                        this._gen = new BN(gen);
+                        return this;
+                    };
+
+                    function formatReturnValue(bn, enc) {
+                        var buf = new Buffer(bn.toArray());
+                        if (!enc) {
+                            return buf;
+                        } else {
+                            return buf.toString(enc);
+                        }
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "./generatePrime": 72,
+                "bn.js": 24,
+                "buffer": 55,
+                "miller-rabin": 111,
+                "randombytes": 132
+            }],
+            72: [function (require, module, exports) {
+                var randomBytes = require('randombytes');
+                module.exports = findPrime;
+                findPrime.simpleSieve = simpleSieve;
+                findPrime.fermatTest = fermatTest;
+                var BN = require('bn.js');
+                var TWENTYFOUR = new BN(24);
+                var MillerRabin = require('miller-rabin');
+                var millerRabin = new MillerRabin();
+                var ONE = new BN(1);
+                var TWO = new BN(2);
+                var FIVE = new BN(5);
+                var SIXTEEN = new BN(16);
+                var EIGHT = new BN(8);
+                var TEN = new BN(10);
+                var THREE = new BN(3);
+                var SEVEN = new BN(7);
+                var ELEVEN = new BN(11);
+                var FOUR = new BN(4);
+                var TWELVE = new BN(12);
+                var primes = null;
+
+                function _getPrimes() {
+                    if (primes !== null)
+                        return primes;
+
+                    var limit = 0x100000;
+                    var res = [];
+                    res[0] = 2;
+                    for (var i = 1, k = 3; k < limit; k += 2) {
+                        var sqrt = Math.ceil(Math.sqrt(k));
+                        for (var j = 0; j < i && res[j] <= sqrt; j++)
+                            if (k % res[j] === 0)
+                                break;
+
+                        if (i !== j && res[j] <= sqrt)
+                            continue;
+
+                        res[i++] = k;
+                    }
+                    primes = res;
+                    return res;
+                }
+
+                function simpleSieve(p) {
+                    var primes = _getPrimes();
+
+                    for (var i = 0; i < primes.length; i++)
+                        if (p.modn(primes[i]) === 0) {
+                            if (p.cmpn(primes[i]) === 0) {
+                                return true;
+                            } else {
+                                return false;
+                            }
+                        }
+
+                    return true;
+                }
+
+                function fermatTest(p) {
+                    var red = BN.mont(p);
+                    return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0;
+                }
+
+                function findPrime(bits, gen) {
+                    if (bits < 16) {
+                        // this is what openssl does
+                        if (gen === 2 || gen === 5) {
+                            return new BN([0x8c, 0x7b]);
+                        } else {
+                            return new BN([0x8c, 0x27]);
+                        }
+                    }
+                    gen = new BN(gen);
+
+                    var num, n2;
+
+                    while (true) {
+                        num = new BN(randomBytes(Math.ceil(bits / 8)));
+                        while (num.bitLength() > bits) {
+                            num.ishrn(1);
+                        }
+                        if (num.isEven()) {
+                            num.iadd(ONE);
+                        }
+                        if (!num.testn(1)) {
+                            num.iadd(TWO);
+                        }
+                        if (!gen.cmp(TWO)) {
+                            while (num.mod(TWENTYFOUR).cmp(ELEVEN)) {
+                                num.iadd(FOUR);
+                            }
+                        } else if (!gen.cmp(FIVE)) {
+                            while (num.mod(TEN).cmp(THREE)) {
+                                num.iadd(FOUR);
+                            }
+                        }
+                        n2 = num.shrn(1);
+                        if (simpleSieve(n2) && simpleSieve(num) &&
+                            fermatTest(n2) && fermatTest(num) &&
+                            millerRabin.test(n2) && millerRabin.test(num)) {
+                            return num;
+                        }
+                    }
+
+                }
+
+            }, {
+                "bn.js": 24,
+                "miller-rabin": 111,
+                "randombytes": 132
+            }],
+            73: [function (require, module, exports) {
+                module.exports = {
+                    "modp1": {
+                        "gen": "02",
+                        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff"
+                    },
+                    "modp2": {
+                        "gen": "02",
+                        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff"
+                    },
+                    "modp5": {
+                        "gen": "02",
+                        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff"
+                    },
+                    "modp14": {
+                        "gen": "02",
+                        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff"
+                    },
+                    "modp15": {
+                        "gen": "02",
+                        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff"
+                    },
+                    "modp16": {
+                        "gen": "02",
+                        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff"
+                    },
+                    "modp17": {
+                        "gen": "02",
+                        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff"
+                    },
+                    "modp18": {
+                        "gen": "02",
+                        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dbe115974a3926f12fee5e438777cb6a932df8cd8bec4d073b931ba3bc832b68d9dd300741fa7bf8afc47ed2576f6936ba424663aab639c5ae4f5683423b4742bf1c978238f16cbe39d652de3fdb8befc848ad922222e04a4037c0713eb57a81a23f0c73473fc646cea306b4bcbc8862f8385ddfa9d4b7fa2c087e879683303ed5bdd3a062b3cf5b3a278a66d2a13f83f44f82ddf310ee074ab6a364597e899a0255dc164f31cc50846851df9ab48195ded7ea1b1d510bd7ee74d73faf36bc31ecfa268359046f4eb879f924009438b481c6cd7889a002ed5ee382bc9190da6fc026e479558e4475677e9aa9e3050e2765694dfc81f56e880b96e7160c980dd98edd3dfffffffffffffffff"
+                    }
+                }
+            }, {}],
+            74: [function (require, module, exports) {
+                'use strict';
+
+                var elliptic = exports;
+
+                elliptic.version = require('../package.json').version;
+                elliptic.utils = require('./elliptic/utils');
+                elliptic.rand = require('brorand');
+                elliptic.curve = require('./elliptic/curve');
+                elliptic.curves = require('./elliptic/curves');
+
+                // Protocols
+                elliptic.ec = require('./elliptic/ec');
+                elliptic.eddsa = require('./elliptic/eddsa');
+
+            }, {
+                "../package.json": 89,
+                "./elliptic/curve": 77,
+                "./elliptic/curves": 80,
+                "./elliptic/ec": 81,
+                "./elliptic/eddsa": 84,
+                "./elliptic/utils": 88,
+                "brorand": 25
+            }],
+            75: [function (require, module, exports) {
+                'use strict';
+
+                var BN = require('bn.js');
+                var elliptic = require('../../elliptic');
+                var utils = elliptic.utils;
+                var getNAF = utils.getNAF;
+                var getJSF = utils.getJSF;
+                var assert = utils.assert;
+
+                function BaseCurve(type, conf) {
+                    this.type = type;
+                    this.p = new BN(conf.p, 16);
+
+                    // Use Montgomery, when there is no fast reduction for the prime
+                    this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);
+
+                    // Useful for many curves
+                    this.zero = new BN(0).toRed(this.red);
+                    this.one = new BN(1).toRed(this.red);
+                    this.two = new BN(2).toRed(this.red);
+
+                    // Curve configuration, optional
+                    this.n = conf.n && new BN(conf.n, 16);
+                    this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);
+
+                    // Temporary arrays
+                    this._wnafT1 = new Array(4);
+                    this._wnafT2 = new Array(4);
+                    this._wnafT3 = new Array(4);
+                    this._wnafT4 = new Array(4);
+
+                    // Generalized Greg Maxwell's trick
+                    var adjustCount = this.n && this.p.div(this.n);
+                    if (!adjustCount || adjustCount.cmpn(100) > 0) {
+                        this.redN = null;
+                    } else {
+                        this._maxwellTrick = true;
+                        this.redN = this.n.toRed(this.red);
+                    }
+                }
+                module.exports = BaseCurve;
+
+                BaseCurve.prototype.point = function point() {
+                    throw new Error('Not implemented');
+                };
+
+                BaseCurve.prototype.validate = function validate() {
+                    throw new Error('Not implemented');
+                };
+
+                BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
+                    assert(p.precomputed);
+                    var doubles = p._getDoubles();
+
+                    var naf = getNAF(k, 1);
+                    var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);
+                    I /= 3;
+
+                    // Translate into more windowed form
+                    var repr = [];
+                    for (var j = 0; j < naf.length; j += doubles.step) {
+                        var nafW = 0;
+                        for (var k = j + doubles.step - 1; k >= j; k--)
+                            nafW = (nafW << 1) + naf[k];
+                        repr.push(nafW);
+                    }
+
+                    var a = this.jpoint(null, null, null);
+                    var b = this.jpoint(null, null, null);
+                    for (var i = I; i > 0; i--) {
+                        for (var j = 0; j < repr.length; j++) {
+                            var nafW = repr[j];
+                            if (nafW === i)
+                                b = b.mixedAdd(doubles.points[j]);
+                            else if (nafW === -i)
+                                b = b.mixedAdd(doubles.points[j].neg());
+                        }
+                        a = a.add(b);
+                    }
+                    return a.toP();
+                };
+
+                BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
+                    var w = 4;
+
+                    // Precompute window
+                    var nafPoints = p._getNAFPoints(w);
+                    w = nafPoints.wnd;
+                    var wnd = nafPoints.points;
+
+                    // Get NAF form
+                    var naf = getNAF(k, w);
+
+                    // Add `this`*(N+1) for every w-NAF index
+                    var acc = this.jpoint(null, null, null);
+                    for (var i = naf.length - 1; i >= 0; i--) {
+                        // Count zeroes
+                        for (var k = 0; i >= 0 && naf[i] === 0; i--)
+                            k++;
+                        if (i >= 0)
+                            k++;
+                        acc = acc.dblp(k);
+
+                        if (i < 0)
+                            break;
+                        var z = naf[i];
+                        assert(z !== 0);
+                        if (p.type === 'affine') {
+                            // J +- P
+                            if (z > 0)
+                                acc = acc.mixedAdd(wnd[(z - 1) >> 1]);
+                            else
+                                acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());
+                        } else {
+                            // J +- J
+                            if (z > 0)
+                                acc = acc.add(wnd[(z - 1) >> 1]);
+                            else
+                                acc = acc.add(wnd[(-z - 1) >> 1].neg());
+                        }
+                    }
+                    return p.type === 'affine' ? acc.toP() : acc;
+                };
+
+                BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,
+                    points,
+                    coeffs,
+                    len,
+                    jacobianResult) {
+                    var wndWidth = this._wnafT1;
+                    var wnd = this._wnafT2;
+                    var naf = this._wnafT3;
+
+                    // Fill all arrays
+                    var max = 0;
+                    for (var i = 0; i < len; i++) {
+                        var p = points[i];
+                        var nafPoints = p._getNAFPoints(defW);
+                        wndWidth[i] = nafPoints.wnd;
+                        wnd[i] = nafPoints.points;
+                    }
+
+                    // Comb small window NAFs
+                    for (var i = len - 1; i >= 1; i -= 2) {
+                        var a = i - 1;
+                        var b = i;
+                        if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
+                            naf[a] = getNAF(coeffs[a], wndWidth[a]);
+                            naf[b] = getNAF(coeffs[b], wndWidth[b]);
+                            max = Math.max(naf[a].length, max);
+                            max = Math.max(naf[b].length, max);
+                            continue;
+                        }
+
+                        var comb = [
+                            points[a], /* 1 */
+                            null, /* 3 */
+                            null, /* 5 */
+                            points[b] /* 7 */
+                        ];
+
+                        // Try to avoid Projective points, if possible
+                        if (points[a].y.cmp(points[b].y) === 0) {
+                            comb[1] = points[a].add(points[b]);
+                            comb[2] = points[a].toJ().mixedAdd(points[b].neg());
+                        } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
+                            comb[1] = points[a].toJ().mixedAdd(points[b]);
+                            comb[2] = points[a].add(points[b].neg());
+                        } else {
+                            comb[1] = points[a].toJ().mixedAdd(points[b]);
+                            comb[2] = points[a].toJ().mixedAdd(points[b].neg());
+                        }
+
+                        var index = [
+                            -3, /* -1 -1 */
+                            -1, /* -1 0 */
+                            -5, /* -1 1 */
+                            -7, /* 0 -1 */
+                            0, /* 0 0 */
+                            7, /* 0 1 */
+                            5, /* 1 -1 */
+                            1, /* 1 0 */
+                            3 /* 1 1 */
+                        ];
+
+                        var jsf = getJSF(coeffs[a], coeffs[b]);
+                        max = Math.max(jsf[0].length, max);
+                        naf[a] = new Array(max);
+                        naf[b] = new Array(max);
+                        for (var j = 0; j < max; j++) {
+                            var ja = jsf[0][j] | 0;
+                            var jb = jsf[1][j] | 0;
+
+                            naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
+                            naf[b][j] = 0;
+                            wnd[a] = comb;
+                        }
+                    }
+
+                    var acc = this.jpoint(null, null, null);
+                    var tmp = this._wnafT4;
+                    for (var i = max; i >= 0; i--) {
+                        var k = 0;
+
+                        while (i >= 0) {
+                            var zero = true;
+                            for (var j = 0; j < len; j++) {
+                                tmp[j] = naf[j][i] | 0;
+                                if (tmp[j] !== 0)
+                                    zero = false;
+                            }
+                            if (!zero)
+                                break;
+                            k++;
+                            i--;
+                        }
+                        if (i >= 0)
+                            k++;
+                        acc = acc.dblp(k);
+                        if (i < 0)
+                            break;
+
+                        for (var j = 0; j < len; j++) {
+                            var z = tmp[j];
+                            var p;
+                            if (z === 0)
+                                continue;
+                            else if (z > 0)
+                                p = wnd[j][(z - 1) >> 1];
+                            else if (z < 0)
+                                p = wnd[j][(-z - 1) >> 1].neg();
+
+                            if (p.type === 'affine')
+                                acc = acc.mixedAdd(p);
+                            else
+                                acc = acc.add(p);
+                        }
+                    }
+                    // Zeroify references
+                    for (var i = 0; i < len; i++)
+                        wnd[i] = null;
+
+                    if (jacobianResult)
+                        return acc;
+                    else
+                        return acc.toP();
+                };
+
+                function BasePoint(curve, type) {
+                    this.curve = curve;
+                    this.type = type;
+                    this.precomputed = null;
+                }
+                BaseCurve.BasePoint = BasePoint;
+
+                BasePoint.prototype.eq = function eq( /*other*/ ) {
+                    throw new Error('Not implemented');
+                };
+
+                BasePoint.prototype.validate = function validate() {
+                    return this.curve.validate(this);
+                };
+
+                BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
+                    bytes = utils.toArray(bytes, enc);
+
+                    var len = this.p.byteLength();
+
+                    // uncompressed, hybrid-odd, hybrid-even
+                    if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&
+                        bytes.length - 1 === 2 * len) {
+                        if (bytes[0] === 0x06)
+                            assert(bytes[bytes.length - 1] % 2 === 0);
+                        else if (bytes[0] === 0x07)
+                            assert(bytes[bytes.length - 1] % 2 === 1);
+
+                        var res = this.point(bytes.slice(1, 1 + len),
+                            bytes.slice(1 + len, 1 + 2 * len));
+
+                        return res;
+                    } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&
+                        bytes.length - 1 === len) {
+                        return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);
+                    }
+                    throw new Error('Unknown point format');
+                };
+
+                BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
+                    return this.encode(enc, true);
+                };
+
+                BasePoint.prototype._encode = function _encode(compact) {
+                    var len = this.curve.p.byteLength();
+                    var x = this.getX().toArray('be', len);
+
+                    if (compact)
+                        return [this.getY().isEven() ? 0x02 : 0x03].concat(x);
+
+                    return [0x04].concat(x, this.getY().toArray('be', len));
+                };
+
+                BasePoint.prototype.encode = function encode(enc, compact) {
+                    return utils.encode(this._encode(compact), enc);
+                };
+
+                BasePoint.prototype.precompute = function precompute(power) {
+                    if (this.precomputed)
+                        return this;
+
+                    var precomputed = {
+                        doubles: null,
+                        naf: null,
+                        beta: null
+                    };
+                    precomputed.naf = this._getNAFPoints(8);
+                    precomputed.doubles = this._getDoubles(4, power);
+                    precomputed.beta = this._getBeta();
+                    this.precomputed = precomputed;
+
+                    return this;
+                };
+
+                BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
+                    if (!this.precomputed)
+                        return false;
+
+                    var doubles = this.precomputed.doubles;
+                    if (!doubles)
+                        return false;
+
+                    return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
+                };
+
+                BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
+                    if (this.precomputed && this.precomputed.doubles)
+                        return this.precomputed.doubles;
+
+                    var doubles = [this];
+                    var acc = this;
+                    for (var i = 0; i < power; i += step) {
+                        for (var j = 0; j < step; j++)
+                            acc = acc.dbl();
+                        doubles.push(acc);
+                    }
+                    return {
+                        step: step,
+                        points: doubles
+                    };
+                };
+
+                BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
+                    if (this.precomputed && this.precomputed.naf)
+                        return this.precomputed.naf;
+
+                    var res = [this];
+                    var max = (1 << wnd) - 1;
+                    var dbl = max === 1 ? null : this.dbl();
+                    for (var i = 1; i < max; i++)
+                        res[i] = res[i - 1].add(dbl);
+                    return {
+                        wnd: wnd,
+                        points: res
+                    };
+                };
+
+                BasePoint.prototype._getBeta = function _getBeta() {
+                    return null;
+                };
+
+                BasePoint.prototype.dblp = function dblp(k) {
+                    var r = this;
+                    for (var i = 0; i < k; i++)
+                        r = r.dbl();
+                    return r;
+                };
+
+            }, {
+                "../../elliptic": 74,
+                "bn.js": 24
+            }],
+            76: [function (require, module, exports) {
+                'use strict';
+
+                var curve = require('../curve');
+                var elliptic = require('../../elliptic');
+                var BN = require('bn.js');
+                var inherits = require('inherits');
+                var Base = curve.base;
+
+                var assert = elliptic.utils.assert;
+
+                function EdwardsCurve(conf) {
+                    // NOTE: Important as we are creating point in Base.call()
+                    this.twisted = (conf.a | 0) !== 1;
+                    this.mOneA = this.twisted && (conf.a | 0) === -1;
+                    this.extended = this.mOneA;
+
+                    Base.call(this, 'edwards', conf);
+
+                    this.a = new BN(conf.a, 16).umod(this.red.m);
+                    this.a = this.a.toRed(this.red);
+                    this.c = new BN(conf.c, 16).toRed(this.red);
+                    this.c2 = this.c.redSqr();
+                    this.d = new BN(conf.d, 16).toRed(this.red);
+                    this.dd = this.d.redAdd(this.d);
+
+                    assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
+                    this.oneC = (conf.c | 0) === 1;
+                }
+                inherits(EdwardsCurve, Base);
+                module.exports = EdwardsCurve;
+
+                EdwardsCurve.prototype._mulA = function _mulA(num) {
+                    if (this.mOneA)
+                        return num.redNeg();
+                    else
+                        return this.a.redMul(num);
+                };
+
+                EdwardsCurve.prototype._mulC = function _mulC(num) {
+                    if (this.oneC)
+                        return num;
+                    else
+                        return this.c.redMul(num);
+                };
+
+                // Just for compatibility with Short curve
+                EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
+                    return this.point(x, y, z, t);
+                };
+
+                EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
+                    x = new BN(x, 16);
+                    if (!x.red)
+                        x = x.toRed(this.red);
+
+                    var x2 = x.redSqr();
+                    var rhs = this.c2.redSub(this.a.redMul(x2));
+                    var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
+
+                    var y2 = rhs.redMul(lhs.redInvm());
+                    var y = y2.redSqrt();
+                    if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
+                        throw new Error('invalid point');
+
+                    var isOdd = y.fromRed().isOdd();
+                    if (odd && !isOdd || !odd && isOdd)
+                        y = y.redNeg();
+
+                    return this.point(x, y);
+                };
+
+                EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
+                    y = new BN(y, 16);
+                    if (!y.red)
+                        y = y.toRed(this.red);
+
+                    // x^2 = (y^2 - 1) / (d y^2 + 1)
+                    var y2 = y.redSqr();
+                    var lhs = y2.redSub(this.one);
+                    var rhs = y2.redMul(this.d).redAdd(this.one);
+                    var x2 = lhs.redMul(rhs.redInvm());
+
+                    if (x2.cmp(this.zero) === 0) {
+                        if (odd)
+                            throw new Error('invalid point');
+                        else
+                            return this.point(this.zero, y);
+                    }
+
+                    var x = x2.redSqrt();
+                    if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)
+                        throw new Error('invalid point');
+
+                    if (x.isOdd() !== odd)
+                        x = x.redNeg();
+
+                    return this.point(x, y);
+                };
+
+                EdwardsCurve.prototype.validate = function validate(point) {
+                    if (point.isInfinity())
+                        return true;
+
+                    // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)
+                    point.normalize();
+
+                    var x2 = point.x.redSqr();
+                    var y2 = point.y.redSqr();
+                    var lhs = x2.redMul(this.a).redAdd(y2);
+                    var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
+
+                    return lhs.cmp(rhs) === 0;
+                };
+
+                function Point(curve, x, y, z, t) {
+                    Base.BasePoint.call(this, curve, 'projective');
+                    if (x === null && y === null && z === null) {
+                        this.x = this.curve.zero;
+                        this.y = this.curve.one;
+                        this.z = this.curve.one;
+                        this.t = this.curve.zero;
+                        this.zOne = true;
+                    } else {
+                        this.x = new BN(x, 16);
+                        this.y = new BN(y, 16);
+                        this.z = z ? new BN(z, 16) : this.curve.one;
+                        this.t = t && new BN(t, 16);
+                        if (!this.x.red)
+                            this.x = this.x.toRed(this.curve.red);
+                        if (!this.y.red)
+                            this.y = this.y.toRed(this.curve.red);
+                        if (!this.z.red)
+                            this.z = this.z.toRed(this.curve.red);
+                        if (this.t && !this.t.red)
+                            this.t = this.t.toRed(this.curve.red);
+                        this.zOne = this.z === this.curve.one;
+
+                        // Use extended coordinates
+                        if (this.curve.extended && !this.t) {
+                            this.t = this.x.redMul(this.y);
+                            if (!this.zOne)
+                                this.t = this.t.redMul(this.z.redInvm());
+                        }
+                    }
+                }
+                inherits(Point, Base.BasePoint);
+
+                EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
+                    return Point.fromJSON(this, obj);
+                };
+
+                EdwardsCurve.prototype.point = function point(x, y, z, t) {
+                    return new Point(this, x, y, z, t);
+                };
+
+                Point.fromJSON = function fromJSON(curve, obj) {
+                    return new Point(curve, obj[0], obj[1], obj[2]);
+                };
+
+                Point.prototype.inspect = function inspect() {
+                    if (this.isInfinity())
+                        return '<EC Point Infinity>';
+                    return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
+                        ' y: ' + this.y.fromRed().toString(16, 2) +
+                        ' z: ' + this.z.fromRed().toString(16, 2) + '>';
+                };
+
+                Point.prototype.isInfinity = function isInfinity() {
+                    // XXX This code assumes that zero is always zero in red
+                    return this.x.cmpn(0) === 0 &&
+                        this.y.cmp(this.z) === 0;
+                };
+
+                Point.prototype._extDbl = function _extDbl() {
+                    // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
+                    //     #doubling-dbl-2008-hwcd
+                    // 4M + 4S
+
+                    // A = X1^2
+                    var a = this.x.redSqr();
+                    // B = Y1^2
+                    var b = this.y.redSqr();
+                    // C = 2 * Z1^2
+                    var c = this.z.redSqr();
+                    c = c.redIAdd(c);
+                    // D = a * A
+                    var d = this.curve._mulA(a);
+                    // E = (X1 + Y1)^2 - A - B
+                    var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);
+                    // G = D + B
+                    var g = d.redAdd(b);
+                    // F = G - C
+                    var f = g.redSub(c);
+                    // H = D - B
+                    var h = d.redSub(b);
+                    // X3 = E * F
+                    var nx = e.redMul(f);
+                    // Y3 = G * H
+                    var ny = g.redMul(h);
+                    // T3 = E * H
+                    var nt = e.redMul(h);
+                    // Z3 = F * G
+                    var nz = f.redMul(g);
+                    return this.curve.point(nx, ny, nz, nt);
+                };
+
+                Point.prototype._projDbl = function _projDbl() {
+                    // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
+                    //     #doubling-dbl-2008-bbjlp
+                    //     #doubling-dbl-2007-bl
+                    // and others
+                    // Generally 3M + 4S or 2M + 4S
+
+                    // B = (X1 + Y1)^2
+                    var b = this.x.redAdd(this.y).redSqr();
+                    // C = X1^2
+                    var c = this.x.redSqr();
+                    // D = Y1^2
+                    var d = this.y.redSqr();
+
+                    var nx;
+                    var ny;
+                    var nz;
+                    if (this.curve.twisted) {
+                        // E = a * C
+                        var e = this.curve._mulA(c);
+                        // F = E + D
+                        var f = e.redAdd(d);
+                        if (this.zOne) {
+                            // X3 = (B - C - D) * (F - 2)
+                            nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));
+                            // Y3 = F * (E - D)
+                            ny = f.redMul(e.redSub(d));
+                            // Z3 = F^2 - 2 * F
+                            nz = f.redSqr().redSub(f).redSub(f);
+                        } else {
+                            // H = Z1^2
+                            var h = this.z.redSqr();
+                            // J = F - 2 * H
+                            var j = f.redSub(h).redISub(h);
+                            // X3 = (B-C-D)*J
+                            nx = b.redSub(c).redISub(d).redMul(j);
+                            // Y3 = F * (E - D)
+                            ny = f.redMul(e.redSub(d));
+                            // Z3 = F * J
+                            nz = f.redMul(j);
+                        }
+                    } else {
+                        // E = C + D
+                        var e = c.redAdd(d);
+                        // H = (c * Z1)^2
+                        var h = this.curve._mulC(this.c.redMul(this.z)).redSqr();
+                        // J = E - 2 * H
+                        var j = e.redSub(h).redSub(h);
+                        // X3 = c * (B - E) * J
+                        nx = this.curve._mulC(b.redISub(e)).redMul(j);
+                        // Y3 = c * E * (C - D)
+                        ny = this.curve._mulC(e).redMul(c.redISub(d));
+                        // Z3 = E * J
+                        nz = e.redMul(j);
+                    }
+                    return this.curve.point(nx, ny, nz);
+                };
+
+                Point.prototype.dbl = function dbl() {
+                    if (this.isInfinity())
+                        return this;
+
+                    // Double in extended coordinates
+                    if (this.curve.extended)
+                        return this._extDbl();
+                    else
+                        return this._projDbl();
+                };
+
+                Point.prototype._extAdd = function _extAdd(p) {
+                    // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
+                    //     #addition-add-2008-hwcd-3
+                    // 8M
+
+                    // A = (Y1 - X1) * (Y2 - X2)
+                    var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));
+                    // B = (Y1 + X1) * (Y2 + X2)
+                    var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));
+                    // C = T1 * k * T2
+                    var c = this.t.redMul(this.curve.dd).redMul(p.t);
+                    // D = Z1 * 2 * Z2
+                    var d = this.z.redMul(p.z.redAdd(p.z));
+                    // E = B - A
+                    var e = b.redSub(a);
+                    // F = D - C
+                    var f = d.redSub(c);
+                    // G = D + C
+                    var g = d.redAdd(c);
+                    // H = B + A
+                    var h = b.redAdd(a);
+                    // X3 = E * F
+                    var nx = e.redMul(f);
+                    // Y3 = G * H
+                    var ny = g.redMul(h);
+                    // T3 = E * H
+                    var nt = e.redMul(h);
+                    // Z3 = F * G
+                    var nz = f.redMul(g);
+                    return this.curve.point(nx, ny, nz, nt);
+                };
+
+                Point.prototype._projAdd = function _projAdd(p) {
+                    // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
+                    //     #addition-add-2008-bbjlp
+                    //     #addition-add-2007-bl
+                    // 10M + 1S
+
+                    // A = Z1 * Z2
+                    var a = this.z.redMul(p.z);
+                    // B = A^2
+                    var b = a.redSqr();
+                    // C = X1 * X2
+                    var c = this.x.redMul(p.x);
+                    // D = Y1 * Y2
+                    var d = this.y.redMul(p.y);
+                    // E = d * C * D
+                    var e = this.curve.d.redMul(c).redMul(d);
+                    // F = B - E
+                    var f = b.redSub(e);
+                    // G = B + E
+                    var g = b.redAdd(e);
+                    // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)
+                    var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
+                    var nx = a.redMul(f).redMul(tmp);
+                    var ny;
+                    var nz;
+                    if (this.curve.twisted) {
+                        // Y3 = A * G * (D - a * C)
+                        ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));
+                        // Z3 = F * G
+                        nz = f.redMul(g);
+                    } else {
+                        // Y3 = A * G * (D - C)
+                        ny = a.redMul(g).redMul(d.redSub(c));
+                        // Z3 = c * F * G
+                        nz = this.curve._mulC(f).redMul(g);
+                    }
+                    return this.curve.point(nx, ny, nz);
+                };
+
+                Point.prototype.add = function add(p) {
+                    if (this.isInfinity())
+                        return p;
+                    if (p.isInfinity())
+                        return this;
+
+                    if (this.curve.extended)
+                        return this._extAdd(p);
+                    else
+                        return this._projAdd(p);
+                };
+
+                Point.prototype.mul = function mul(k) {
+                    if (this._hasDoubles(k))
+                        return this.curve._fixedNafMul(this, k);
+                    else
+                        return this.curve._wnafMul(this, k);
+                };
+
+                Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
+                    return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);
+                };
+
+                Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
+                    return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);
+                };
+
+                Point.prototype.normalize = function normalize() {
+                    if (this.zOne)
+                        return this;
+
+                    // Normalize coordinates
+                    var zi = this.z.redInvm();
+                    this.x = this.x.redMul(zi);
+                    this.y = this.y.redMul(zi);
+                    if (this.t)
+                        this.t = this.t.redMul(zi);
+                    this.z = this.curve.one;
+                    this.zOne = true;
+                    return this;
+                };
+
+                Point.prototype.neg = function neg() {
+                    return this.curve.point(this.x.redNeg(),
+                        this.y,
+                        this.z,
+                        this.t && this.t.redNeg());
+                };
+
+                Point.prototype.getX = function getX() {
+                    this.normalize();
+                    return this.x.fromRed();
+                };
+
+                Point.prototype.getY = function getY() {
+                    this.normalize();
+                    return this.y.fromRed();
+                };
+
+                Point.prototype.eq = function eq(other) {
+                    return this === other ||
+                        this.getX().cmp(other.getX()) === 0 &&
+                        this.getY().cmp(other.getY()) === 0;
+                };
+
+                Point.prototype.eqXToP = function eqXToP(x) {
+                    var rx = x.toRed(this.curve.red).redMul(this.z);
+                    if (this.x.cmp(rx) === 0)
+                        return true;
+
+                    var xc = x.clone();
+                    var t = this.curve.redN.redMul(this.z);
+                    for (;;) {
+                        xc.iadd(this.curve.n);
+                        if (xc.cmp(this.curve.p) >= 0)
+                            return false;
+
+                        rx.redIAdd(t);
+                        if (this.x.cmp(rx) === 0)
+                            return true;
+                    }
+                    return false;
+                };
+
+                // Compatibility with BaseCurve
+                Point.prototype.toP = Point.prototype.normalize;
+                Point.prototype.mixedAdd = Point.prototype.add;
+
+            }, {
+                "../../elliptic": 74,
+                "../curve": 77,
+                "bn.js": 24,
+                "inherits": 107
+            }],
+            77: [function (require, module, exports) {
+                'use strict';
+
+                var curve = exports;
+
+                curve.base = require('./base');
+                curve.short = require('./short');
+                curve.mont = require('./mont');
+                curve.edwards = require('./edwards');
+
+            }, {
+                "./base": 75,
+                "./edwards": 76,
+                "./mont": 78,
+                "./short": 79
+            }],
+            78: [function (require, module, exports) {
+                'use strict';
+
+                var curve = require('../curve');
+                var BN = require('bn.js');
+                var inherits = require('inherits');
+                var Base = curve.base;
+
+                var elliptic = require('../../elliptic');
+                var utils = elliptic.utils;
+
+                function MontCurve(conf) {
+                    Base.call(this, 'mont', conf);
+
+                    this.a = new BN(conf.a, 16).toRed(this.red);
+                    this.b = new BN(conf.b, 16).toRed(this.red);
+                    this.i4 = new BN(4).toRed(this.red).redInvm();
+                    this.two = new BN(2).toRed(this.red);
+                    this.a24 = this.i4.redMul(this.a.redAdd(this.two));
+                }
+                inherits(MontCurve, Base);
+                module.exports = MontCurve;
+
+                MontCurve.prototype.validate = function validate(point) {
+                    var x = point.normalize().x;
+                    var x2 = x.redSqr();
+                    var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
+                    var y = rhs.redSqrt();
+
+                    return y.redSqr().cmp(rhs) === 0;
+                };
+
+                function Point(curve, x, z) {
+                    Base.BasePoint.call(this, curve, 'projective');
+                    if (x === null && z === null) {
+                        this.x = this.curve.one;
+                        this.z = this.curve.zero;
+                    } else {
+                        this.x = new BN(x, 16);
+                        this.z = new BN(z, 16);
+                        if (!this.x.red)
+                            this.x = this.x.toRed(this.curve.red);
+                        if (!this.z.red)
+                            this.z = this.z.toRed(this.curve.red);
+                    }
+                }
+                inherits(Point, Base.BasePoint);
+
+                MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
+                    return this.point(utils.toArray(bytes, enc), 1);
+                };
+
+                MontCurve.prototype.point = function point(x, z) {
+                    return new Point(this, x, z);
+                };
+
+                MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
+                    return Point.fromJSON(this, obj);
+                };
+
+                Point.prototype.precompute = function precompute() {
+                    // No-op
+                };
+
+                Point.prototype._encode = function _encode() {
+                    return this.getX().toArray('be', this.curve.p.byteLength());
+                };
+
+                Point.fromJSON = function fromJSON(curve, obj) {
+                    return new Point(curve, obj[0], obj[1] || curve.one);
+                };
+
+                Point.prototype.inspect = function inspect() {
+                    if (this.isInfinity())
+                        return '<EC Point Infinity>';
+                    return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
+                        ' z: ' + this.z.fromRed().toString(16, 2) + '>';
+                };
+
+                Point.prototype.isInfinity = function isInfinity() {
+                    // XXX This code assumes that zero is always zero in red
+                    return this.z.cmpn(0) === 0;
+                };
+
+                Point.prototype.dbl = function dbl() {
+                    // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3
+                    // 2M + 2S + 4A
+
+                    // A = X1 + Z1
+                    var a = this.x.redAdd(this.z);
+                    // AA = A^2
+                    var aa = a.redSqr();
+                    // B = X1 - Z1
+                    var b = this.x.redSub(this.z);
+                    // BB = B^2
+                    var bb = b.redSqr();
+                    // C = AA - BB
+                    var c = aa.redSub(bb);
+                    // X3 = AA * BB
+                    var nx = aa.redMul(bb);
+                    // Z3 = C * (BB + A24 * C)
+                    var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
+                    return this.curve.point(nx, nz);
+                };
+
+                Point.prototype.add = function add() {
+                    throw new Error('Not supported on Montgomery curve');
+                };
+
+                Point.prototype.diffAdd = function diffAdd(p, diff) {
+                    // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3
+                    // 4M + 2S + 6A
+
+                    // A = X2 + Z2
+                    var a = this.x.redAdd(this.z);
+                    // B = X2 - Z2
+                    var b = this.x.redSub(this.z);
+                    // C = X3 + Z3
+                    var c = p.x.redAdd(p.z);
+                    // D = X3 - Z3
+                    var d = p.x.redSub(p.z);
+                    // DA = D * A
+                    var da = d.redMul(a);
+                    // CB = C * B
+                    var cb = c.redMul(b);
+                    // X5 = Z1 * (DA + CB)^2
+                    var nx = diff.z.redMul(da.redAdd(cb).redSqr());
+                    // Z5 = X1 * (DA - CB)^2
+                    var nz = diff.x.redMul(da.redISub(cb).redSqr());
+                    return this.curve.point(nx, nz);
+                };
+
+                Point.prototype.mul = function mul(k) {
+                    var t = k.clone();
+                    var a = this; // (N / 2) * Q + Q
+                    var b = this.curve.point(null, null); // (N / 2) * Q
+                    var c = this; // Q
+
+                    for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))
+                        bits.push(t.andln(1));
+
+                    for (var i = bits.length - 1; i >= 0; i--) {
+                        if (bits[i] === 0) {
+                            // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q
+                            a = a.diffAdd(b, c);
+                            // N * Q = 2 * ((N / 2) * Q + Q))
+                            b = b.dbl();
+                        } else {
+                            // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)
+                            b = a.diffAdd(b, c);
+                            // N * Q + Q = 2 * ((N / 2) * Q + Q)
+                            a = a.dbl();
+                        }
+                    }
+                    return b;
+                };
+
+                Point.prototype.mulAdd = function mulAdd() {
+                    throw new Error('Not supported on Montgomery curve');
+                };
+
+                Point.prototype.jumlAdd = function jumlAdd() {
+                    throw new Error('Not supported on Montgomery curve');
+                };
+
+                Point.prototype.eq = function eq(other) {
+                    return this.getX().cmp(other.getX()) === 0;
+                };
+
+                Point.prototype.normalize = function normalize() {
+                    this.x = this.x.redMul(this.z.redInvm());
+                    this.z = this.curve.one;
+                    return this;
+                };
+
+                Point.prototype.getX = function getX() {
+                    // Normalize coordinates
+                    this.normalize();
+
+                    return this.x.fromRed();
+                };
+
+            }, {
+                "../../elliptic": 74,
+                "../curve": 77,
+                "bn.js": 24,
+                "inherits": 107
+            }],
+            79: [function (require, module, exports) {
+                'use strict';
+
+                var curve = require('../curve');
+                var elliptic = require('../../elliptic');
+                var BN = require('bn.js');
+                var inherits = require('inherits');
+                var Base = curve.base;
+
+                var assert = elliptic.utils.assert;
+
+                function ShortCurve(conf) {
+                    Base.call(this, 'short', conf);
+
+                    this.a = new BN(conf.a, 16).toRed(this.red);
+                    this.b = new BN(conf.b, 16).toRed(this.red);
+                    this.tinv = this.two.redInvm();
+
+                    this.zeroA = this.a.fromRed().cmpn(0) === 0;
+                    this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;
+
+                    // If the curve is endomorphic, precalculate beta and lambda
+                    this.endo = this._getEndomorphism(conf);
+                    this._endoWnafT1 = new Array(4);
+                    this._endoWnafT2 = new Array(4);
+                }
+                inherits(ShortCurve, Base);
+                module.exports = ShortCurve;
+
+                ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
+                    // No efficient endomorphism
+                    if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)
+                        return;
+
+                    // Compute beta and lambda, that lambda * P = (beta * Px; Py)
+                    var beta;
+                    var lambda;
+                    if (conf.beta) {
+                        beta = new BN(conf.beta, 16).toRed(this.red);
+                    } else {
+                        var betas = this._getEndoRoots(this.p);
+                        // Choose the smallest beta
+                        beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
+                        beta = beta.toRed(this.red);
+                    }
+                    if (conf.lambda) {
+                        lambda = new BN(conf.lambda, 16);
+                    } else {
+                        // Choose the lambda that is matching selected beta
+                        var lambdas = this._getEndoRoots(this.n);
+                        if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
+                            lambda = lambdas[0];
+                        } else {
+                            lambda = lambdas[1];
+                            assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
+                        }
+                    }
+
+                    // Get basis vectors, used for balanced length-two representation
+                    var basis;
+                    if (conf.basis) {
+                        basis = conf.basis.map(function (vec) {
+                            return {
+                                a: new BN(vec.a, 16),
+                                b: new BN(vec.b, 16)
+                            };
+                        });
+                    } else {
+                        basis = this._getEndoBasis(lambda);
+                    }
+
+                    return {
+                        beta: beta,
+                        lambda: lambda,
+                        basis: basis
+                    };
+                };
+
+                ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
+                    // Find roots of for x^2 + x + 1 in F
+                    // Root = (-1 +- Sqrt(-3)) / 2
+                    //
+                    var red = num === this.p ? this.red : BN.mont(num);
+                    var tinv = new BN(2).toRed(red).redInvm();
+                    var ntinv = tinv.redNeg();
+
+                    var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
+
+                    var l1 = ntinv.redAdd(s).fromRed();
+                    var l2 = ntinv.redSub(s).fromRed();
+                    return [l1, l2];
+                };
+
+                ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
+                    // aprxSqrt >= sqrt(this.n)
+                    var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
+
+                    // 3.74
+                    // Run EGCD, until r(L + 1) < aprxSqrt
+                    var u = lambda;
+                    var v = this.n.clone();
+                    var x1 = new BN(1);
+                    var y1 = new BN(0);
+                    var x2 = new BN(0);
+                    var y2 = new BN(1);
+
+                    // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)
+                    var a0;
+                    var b0;
+                    // First vector
+                    var a1;
+                    var b1;
+                    // Second vector
+                    var a2;
+                    var b2;
+
+                    var prevR;
+                    var i = 0;
+                    var r;
+                    var x;
+                    while (u.cmpn(0) !== 0) {
+                        var q = v.div(u);
+                        r = v.sub(q.mul(u));
+                        x = x2.sub(q.mul(x1));
+                        var y = y2.sub(q.mul(y1));
+
+                        if (!a1 && r.cmp(aprxSqrt) < 0) {
+                            a0 = prevR.neg();
+                            b0 = x1;
+                            a1 = r.neg();
+                            b1 = x;
+                        } else if (a1 && ++i === 2) {
+                            break;
+                        }
+                        prevR = r;
+
+                        v = u;
+                        u = r;
+                        x2 = x1;
+                        x1 = x;
+                        y2 = y1;
+                        y1 = y;
+                    }
+                    a2 = r.neg();
+                    b2 = x;
+
+                    var len1 = a1.sqr().add(b1.sqr());
+                    var len2 = a2.sqr().add(b2.sqr());
+                    if (len2.cmp(len1) >= 0) {
+                        a2 = a0;
+                        b2 = b0;
+                    }
+
+                    // Normalize signs
+                    if (a1.negative) {
+                        a1 = a1.neg();
+                        b1 = b1.neg();
+                    }
+                    if (a2.negative) {
+                        a2 = a2.neg();
+                        b2 = b2.neg();
+                    }
+
+                    return [{
+                            a: a1,
+                            b: b1
+                        },
+                        {
+                            a: a2,
+                            b: b2
+                        }
+                    ];
+                };
+
+                ShortCurve.prototype._endoSplit = function _endoSplit(k) {
+                    var basis = this.endo.basis;
+                    var v1 = basis[0];
+                    var v2 = basis[1];
+
+                    var c1 = v2.b.mul(k).divRound(this.n);
+                    var c2 = v1.b.neg().mul(k).divRound(this.n);
+
+                    var p1 = c1.mul(v1.a);
+                    var p2 = c2.mul(v2.a);
+                    var q1 = c1.mul(v1.b);
+                    var q2 = c2.mul(v2.b);
+
+                    // Calculate answer
+                    var k1 = k.sub(p1).sub(p2);
+                    var k2 = q1.add(q2).neg();
+                    return {
+                        k1: k1,
+                        k2: k2
+                    };
+                };
+
+                ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
+                    x = new BN(x, 16);
+                    if (!x.red)
+                        x = x.toRed(this.red);
+
+                    var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
+                    var y = y2.redSqrt();
+                    if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
+                        throw new Error('invalid point');
+
+                    // XXX Is there any way to tell if the number is odd without converting it
+                    // to non-red form?
+                    var isOdd = y.fromRed().isOdd();
+                    if (odd && !isOdd || !odd && isOdd)
+                        y = y.redNeg();
+
+                    return this.point(x, y);
+                };
+
+                ShortCurve.prototype.validate = function validate(point) {
+                    if (point.inf)
+                        return true;
+
+                    var x = point.x;
+                    var y = point.y;
+
+                    var ax = this.a.redMul(x);
+                    var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
+                    return y.redSqr().redISub(rhs).cmpn(0) === 0;
+                };
+
+                ShortCurve.prototype._endoWnafMulAdd =
+                    function _endoWnafMulAdd(points, coeffs, jacobianResult) {
+                        var npoints = this._endoWnafT1;
+                        var ncoeffs = this._endoWnafT2;
+                        for (var i = 0; i < points.length; i++) {
+                            var split = this._endoSplit(coeffs[i]);
+                            var p = points[i];
+                            var beta = p._getBeta();
+
+                            if (split.k1.negative) {
+                                split.k1.ineg();
+                                p = p.neg(true);
+                            }
+                            if (split.k2.negative) {
+                                split.k2.ineg();
+                                beta = beta.neg(true);
+                            }
+
+                            npoints[i * 2] = p;
+                            npoints[i * 2 + 1] = beta;
+                            ncoeffs[i * 2] = split.k1;
+                            ncoeffs[i * 2 + 1] = split.k2;
+                        }
+                        var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);
+
+                        // Clean-up references to points and coefficients
+                        for (var j = 0; j < i * 2; j++) {
+                            npoints[j] = null;
+                            ncoeffs[j] = null;
+                        }
+                        return res;
+                    };
+
+                function Point(curve, x, y, isRed) {
+                    Base.BasePoint.call(this, curve, 'affine');
+                    if (x === null && y === null) {
+                        this.x = null;
+                        this.y = null;
+                        this.inf = true;
+                    } else {
+                        this.x = new BN(x, 16);
+                        this.y = new BN(y, 16);
+                        // Force redgomery representation when loading from JSON
+                        if (isRed) {
+                            this.x.forceRed(this.curve.red);
+                            this.y.forceRed(this.curve.red);
+                        }
+                        if (!this.x.red)
+                            this.x = this.x.toRed(this.curve.red);
+                        if (!this.y.red)
+                            this.y = this.y.toRed(this.curve.red);
+                        this.inf = false;
+                    }
+                }
+                inherits(Point, Base.BasePoint);
+
+                ShortCurve.prototype.point = function point(x, y, isRed) {
+                    return new Point(this, x, y, isRed);
+                };
+
+                ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
+                    return Point.fromJSON(this, obj, red);
+                };
+
+                Point.prototype._getBeta = function _getBeta() {
+                    if (!this.curve.endo)
+                        return;
+
+                    var pre = this.precomputed;
+                    if (pre && pre.beta)
+                        return pre.beta;
+
+                    var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
+                    if (pre) {
+                        var curve = this.curve;
+                        var endoMul = function (p) {
+                            return curve.point(p.x.redMul(curve.endo.beta), p.y);
+                        };
+                        pre.beta = beta;
+                        beta.precomputed = {
+                            beta: null,
+                            naf: pre.naf && {
+                                wnd: pre.naf.wnd,
+                                points: pre.naf.points.map(endoMul)
+                            },
+                            doubles: pre.doubles && {
+                                step: pre.doubles.step,
+                                points: pre.doubles.points.map(endoMul)
+                            }
+                        };
+                    }
+                    return beta;
+                };
+
+                Point.prototype.toJSON = function toJSON() {
+                    if (!this.precomputed)
+                        return [this.x, this.y];
+
+                    return [this.x, this.y, this.precomputed && {
+                        doubles: this.precomputed.doubles && {
+                            step: this.precomputed.doubles.step,
+                            points: this.precomputed.doubles.points.slice(1)
+                        },
+                        naf: this.precomputed.naf && {
+                            wnd: this.precomputed.naf.wnd,
+                            points: this.precomputed.naf.points.slice(1)
+                        }
+                    }];
+                };
+
+                Point.fromJSON = function fromJSON(curve, obj, red) {
+                    if (typeof obj === 'string')
+                        obj = JSON.parse(obj);
+                    var res = curve.point(obj[0], obj[1], red);
+                    if (!obj[2])
+                        return res;
+
+                    function obj2point(obj) {
+                        return curve.point(obj[0], obj[1], red);
+                    }
+
+                    var pre = obj[2];
+                    res.precomputed = {
+                        beta: null,
+                        doubles: pre.doubles && {
+                            step: pre.doubles.step,
+                            points: [res].concat(pre.doubles.points.map(obj2point))
+                        },
+                        naf: pre.naf && {
+                            wnd: pre.naf.wnd,
+                            points: [res].concat(pre.naf.points.map(obj2point))
+                        }
+                    };
+                    return res;
+                };
+
+                Point.prototype.inspect = function inspect() {
+                    if (this.isInfinity())
+                        return '<EC Point Infinity>';
+                    return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
+                        ' y: ' + this.y.fromRed().toString(16, 2) + '>';
+                };
+
+                Point.prototype.isInfinity = function isInfinity() {
+                    return this.inf;
+                };
+
+                Point.prototype.add = function add(p) {
+                    // O + P = P
+                    if (this.inf)
+                        return p;
+
+                    // P + O = P
+                    if (p.inf)
+                        return this;
+
+                    // P + P = 2P
+                    if (this.eq(p))
+                        return this.dbl();
+
+                    // P + (-P) = O
+                    if (this.neg().eq(p))
+                        return this.curve.point(null, null);
+
+                    // P + Q = O
+                    if (this.x.cmp(p.x) === 0)
+                        return this.curve.point(null, null);
+
+                    var c = this.y.redSub(p.y);
+                    if (c.cmpn(0) !== 0)
+                        c = c.redMul(this.x.redSub(p.x).redInvm());
+                    var nx = c.redSqr().redISub(this.x).redISub(p.x);
+                    var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
+                    return this.curve.point(nx, ny);
+                };
+
+                Point.prototype.dbl = function dbl() {
+                    if (this.inf)
+                        return this;
+
+                    // 2P = O
+                    var ys1 = this.y.redAdd(this.y);
+                    if (ys1.cmpn(0) === 0)
+                        return this.curve.point(null, null);
+
+                    var a = this.curve.a;
+
+                    var x2 = this.x.redSqr();
+                    var dyinv = ys1.redInvm();
+                    var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
+
+                    var nx = c.redSqr().redISub(this.x.redAdd(this.x));
+                    var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
+                    return this.curve.point(nx, ny);
+                };
+
+                Point.prototype.getX = function getX() {
+                    return this.x.fromRed();
+                };
+
+                Point.prototype.getY = function getY() {
+                    return this.y.fromRed();
+                };
+
+                Point.prototype.mul = function mul(k) {
+                    k = new BN(k, 16);
+
+                    if (this._hasDoubles(k))
+                        return this.curve._fixedNafMul(this, k);
+                    else if (this.curve.endo)
+                        return this.curve._endoWnafMulAdd([this], [k]);
+                    else
+                        return this.curve._wnafMul(this, k);
+                };
+
+                Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
+                    var points = [this, p2];
+                    var coeffs = [k1, k2];
+                    if (this.curve.endo)
+                        return this.curve._endoWnafMulAdd(points, coeffs);
+                    else
+                        return this.curve._wnafMulAdd(1, points, coeffs, 2);
+                };
+
+                Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
+                    var points = [this, p2];
+                    var coeffs = [k1, k2];
+                    if (this.curve.endo)
+                        return this.curve._endoWnafMulAdd(points, coeffs, true);
+                    else
+                        return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
+                };
+
+                Point.prototype.eq = function eq(p) {
+                    return this === p ||
+                        this.inf === p.inf &&
+                        (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
+                };
+
+                Point.prototype.neg = function neg(_precompute) {
+                    if (this.inf)
+                        return this;
+
+                    var res = this.curve.point(this.x, this.y.redNeg());
+                    if (_precompute && this.precomputed) {
+                        var pre = this.precomputed;
+                        var negate = function (p) {
+                            return p.neg();
+                        };
+                        res.precomputed = {
+                            naf: pre.naf && {
+                                wnd: pre.naf.wnd,
+                                points: pre.naf.points.map(negate)
+                            },
+                            doubles: pre.doubles && {
+                                step: pre.doubles.step,
+                                points: pre.doubles.points.map(negate)
+                            }
+                        };
+                    }
+                    return res;
+                };
+
+                Point.prototype.toJ = function toJ() {
+                    if (this.inf)
+                        return this.curve.jpoint(null, null, null);
+
+                    var res = this.curve.jpoint(this.x, this.y, this.curve.one);
+                    return res;
+                };
+
+                function JPoint(curve, x, y, z) {
+                    Base.BasePoint.call(this, curve, 'jacobian');
+                    if (x === null && y === null && z === null) {
+                        this.x = this.curve.one;
+                        this.y = this.curve.one;
+                        this.z = new BN(0);
+                    } else {
+                        this.x = new BN(x, 16);
+                        this.y = new BN(y, 16);
+                        this.z = new BN(z, 16);
+                    }
+                    if (!this.x.red)
+                        this.x = this.x.toRed(this.curve.red);
+                    if (!this.y.red)
+                        this.y = this.y.toRed(this.curve.red);
+                    if (!this.z.red)
+                        this.z = this.z.toRed(this.curve.red);
+
+                    this.zOne = this.z === this.curve.one;
+                }
+                inherits(JPoint, Base.BasePoint);
+
+                ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
+                    return new JPoint(this, x, y, z);
+                };
+
+                JPoint.prototype.toP = function toP() {
+                    if (this.isInfinity())
+                        return this.curve.point(null, null);
+
+                    var zinv = this.z.redInvm();
+                    var zinv2 = zinv.redSqr();
+                    var ax = this.x.redMul(zinv2);
+                    var ay = this.y.redMul(zinv2).redMul(zinv);
+
+                    return this.curve.point(ax, ay);
+                };
+
+                JPoint.prototype.neg = function neg() {
+                    return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
+                };
+
+                JPoint.prototype.add = function add(p) {
+                    // O + P = P
+                    if (this.isInfinity())
+                        return p;
+
+                    // P + O = P
+                    if (p.isInfinity())
+                        return this;
+
+                    // 12M + 4S + 7A
+                    var pz2 = p.z.redSqr();
+                    var z2 = this.z.redSqr();
+                    var u1 = this.x.redMul(pz2);
+                    var u2 = p.x.redMul(z2);
+                    var s1 = this.y.redMul(pz2.redMul(p.z));
+                    var s2 = p.y.redMul(z2.redMul(this.z));
+
+                    var h = u1.redSub(u2);
+                    var r = s1.redSub(s2);
+                    if (h.cmpn(0) === 0) {
+                        if (r.cmpn(0) !== 0)
+                            return this.curve.jpoint(null, null, null);
+                        else
+                            return this.dbl();
+                    }
+
+                    var h2 = h.redSqr();
+                    var h3 = h2.redMul(h);
+                    var v = u1.redMul(h2);
+
+                    var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
+                    var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
+                    var nz = this.z.redMul(p.z).redMul(h);
+
+                    return this.curve.jpoint(nx, ny, nz);
+                };
+
+                JPoint.prototype.mixedAdd = function mixedAdd(p) {
+                    // O + P = P
+                    if (this.isInfinity())
+                        return p.toJ();
+
+                    // P + O = P
+                    if (p.isInfinity())
+                        return this;
+
+                    // 8M + 3S + 7A
+                    var z2 = this.z.redSqr();
+                    var u1 = this.x;
+                    var u2 = p.x.redMul(z2);
+                    var s1 = this.y;
+                    var s2 = p.y.redMul(z2).redMul(this.z);
+
+                    var h = u1.redSub(u2);
+                    var r = s1.redSub(s2);
+                    if (h.cmpn(0) === 0) {
+                        if (r.cmpn(0) !== 0)
+                            return this.curve.jpoint(null, null, null);
+                        else
+                            return this.dbl();
+                    }
+
+                    var h2 = h.redSqr();
+                    var h3 = h2.redMul(h);
+                    var v = u1.redMul(h2);
+
+                    var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
+                    var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
+                    var nz = this.z.redMul(h);
+
+                    return this.curve.jpoint(nx, ny, nz);
+                };
+
+                JPoint.prototype.dblp = function dblp(pow) {
+                    if (pow === 0)
+                        return this;
+                    if (this.isInfinity())
+                        return this;
+                    if (!pow)
+                        return this.dbl();
+
+                    if (this.curve.zeroA || this.curve.threeA) {
+                        var r = this;
+                        for (var i = 0; i < pow; i++)
+                            r = r.dbl();
+                        return r;
+                    }
+
+                    // 1M + 2S + 1A + N * (4S + 5M + 8A)
+                    // N = 1 => 6M + 6S + 9A
+                    var a = this.curve.a;
+                    var tinv = this.curve.tinv;
+
+                    var jx = this.x;
+                    var jy = this.y;
+                    var jz = this.z;
+                    var jz4 = jz.redSqr().redSqr();
+
+                    // Reuse results
+                    var jyd = jy.redAdd(jy);
+                    for (var i = 0; i < pow; i++) {
+                        var jx2 = jx.redSqr();
+                        var jyd2 = jyd.redSqr();
+                        var jyd4 = jyd2.redSqr();
+                        var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
+
+                        var t1 = jx.redMul(jyd2);
+                        var nx = c.redSqr().redISub(t1.redAdd(t1));
+                        var t2 = t1.redISub(nx);
+                        var dny = c.redMul(t2);
+                        dny = dny.redIAdd(dny).redISub(jyd4);
+                        var nz = jyd.redMul(jz);
+                        if (i + 1 < pow)
+                            jz4 = jz4.redMul(jyd4);
+
+                        jx = nx;
+                        jz = nz;
+                        jyd = dny;
+                    }
+
+                    return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
+                };
+
+                JPoint.prototype.dbl = function dbl() {
+                    if (this.isInfinity())
+                        return this;
+
+                    if (this.curve.zeroA)
+                        return this._zeroDbl();
+                    else if (this.curve.threeA)
+                        return this._threeDbl();
+                    else
+                        return this._dbl();
+                };
+
+                JPoint.prototype._zeroDbl = function _zeroDbl() {
+                    var nx;
+                    var ny;
+                    var nz;
+                    // Z = 1
+                    if (this.zOne) {
+                        // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
+                        //     #doubling-mdbl-2007-bl
+                        // 1M + 5S + 14A
+
+                        // XX = X1^2
+                        var xx = this.x.redSqr();
+                        // YY = Y1^2
+                        var yy = this.y.redSqr();
+                        // YYYY = YY^2
+                        var yyyy = yy.redSqr();
+                        // S = 2 * ((X1 + YY)^2 - XX - YYYY)
+                        var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
+                        s = s.redIAdd(s);
+                        // M = 3 * XX + a; a = 0
+                        var m = xx.redAdd(xx).redIAdd(xx);
+                        // T = M ^ 2 - 2*S
+                        var t = m.redSqr().redISub(s).redISub(s);
+
+                        // 8 * YYYY
+                        var yyyy8 = yyyy.redIAdd(yyyy);
+                        yyyy8 = yyyy8.redIAdd(yyyy8);
+                        yyyy8 = yyyy8.redIAdd(yyyy8);
+
+                        // X3 = T
+                        nx = t;
+                        // Y3 = M * (S - T) - 8 * YYYY
+                        ny = m.redMul(s.redISub(t)).redISub(yyyy8);
+                        // Z3 = 2*Y1
+                        nz = this.y.redAdd(this.y);
+                    } else {
+                        // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
+                        //     #doubling-dbl-2009-l
+                        // 2M + 5S + 13A
+
+                        // A = X1^2
+                        var a = this.x.redSqr();
+                        // B = Y1^2
+                        var b = this.y.redSqr();
+                        // C = B^2
+                        var c = b.redSqr();
+                        // D = 2 * ((X1 + B)^2 - A - C)
+                        var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
+                        d = d.redIAdd(d);
+                        // E = 3 * A
+                        var e = a.redAdd(a).redIAdd(a);
+                        // F = E^2
+                        var f = e.redSqr();
+
+                        // 8 * C
+                        var c8 = c.redIAdd(c);
+                        c8 = c8.redIAdd(c8);
+                        c8 = c8.redIAdd(c8);
+
+                        // X3 = F - 2 * D
+                        nx = f.redISub(d).redISub(d);
+                        // Y3 = E * (D - X3) - 8 * C
+                        ny = e.redMul(d.redISub(nx)).redISub(c8);
+                        // Z3 = 2 * Y1 * Z1
+                        nz = this.y.redMul(this.z);
+                        nz = nz.redIAdd(nz);
+                    }
+
+                    return this.curve.jpoint(nx, ny, nz);
+                };
+
+                JPoint.prototype._threeDbl = function _threeDbl() {
+                    var nx;
+                    var ny;
+                    var nz;
+                    // Z = 1
+                    if (this.zOne) {
+                        // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html
+                        //     #doubling-mdbl-2007-bl
+                        // 1M + 5S + 15A
+
+                        // XX = X1^2
+                        var xx = this.x.redSqr();
+                        // YY = Y1^2
+                        var yy = this.y.redSqr();
+                        // YYYY = YY^2
+                        var yyyy = yy.redSqr();
+                        // S = 2 * ((X1 + YY)^2 - XX - YYYY)
+                        var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
+                        s = s.redIAdd(s);
+                        // M = 3 * XX + a
+                        var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
+                        // T = M^2 - 2 * S
+                        var t = m.redSqr().redISub(s).redISub(s);
+                        // X3 = T
+                        nx = t;
+                        // Y3 = M * (S - T) - 8 * YYYY
+                        var yyyy8 = yyyy.redIAdd(yyyy);
+                        yyyy8 = yyyy8.redIAdd(yyyy8);
+                        yyyy8 = yyyy8.redIAdd(yyyy8);
+                        ny = m.redMul(s.redISub(t)).redISub(yyyy8);
+                        // Z3 = 2 * Y1
+                        nz = this.y.redAdd(this.y);
+                    } else {
+                        // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b
+                        // 3M + 5S
+
+                        // delta = Z1^2
+                        var delta = this.z.redSqr();
+                        // gamma = Y1^2
+                        var gamma = this.y.redSqr();
+                        // beta = X1 * gamma
+                        var beta = this.x.redMul(gamma);
+                        // alpha = 3 * (X1 - delta) * (X1 + delta)
+                        var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
+                        alpha = alpha.redAdd(alpha).redIAdd(alpha);
+                        // X3 = alpha^2 - 8 * beta
+                        var beta4 = beta.redIAdd(beta);
+                        beta4 = beta4.redIAdd(beta4);
+                        var beta8 = beta4.redAdd(beta4);
+                        nx = alpha.redSqr().redISub(beta8);
+                        // Z3 = (Y1 + Z1)^2 - gamma - delta
+                        nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
+                        // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2
+                        var ggamma8 = gamma.redSqr();
+                        ggamma8 = ggamma8.redIAdd(ggamma8);
+                        ggamma8 = ggamma8.redIAdd(ggamma8);
+                        ggamma8 = ggamma8.redIAdd(ggamma8);
+                        ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
+                    }
+
+                    return this.curve.jpoint(nx, ny, nz);
+                };
+
+                JPoint.prototype._dbl = function _dbl() {
+                    var a = this.curve.a;
+
+                    // 4M + 6S + 10A
+                    var jx = this.x;
+                    var jy = this.y;
+                    var jz = this.z;
+                    var jz4 = jz.redSqr().redSqr();
+
+                    var jx2 = jx.redSqr();
+                    var jy2 = jy.redSqr();
+
+                    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
+
+                    var jxd4 = jx.redAdd(jx);
+                    jxd4 = jxd4.redIAdd(jxd4);
+                    var t1 = jxd4.redMul(jy2);
+                    var nx = c.redSqr().redISub(t1.redAdd(t1));
+                    var t2 = t1.redISub(nx);
+
+                    var jyd8 = jy2.redSqr();
+                    jyd8 = jyd8.redIAdd(jyd8);
+                    jyd8 = jyd8.redIAdd(jyd8);
+                    jyd8 = jyd8.redIAdd(jyd8);
+                    var ny = c.redMul(t2).redISub(jyd8);
+                    var nz = jy.redAdd(jy).redMul(jz);
+
+                    return this.curve.jpoint(nx, ny, nz);
+                };
+
+                JPoint.prototype.trpl = function trpl() {
+                    if (!this.curve.zeroA)
+                        return this.dbl().add(this);
+
+                    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl
+                    // 5M + 10S + ...
+
+                    // XX = X1^2
+                    var xx = this.x.redSqr();
+                    // YY = Y1^2
+                    var yy = this.y.redSqr();
+                    // ZZ = Z1^2
+                    var zz = this.z.redSqr();
+                    // YYYY = YY^2
+                    var yyyy = yy.redSqr();
+                    // M = 3 * XX + a * ZZ2; a = 0
+                    var m = xx.redAdd(xx).redIAdd(xx);
+                    // MM = M^2
+                    var mm = m.redSqr();
+                    // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM
+                    var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
+                    e = e.redIAdd(e);
+                    e = e.redAdd(e).redIAdd(e);
+                    e = e.redISub(mm);
+                    // EE = E^2
+                    var ee = e.redSqr();
+                    // T = 16*YYYY
+                    var t = yyyy.redIAdd(yyyy);
+                    t = t.redIAdd(t);
+                    t = t.redIAdd(t);
+                    t = t.redIAdd(t);
+                    // U = (M + E)^2 - MM - EE - T
+                    var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
+                    // X3 = 4 * (X1 * EE - 4 * YY * U)
+                    var yyu4 = yy.redMul(u);
+                    yyu4 = yyu4.redIAdd(yyu4);
+                    yyu4 = yyu4.redIAdd(yyu4);
+                    var nx = this.x.redMul(ee).redISub(yyu4);
+                    nx = nx.redIAdd(nx);
+                    nx = nx.redIAdd(nx);
+                    // Y3 = 8 * Y1 * (U * (T - U) - E * EE)
+                    var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
+                    ny = ny.redIAdd(ny);
+                    ny = ny.redIAdd(ny);
+                    ny = ny.redIAdd(ny);
+                    // Z3 = (Z1 + E)^2 - ZZ - EE
+                    var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
+
+                    return this.curve.jpoint(nx, ny, nz);
+                };
+
+                JPoint.prototype.mul = function mul(k, kbase) {
+                    k = new BN(k, kbase);
+
+                    return this.curve._wnafMul(this, k);
+                };
+
+                JPoint.prototype.eq = function eq(p) {
+                    if (p.type === 'affine')
+                        return this.eq(p.toJ());
+
+                    if (this === p)
+                        return true;
+
+                    // x1 * z2^2 == x2 * z1^2
+                    var z2 = this.z.redSqr();
+                    var pz2 = p.z.redSqr();
+                    if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)
+                        return false;
+
+                    // y1 * z2^3 == y2 * z1^3
+                    var z3 = z2.redMul(this.z);
+                    var pz3 = pz2.redMul(p.z);
+                    return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
+                };
+
+                JPoint.prototype.eqXToP = function eqXToP(x) {
+                    var zs = this.z.redSqr();
+                    var rx = x.toRed(this.curve.red).redMul(zs);
+                    if (this.x.cmp(rx) === 0)
+                        return true;
+
+                    var xc = x.clone();
+                    var t = this.curve.redN.redMul(zs);
+                    for (;;) {
+                        xc.iadd(this.curve.n);
+                        if (xc.cmp(this.curve.p) >= 0)
+                            return false;
+
+                        rx.redIAdd(t);
+                        if (this.x.cmp(rx) === 0)
+                            return true;
+                    }
+                    return false;
+                };
+
+                JPoint.prototype.inspect = function inspect() {
+                    if (this.isInfinity())
+                        return '<EC JPoint Infinity>';
+                    return '<EC JPoint x: ' + this.x.toString(16, 2) +
+                        ' y: ' + this.y.toString(16, 2) +
+                        ' z: ' + this.z.toString(16, 2) + '>';
+                };
+
+                JPoint.prototype.isInfinity = function isInfinity() {
+                    // XXX This code assumes that zero is always zero in red
+                    return this.z.cmpn(0) === 0;
+                };
+
+            }, {
+                "../../elliptic": 74,
+                "../curve": 77,
+                "bn.js": 24,
+                "inherits": 107
+            }],
+            80: [function (require, module, exports) {
+                'use strict';
+
+                var curves = exports;
+
+                var hash = require('hash.js');
+                var elliptic = require('../elliptic');
+
+                var assert = elliptic.utils.assert;
+
+                function PresetCurve(options) {
+                    if (options.type === 'short')
+                        this.curve = new elliptic.curve.short(options);
+                    else if (options.type === 'edwards')
+                        this.curve = new elliptic.curve.edwards(options);
+                    else
+                        this.curve = new elliptic.curve.mont(options);
+                    this.g = this.curve.g;
+                    this.n = this.curve.n;
+                    this.hash = options.hash;
+
+                    assert(this.g.validate(), 'Invalid curve');
+                    assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');
+                }
+                curves.PresetCurve = PresetCurve;
+
+                function defineCurve(name, options) {
+                    Object.defineProperty(curves, name, {
+                        configurable: true,
+                        enumerable: true,
+                        get: function () {
+                            var curve = new PresetCurve(options);
+                            Object.defineProperty(curves, name, {
+                                configurable: true,
+                                enumerable: true,
+                                value: curve
+                            });
+                            return curve;
+                        }
+                    });
+                }
+
+                defineCurve('p192', {
+                    type: 'short',
+                    prime: 'p192',
+                    p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',
+                    a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',
+                    b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',
+                    n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',
+                    hash: hash.sha256,
+                    gRed: false,
+                    g: [
+                        '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',
+                        '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811'
+                    ]
+                });
+
+                defineCurve('p224', {
+                    type: 'short',
+                    prime: 'p224',
+                    p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',
+                    a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',
+                    b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',
+                    n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',
+                    hash: hash.sha256,
+                    gRed: false,
+                    g: [
+                        'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',
+                        'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34'
+                    ]
+                });
+
+                defineCurve('p256', {
+                    type: 'short',
+                    prime: null,
+                    p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',
+                    a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',
+                    b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',
+                    n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',
+                    hash: hash.sha256,
+                    gRed: false,
+                    g: [
+                        '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',
+                        '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5'
+                    ]
+                });
+
+                defineCurve('p384', {
+                    type: 'short',
+                    prime: null,
+                    p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+                        'fffffffe ffffffff 00000000 00000000 ffffffff',
+                    a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+                        'fffffffe ffffffff 00000000 00000000 fffffffc',
+                    b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +
+                        '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',
+                    n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +
+                        'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',
+                    hash: hash.sha384,
+                    gRed: false,
+                    g: [
+                        'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +
+                        '5502f25d bf55296c 3a545e38 72760ab7',
+                        '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +
+                        '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f'
+                    ]
+                });
+
+                defineCurve('p521', {
+                    type: 'short',
+                    prime: null,
+                    p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+                        'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+                        'ffffffff ffffffff ffffffff ffffffff ffffffff',
+                    a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+                        'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+                        'ffffffff ffffffff ffffffff ffffffff fffffffc',
+                    b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +
+                        '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +
+                        '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',
+                    n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
+                        'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +
+                        'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',
+                    hash: hash.sha512,
+                    gRed: false,
+                    g: [
+                        '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +
+                        '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +
+                        'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',
+                        '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +
+                        '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +
+                        '3fad0761 353c7086 a272c240 88be9476 9fd16650'
+                    ]
+                });
+
+                defineCurve('curve25519', {
+                    type: 'mont',
+                    prime: 'p25519',
+                    p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
+                    a: '76d06',
+                    b: '1',
+                    n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
+                    hash: hash.sha256,
+                    gRed: false,
+                    g: [
+                        '9'
+                    ]
+                });
+
+                defineCurve('ed25519', {
+                    type: 'edwards',
+                    prime: 'p25519',
+                    p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
+                    a: '-1',
+                    c: '1',
+                    // -121665 * (121666^(-1)) (mod P)
+                    d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',
+                    n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
+                    hash: hash.sha256,
+                    gRed: false,
+                    g: [
+                        '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',
+
+                        // 4/5
+                        '6666666666666666666666666666666666666666666666666666666666666658'
+                    ]
+                });
+
+                var pre;
+                try {
+                    pre = require('./precomputed/secp256k1');
+                } catch (e) {
+                    pre = undefined;
+                }
+
+                defineCurve('secp256k1', {
+                    type: 'short',
+                    prime: 'k256',
+                    p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',
+                    a: '0',
+                    b: '7',
+                    n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',
+                    h: '1',
+                    hash: hash.sha256,
+
+                    // Precomputed endomorphism
+                    beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',
+                    lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
+                    basis: [{
+                            a: '3086d221a7d46bcde86c90e49284eb15',
+                            b: '-e4437ed6010e88286f547fa90abfe4c3'
+                        },
+                        {
+                            a: '114ca50f7a8e2f3f657c1108d9d44cfd8',
+                            b: '3086d221a7d46bcde86c90e49284eb15'
+                        }
+                    ],
+
+                    gRed: false,
+                    g: [
+                        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+                        '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+                        pre
+                    ]
+                });
+
+            }, {
+                "../elliptic": 74,
+                "./precomputed/secp256k1": 87,
+                "hash.js": 93
+            }],
+            81: [function (require, module, exports) {
+                'use strict';
+
+                var BN = require('bn.js');
+                var HmacDRBG = require('hmac-drbg');
+                var elliptic = require('../../elliptic');
+                var utils = elliptic.utils;
+                var assert = utils.assert;
+
+                var KeyPair = require('./key');
+                var Signature = require('./signature');
+
+                function EC(options) {
+                    if (!(this instanceof EC))
+                        return new EC(options);
+
+                    // Shortcut `elliptic.ec(curve-name)`
+                    if (typeof options === 'string') {
+                        assert(elliptic.curves.hasOwnProperty(options), 'Unknown curve ' + options);
+
+                        options = elliptic.curves[options];
+                    }
+
+                    // Shortcut for `elliptic.ec(elliptic.curves.curveName)`
+                    if (options instanceof elliptic.curves.PresetCurve)
+                        options = {
+                            curve: options
+                        };
+
+                    this.curve = options.curve.curve;
+                    this.n = this.curve.n;
+                    this.nh = this.n.ushrn(1);
+                    this.g = this.curve.g;
+
+                    // Point on curve
+                    this.g = options.curve.g;
+                    this.g.precompute(options.curve.n.bitLength() + 1);
+
+                    // Hash for function for DRBG
+                    this.hash = options.hash || options.curve.hash;
+                }
+                module.exports = EC;
+
+                EC.prototype.keyPair = function keyPair(options) {
+                    return new KeyPair(this, options);
+                };
+
+                EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
+                    return KeyPair.fromPrivate(this, priv, enc);
+                };
+
+                EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
+                    return KeyPair.fromPublic(this, pub, enc);
+                };
+
+                EC.prototype.genKeyPair = function genKeyPair(options) {
+                    if (!options)
+                        options = {};
+
+                    // Instantiate Hmac_DRBG
+                    var drbg = new HmacDRBG({
+                        hash: this.hash,
+                        pers: options.pers,
+                        persEnc: options.persEnc || 'utf8',
+                        entropy: options.entropy || elliptic.rand(this.hash.hmacStrength),
+                        entropyEnc: options.entropy && options.entropyEnc || 'utf8',
+                        nonce: this.n.toArray()
+                    });
+
+                    var bytes = this.n.byteLength();
+                    var ns2 = this.n.sub(new BN(2));
+                    do {
+                        var priv = new BN(drbg.generate(bytes));
+                        if (priv.cmp(ns2) > 0)
+                            continue;
+
+                        priv.iaddn(1);
+                        return this.keyFromPrivate(priv);
+                    } while (true);
+                };
+
+                EC.prototype._truncateToN = function truncateToN(msg, truncOnly) {
+                    var delta = msg.byteLength() * 8 - this.n.bitLength();
+                    if (delta > 0)
+                        msg = msg.ushrn(delta);
+                    if (!truncOnly && msg.cmp(this.n) >= 0)
+                        return msg.sub(this.n);
+                    else
+                        return msg;
+                };
+
+                EC.prototype.sign = function sign(msg, key, enc, options) {
+                    if (typeof enc === 'object') {
+                        options = enc;
+                        enc = null;
+                    }
+                    if (!options)
+                        options = {};
+
+                    key = this.keyFromPrivate(key, enc);
+                    msg = this._truncateToN(new BN(msg, 16));
+
+                    // Zero-extend key to provide enough entropy
+                    var bytes = this.n.byteLength();
+                    var bkey = key.getPrivate().toArray('be', bytes);
+
+                    // Zero-extend nonce to have the same byte size as N
+                    var nonce = msg.toArray('be', bytes);
+
+                    // Instantiate Hmac_DRBG
+                    var drbg = new HmacDRBG({
+                        hash: this.hash,
+                        entropy: bkey,
+                        nonce: nonce,
+                        pers: options.pers,
+                        persEnc: options.persEnc || 'utf8'
+                    });
+
+                    // Number of bytes to generate
+                    var ns1 = this.n.sub(new BN(1));
+
+                    for (var iter = 0; true; iter++) {
+                        var k = options.k ?
+                            options.k(iter) :
+                            new BN(drbg.generate(this.n.byteLength()));
+                        k = this._truncateToN(k, true);
+                        if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)
+                            continue;
+
+                        var kp = this.g.mul(k);
+                        if (kp.isInfinity())
+                            continue;
+
+                        var kpX = kp.getX();
+                        var r = kpX.umod(this.n);
+                        if (r.cmpn(0) === 0)
+                            continue;
+
+                        var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
+                        s = s.umod(this.n);
+                        if (s.cmpn(0) === 0)
+                            continue;
+
+                        var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |
+                            (kpX.cmp(r) !== 0 ? 2 : 0);
+
+                        // Use complement of `s`, if it is > `n / 2`
+                        if (options.canonical && s.cmp(this.nh) > 0) {
+                            s = this.n.sub(s);
+                            recoveryParam ^= 1;
+                        }
+
+                        return new Signature({
+                            r: r,
+                            s: s,
+                            recoveryParam: recoveryParam
+                        });
+                    }
+                };
+
+                EC.prototype.verify = function verify(msg, signature, key, enc) {
+                    msg = this._truncateToN(new BN(msg, 16));
+                    key = this.keyFromPublic(key, enc);
+                    signature = new Signature(signature, 'hex');
+
+                    // Perform primitive values validation
+                    var r = signature.r;
+                    var s = signature.s;
+                    if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)
+                        return false;
+                    if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)
+                        return false;
+
+                    // Validate signature
+                    var sinv = s.invm(this.n);
+                    var u1 = sinv.mul(msg).umod(this.n);
+                    var u2 = sinv.mul(r).umod(this.n);
+
+                    if (!this.curve._maxwellTrick) {
+                        var p = this.g.mulAdd(u1, key.getPublic(), u2);
+                        if (p.isInfinity())
+                            return false;
+
+                        return p.getX().umod(this.n).cmp(r) === 0;
+                    }
+
+                    // NOTE: Greg Maxwell's trick, inspired by:
+                    // https://git.io/vad3K
+
+                    var p = this.g.jmulAdd(u1, key.getPublic(), u2);
+                    if (p.isInfinity())
+                        return false;
+
+                    // Compare `p.x` of Jacobian point with `r`,
+                    // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the
+                    // inverse of `p.z^2`
+                    return p.eqXToP(r);
+                };
+
+                EC.prototype.recoverPubKey = function (msg, signature, j, enc) {
+                    assert((3 & j) === j, 'The recovery param is more than two bits');
+                    signature = new Signature(signature, enc);
+
+                    var n = this.n;
+                    var e = new BN(msg);
+                    var r = signature.r;
+                    var s = signature.s;
+
+                    // A set LSB signifies that the y-coordinate is odd
+                    var isYOdd = j & 1;
+                    var isSecondKey = j >> 1;
+                    if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)
+                        throw new Error('Unable to find sencond key candinate');
+
+                    // 1.1. Let x = r + jn.
+                    if (isSecondKey)
+                        r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);
+                    else
+                        r = this.curve.pointFromX(r, isYOdd);
+
+                    var rInv = signature.r.invm(n);
+                    var s1 = n.sub(e).mul(rInv).umod(n);
+                    var s2 = s.mul(rInv).umod(n);
+
+                    // 1.6.1 Compute Q = r^-1 (sR -  eG)
+                    //               Q = r^-1 (sR + -eG)
+                    return this.g.mulAdd(s1, r, s2);
+                };
+
+                EC.prototype.getKeyRecoveryParam = function (e, signature, Q, enc) {
+                    signature = new Signature(signature, enc);
+                    if (signature.recoveryParam !== null)
+                        return signature.recoveryParam;
+
+                    for (var i = 0; i < 4; i++) {
+                        var Qprime;
+                        try {
+                            Qprime = this.recoverPubKey(e, signature, i);
+                        } catch (e) {
+                            continue;
+                        }
+
+                        if (Qprime.eq(Q))
+                            return i;
+                    }
+                    throw new Error('Unable to find valid recovery factor');
+                };
+
+            }, {
+                "../../elliptic": 74,
+                "./key": 82,
+                "./signature": 83,
+                "bn.js": 24,
+                "hmac-drbg": 105
+            }],
+            82: [function (require, module, exports) {
+                'use strict';
+
+                var BN = require('bn.js');
+                var elliptic = require('../../elliptic');
+                var utils = elliptic.utils;
+                var assert = utils.assert;
+
+                function KeyPair(ec, options) {
+                    this.ec = ec;
+                    this.priv = null;
+                    this.pub = null;
+
+                    // KeyPair(ec, { priv: ..., pub: ... })
+                    if (options.priv)
+                        this._importPrivate(options.priv, options.privEnc);
+                    if (options.pub)
+                        this._importPublic(options.pub, options.pubEnc);
+                }
+                module.exports = KeyPair;
+
+                KeyPair.fromPublic = function fromPublic(ec, pub, enc) {
+                    if (pub instanceof KeyPair)
+                        return pub;
+
+                    return new KeyPair(ec, {
+                        pub: pub,
+                        pubEnc: enc
+                    });
+                };
+
+                KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {
+                    if (priv instanceof KeyPair)
+                        return priv;
+
+                    return new KeyPair(ec, {
+                        priv: priv,
+                        privEnc: enc
+                    });
+                };
+
+                KeyPair.prototype.validate = function validate() {
+                    var pub = this.getPublic();
+
+                    if (pub.isInfinity())
+                        return {
+                            result: false,
+                            reason: 'Invalid public key'
+                        };
+                    if (!pub.validate())
+                        return {
+                            result: false,
+                            reason: 'Public key is not a point'
+                        };
+                    if (!pub.mul(this.ec.curve.n).isInfinity())
+                        return {
+                            result: false,
+                            reason: 'Public key * N != O'
+                        };
+
+                    return {
+                        result: true,
+                        reason: null
+                    };
+                };
+
+                KeyPair.prototype.getPublic = function getPublic(compact, enc) {
+                    // compact is optional argument
+                    if (typeof compact === 'string') {
+                        enc = compact;
+                        compact = null;
+                    }
+
+                    if (!this.pub)
+                        this.pub = this.ec.g.mul(this.priv);
+
+                    if (!enc)
+                        return this.pub;
+
+                    return this.pub.encode(enc, compact);
+                };
+
+                KeyPair.prototype.getPrivate = function getPrivate(enc) {
+                    if (enc === 'hex')
+                        return this.priv.toString(16, 2);
+                    else
+                        return this.priv;
+                };
+
+                KeyPair.prototype._importPrivate = function _importPrivate(key, enc) {
+                    this.priv = new BN(key, enc || 16);
+
+                    // Ensure that the priv won't be bigger than n, otherwise we may fail
+                    // in fixed multiplication method
+                    this.priv = this.priv.umod(this.ec.curve.n);
+                };
+
+                KeyPair.prototype._importPublic = function _importPublic(key, enc) {
+                    if (key.x || key.y) {
+                        // Montgomery points only have an `x` coordinate.
+                        // Weierstrass/Edwards points on the other hand have both `x` and
+                        // `y` coordinates.
+                        if (this.ec.curve.type === 'mont') {
+                            assert(key.x, 'Need x coordinate');
+                        } else if (this.ec.curve.type === 'short' ||
+                            this.ec.curve.type === 'edwards') {
+                            assert(key.x && key.y, 'Need both x and y coordinate');
+                        }
+                        this.pub = this.ec.curve.point(key.x, key.y);
                         return;
                     }
+                    this.pub = this.ec.curve.decodePoint(key, enc);
+                };
 
-                    var contactRecordToRemove = clone(contactRecord);
-                    contactRecordToRemove.id =
-                        new Buffer(contactRecord.id, 'base64');
-                    kBucket.remove(contactRecordToRemove);
+                // ECDH
+                KeyPair.prototype.derive = function derive(pub) {
+                    return pub.mul(this.priv).getX();
+                };
+
+                // ECDSA
+                KeyPair.prototype.sign = function sign(msg, enc, options) {
+                    return this.ec.sign(msg, this, enc, options);
+                };
+
+                KeyPair.prototype.verify = function verify(msg, signature) {
+                    return this.ec.verify(msg, signature, this);
+                };
+
+                KeyPair.prototype.inspect = function inspect() {
+                    return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +
+                        ' pub: ' + (this.pub && this.pub.inspect()) + ' >';
+                };
+
+            }, {
+                "../../elliptic": 74,
+                "bn.js": 24
+            }],
+            83: [function (require, module, exports) {
+                'use strict';
+
+                var BN = require('bn.js');
+
+                var elliptic = require('../../elliptic');
+                var utils = elliptic.utils;
+                var assert = utils.assert;
+
+                function Signature(options, enc) {
+                    if (options instanceof Signature)
+                        return options;
+
+                    if (this._importDER(options, enc))
+                        return;
+
+                    assert(options.r && options.s, 'Signature without r or s');
+                    this.r = new BN(options.r, 16);
+                    this.s = new BN(options.s, 16);
+                    if (options.recoveryParam === undefined)
+                        this.recoveryParam = null;
+                    else
+                        this.recoveryParam = options.recoveryParam;
+                }
+                module.exports = Signature;
+
+                function Position() {
+                    this.place = 0;
                 }
 
-                contactRecord.contacted = true;
+                function getLength(buf, p) {
+                    var initial = buf[p.place++];
+                    if (!(initial & 0x80)) {
+                        return initial;
+                    }
+                    var octetLen = initial & 0xf;
+                    var val = 0;
+                    for (var i = 0, off = p.place; i < octetLen; i++, off++) {
+                        val <<= 8;
+                        val |= buf[off];
+                    }
+                    p.place = off;
+                    return val;
+                }
 
-                // console.dir(query);
+                function rmPadding(buf) {
+                    var i = 0;
+                    var len = buf.length - 1;
+                    while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {
+                        i++;
+                    }
+                    if (i === 0) {
+                        return buf;
+                    }
+                    return buf.slice(i);
+                }
 
-                // initiate next request if there are still queries to be made
-                if (query.index < query.nodes.length
-                    && query.ongoingRequests < self.CONCURRENCY_CONSTANT) {
-                    process.nextTick(function () {
-                        self.executeQuery(query, callback);
+                Signature.prototype._importDER = function _importDER(data, enc) {
+                    data = utils.toArray(data, enc);
+                    var p = new Position();
+                    if (data[p.place++] !== 0x30) {
+                        return false;
+                    }
+                    var len = getLength(data, p);
+                    if ((len + p.place) !== data.length) {
+                        return false;
+                    }
+                    if (data[p.place++] !== 0x02) {
+                        return false;
+                    }
+                    var rlen = getLength(data, p);
+                    var r = data.slice(p.place, rlen + p.place);
+                    p.place += rlen;
+                    if (data[p.place++] !== 0x02) {
+                        return false;
+                    }
+                    var slen = getLength(data, p);
+                    if (data.length !== slen + p.place) {
+                        return false;
+                    }
+                    var s = data.slice(p.place, slen + p.place);
+                    if (r[0] === 0 && (r[1] & 0x80)) {
+                        r = r.slice(1);
+                    }
+                    if (s[0] === 0 && (s[1] & 0x80)) {
+                        s = s.slice(1);
+                    }
+
+                    this.r = new BN(r);
+                    this.s = new BN(s);
+                    this.recoveryParam = null;
+
+                    return true;
+                };
+
+                function constructLength(arr, len) {
+                    if (len < 0x80) {
+                        arr.push(len);
+                        return;
+                    }
+                    var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
+                    arr.push(octets | 0x80);
+                    while (--octets) {
+                        arr.push((len >>> (octets << 3)) & 0xff);
+                    }
+                    arr.push(len);
+                }
+
+                Signature.prototype.toDER = function toDER(enc) {
+                    var r = this.r.toArray();
+                    var s = this.s.toArray();
+
+                    // Pad values
+                    if (r[0] & 0x80)
+                        r = [0].concat(r);
+                    // Pad values
+                    if (s[0] & 0x80)
+                        s = [0].concat(s);
+
+                    r = rmPadding(r);
+                    s = rmPadding(s);
+
+                    while (!s[0] && !(s[1] & 0x80)) {
+                        s = s.slice(1);
+                    }
+                    var arr = [0x02];
+                    constructLength(arr, r.length);
+                    arr = arr.concat(r);
+                    arr.push(0x02);
+                    constructLength(arr, s.length);
+                    var backHalf = arr.concat(s);
+                    var res = [0x30];
+                    constructLength(res, backHalf.length);
+                    res = res.concat(backHalf);
+                    return utils.encode(res, enc);
+                };
+
+            }, {
+                "../../elliptic": 74,
+                "bn.js": 24
+            }],
+            84: [function (require, module, exports) {
+                'use strict';
+
+                var hash = require('hash.js');
+                var elliptic = require('../../elliptic');
+                var utils = elliptic.utils;
+                var assert = utils.assert;
+                var parseBytes = utils.parseBytes;
+                var KeyPair = require('./key');
+                var Signature = require('./signature');
+
+                function EDDSA(curve) {
+                    assert(curve === 'ed25519', 'only tested with ed25519 so far');
+
+                    if (!(this instanceof EDDSA))
+                        return new EDDSA(curve);
+
+                    var curve = elliptic.curves[curve].curve;
+                    this.curve = curve;
+                    this.g = curve.g;
+                    this.g.precompute(curve.n.bitLength() + 1);
+
+                    this.pointClass = curve.point().constructor;
+                    this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
+                    this.hash = hash.sha512;
+                }
+
+                module.exports = EDDSA;
+
+                /**
+                * @param {Array|String} message - message bytes
+                * @param {Array|String|KeyPair} secret - secret bytes or a keypair
+                * @returns {Signature} - signature
+                */
+                EDDSA.prototype.sign = function sign(message, secret) {
+                    message = parseBytes(message);
+                    var key = this.keyFromSecret(secret);
+                    var r = this.hashInt(key.messagePrefix(), message);
+                    var R = this.g.mul(r);
+                    var Rencoded = this.encodePoint(R);
+                    var s_ = this.hashInt(Rencoded, key.pubBytes(), message)
+                        .mul(key.priv());
+                    var S = r.add(s_).umod(this.curve.n);
+                    return this.makeSignature({
+                        R: R,
+                        S: S,
+                        Rencoded: Rencoded
+                    });
+                };
+
+                /**
+                * @param {Array} message - message bytes
+                * @param {Array|String|Signature} sig - sig bytes
+                * @param {Array|String|Point|KeyPair} pub - public key
+                * @returns {Boolean} - true if public key matches sig of message
+                */
+                EDDSA.prototype.verify = function verify(message, sig, pub) {
+                    message = parseBytes(message);
+                    sig = this.makeSignature(sig);
+                    var key = this.keyFromPublic(pub);
+                    var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);
+                    var SG = this.g.mul(sig.S());
+                    var RplusAh = sig.R().add(key.pub().mul(h));
+                    return RplusAh.eq(SG);
+                };
+
+                EDDSA.prototype.hashInt = function hashInt() {
+                    var hash = this.hash();
+                    for (var i = 0; i < arguments.length; i++)
+                        hash.update(arguments[i]);
+                    return utils.intFromLE(hash.digest()).umod(this.curve.n);
+                };
+
+                EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
+                    return KeyPair.fromPublic(this, pub);
+                };
+
+                EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
+                    return KeyPair.fromSecret(this, secret);
+                };
+
+                EDDSA.prototype.makeSignature = function makeSignature(sig) {
+                    if (sig instanceof Signature)
+                        return sig;
+                    return new Signature(this, sig);
+                };
+
+                /**
+                * * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2
+                *
+                * EDDSA defines methods for encoding and decoding points and integers. These are
+                * helper convenience methods, that pass along to utility functions implied
+                * parameters.
+                *
+                */
+                EDDSA.prototype.encodePoint = function encodePoint(point) {
+                    var enc = point.getY().toArray('le', this.encodingLength);
+                    enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;
+                    return enc;
+                };
+
+                EDDSA.prototype.decodePoint = function decodePoint(bytes) {
+                    bytes = utils.parseBytes(bytes);
+
+                    var lastIx = bytes.length - 1;
+                    var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);
+                    var xIsOdd = (bytes[lastIx] & 0x80) !== 0;
+
+                    var y = utils.intFromLE(normed);
+                    return this.curve.pointFromY(y, xIsOdd);
+                };
+
+                EDDSA.prototype.encodeInt = function encodeInt(num) {
+                    return num.toArray('le', this.encodingLength);
+                };
+
+                EDDSA.prototype.decodeInt = function decodeInt(bytes) {
+                    return utils.intFromLE(bytes);
+                };
+
+                EDDSA.prototype.isPoint = function isPoint(val) {
+                    return val instanceof this.pointClass;
+                };
+
+            }, {
+                "../../elliptic": 74,
+                "./key": 85,
+                "./signature": 86,
+                "hash.js": 93
+            }],
+            85: [function (require, module, exports) {
+                'use strict';
+
+                var elliptic = require('../../elliptic');
+                var utils = elliptic.utils;
+                var assert = utils.assert;
+                var parseBytes = utils.parseBytes;
+                var cachedProperty = utils.cachedProperty;
+
+                /**
+                * @param {EDDSA} eddsa - instance
+                * @param {Object} params - public/private key parameters
+                *
+                * @param {Array<Byte>} [params.secret] - secret seed bytes
+                * @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)
+                * @param {Array<Byte>} [params.pub] - public key point encoded as bytes
+                *
+                */
+                function KeyPair(eddsa, params) {
+                    this.eddsa = eddsa;
+                    this._secret = parseBytes(params.secret);
+                    if (eddsa.isPoint(params.pub))
+                        this._pub = params.pub;
+                    else
+                        this._pubBytes = parseBytes(params.pub);
+                }
+
+                KeyPair.fromPublic = function fromPublic(eddsa, pub) {
+                    if (pub instanceof KeyPair)
+                        return pub;
+                    return new KeyPair(eddsa, {
+                        pub: pub
+                    });
+                };
+
+                KeyPair.fromSecret = function fromSecret(eddsa, secret) {
+                    if (secret instanceof KeyPair)
+                        return secret;
+                    return new KeyPair(eddsa, {
+                        secret: secret
+                    });
+                };
+
+                KeyPair.prototype.secret = function secret() {
+                    return this._secret;
+                };
+
+                cachedProperty(KeyPair, 'pubBytes', function pubBytes() {
+                    return this.eddsa.encodePoint(this.pub());
+                });
+
+                cachedProperty(KeyPair, 'pub', function pub() {
+                    if (this._pubBytes)
+                        return this.eddsa.decodePoint(this._pubBytes);
+                    return this.eddsa.g.mul(this.priv());
+                });
+
+                cachedProperty(KeyPair, 'privBytes', function privBytes() {
+                    var eddsa = this.eddsa;
+                    var hash = this.hash();
+                    var lastIx = eddsa.encodingLength - 1;
+
+                    var a = hash.slice(0, eddsa.encodingLength);
+                    a[0] &= 248;
+                    a[lastIx] &= 127;
+                    a[lastIx] |= 64;
+
+                    return a;
+                });
+
+                cachedProperty(KeyPair, 'priv', function priv() {
+                    return this.eddsa.decodeInt(this.privBytes());
+                });
+
+                cachedProperty(KeyPair, 'hash', function hash() {
+                    return this.eddsa.hash().update(this.secret()).digest();
+                });
+
+                cachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {
+                    return this.hash().slice(this.eddsa.encodingLength);
+                });
+
+                KeyPair.prototype.sign = function sign(message) {
+                    assert(this._secret, 'KeyPair can only verify');
+                    return this.eddsa.sign(message, this);
+                };
+
+                KeyPair.prototype.verify = function verify(message, sig) {
+                    return this.eddsa.verify(message, sig, this);
+                };
+
+                KeyPair.prototype.getSecret = function getSecret(enc) {
+                    assert(this._secret, 'KeyPair is public only');
+                    return utils.encode(this.secret(), enc);
+                };
+
+                KeyPair.prototype.getPublic = function getPublic(enc) {
+                    return utils.encode(this.pubBytes(), enc);
+                };
+
+                module.exports = KeyPair;
+
+            }, {
+                "../../elliptic": 74
+            }],
+            86: [function (require, module, exports) {
+                'use strict';
+
+                var BN = require('bn.js');
+                var elliptic = require('../../elliptic');
+                var utils = elliptic.utils;
+                var assert = utils.assert;
+                var cachedProperty = utils.cachedProperty;
+                var parseBytes = utils.parseBytes;
+
+                /**
+                * @param {EDDSA} eddsa - eddsa instance
+                * @param {Array<Bytes>|Object} sig -
+                * @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes
+                * @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes
+                * @param {Array<Bytes>} [sig.Rencoded] - R point encoded
+                * @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded
+                */
+                function Signature(eddsa, sig) {
+                    this.eddsa = eddsa;
+
+                    if (typeof sig !== 'object')
+                        sig = parseBytes(sig);
+
+                    if (Array.isArray(sig)) {
+                        sig = {
+                            R: sig.slice(0, eddsa.encodingLength),
+                            S: sig.slice(eddsa.encodingLength)
+                        };
+                    }
+
+                    assert(sig.R && sig.S, 'Signature without R or S');
+
+                    if (eddsa.isPoint(sig.R))
+                        this._R = sig.R;
+                    if (sig.S instanceof BN)
+                        this._S = sig.S;
+
+                    this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
+                    this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
+                }
+
+                cachedProperty(Signature, 'S', function S() {
+                    return this.eddsa.decodeInt(this.Sencoded());
+                });
+
+                cachedProperty(Signature, 'R', function R() {
+                    return this.eddsa.decodePoint(this.Rencoded());
+                });
+
+                cachedProperty(Signature, 'Rencoded', function Rencoded() {
+                    return this.eddsa.encodePoint(this.R());
+                });
+
+                cachedProperty(Signature, 'Sencoded', function Sencoded() {
+                    return this.eddsa.encodeInt(this.S());
+                });
+
+                Signature.prototype.toBytes = function toBytes() {
+                    return this.Rencoded().concat(this.Sencoded());
+                };
+
+                Signature.prototype.toHex = function toHex() {
+                    return utils.encode(this.toBytes(), 'hex').toUpperCase();
+                };
+
+                module.exports = Signature;
+
+            }, {
+                "../../elliptic": 74,
+                "bn.js": 24
+            }],
+            87: [function (require, module, exports) {
+                module.exports = {
+                    doubles: {
+                        step: 4,
+                        points: [
+                            [
+                                'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a',
+                                'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821'
+                            ],
+                            [
+                                '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508',
+                                '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf'
+                            ],
+                            [
+                                '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739',
+                                'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695'
+                            ],
+                            [
+                                '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640',
+                                '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9'
+                            ],
+                            [
+                                '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c',
+                                '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36'
+                            ],
+                            [
+                                '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda',
+                                '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f'
+                            ],
+                            [
+                                'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa',
+                                '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999'
+                            ],
+                            [
+                                '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0',
+                                'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09'
+                            ],
+                            [
+                                'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d',
+                                '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d'
+                            ],
+                            [
+                                'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d',
+                                'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088'
+                            ],
+                            [
+                                'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1',
+                                '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d'
+                            ],
+                            [
+                                '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0',
+                                '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8'
+                            ],
+                            [
+                                '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047',
+                                '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a'
+                            ],
+                            [
+                                '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862',
+                                '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453'
+                            ],
+                            [
+                                '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7',
+                                '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160'
+                            ],
+                            [
+                                '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd',
+                                '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0'
+                            ],
+                            [
+                                '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83',
+                                '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6'
+                            ],
+                            [
+                                '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a',
+                                '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589'
+                            ],
+                            [
+                                '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8',
+                                'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17'
+                            ],
+                            [
+                                'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d',
+                                '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda'
+                            ],
+                            [
+                                'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725',
+                                '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd'
+                            ],
+                            [
+                                '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754',
+                                '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2'
+                            ],
+                            [
+                                '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c',
+                                '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6'
+                            ],
+                            [
+                                'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6',
+                                '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f'
+                            ],
+                            [
+                                '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39',
+                                'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01'
+                            ],
+                            [
+                                'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891',
+                                '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3'
+                            ],
+                            [
+                                'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b',
+                                'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f'
+                            ],
+                            [
+                                'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03',
+                                '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7'
+                            ],
+                            [
+                                'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d',
+                                'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78'
+                            ],
+                            [
+                                'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070',
+                                '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1'
+                            ],
+                            [
+                                '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4',
+                                'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150'
+                            ],
+                            [
+                                '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da',
+                                '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82'
+                            ],
+                            [
+                                'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11',
+                                '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc'
+                            ],
+                            [
+                                '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e',
+                                'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b'
+                            ],
+                            [
+                                'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41',
+                                '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51'
+                            ],
+                            [
+                                'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef',
+                                '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45'
+                            ],
+                            [
+                                'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8',
+                                'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120'
+                            ],
+                            [
+                                '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d',
+                                '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84'
+                            ],
+                            [
+                                '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96',
+                                '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d'
+                            ],
+                            [
+                                '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd',
+                                'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d'
+                            ],
+                            [
+                                '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5',
+                                '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8'
+                            ],
+                            [
+                                'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266',
+                                '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8'
+                            ],
+                            [
+                                '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71',
+                                '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac'
+                            ],
+                            [
+                                '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac',
+                                'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f'
+                            ],
+                            [
+                                '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751',
+                                '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962'
+                            ],
+                            [
+                                'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e',
+                                '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907'
+                            ],
+                            [
+                                '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241',
+                                'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec'
+                            ],
+                            [
+                                'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3',
+                                'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d'
+                            ],
+                            [
+                                'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f',
+                                '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414'
+                            ],
+                            [
+                                '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19',
+                                'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd'
+                            ],
+                            [
+                                '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be',
+                                'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0'
+                            ],
+                            [
+                                'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9',
+                                '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811'
+                            ],
+                            [
+                                'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2',
+                                '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1'
+                            ],
+                            [
+                                'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13',
+                                '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c'
+                            ],
+                            [
+                                '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c',
+                                'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73'
+                            ],
+                            [
+                                '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba',
+                                '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd'
+                            ],
+                            [
+                                'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151',
+                                'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405'
+                            ],
+                            [
+                                '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073',
+                                'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589'
+                            ],
+                            [
+                                '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458',
+                                '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e'
+                            ],
+                            [
+                                '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b',
+                                '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27'
+                            ],
+                            [
+                                'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366',
+                                'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1'
+                            ],
+                            [
+                                '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa',
+                                '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482'
+                            ],
+                            [
+                                '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0',
+                                '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945'
+                            ],
+                            [
+                                'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787',
+                                '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573'
+                            ],
+                            [
+                                'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e',
+                                'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82'
+                            ]
+                        ]
+                    },
+                    naf: {
+                        wnd: 7,
+                        points: [
+                            [
+                                'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',
+                                '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672'
+                            ],
+                            [
+                                '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4',
+                                'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6'
+                            ],
+                            [
+                                '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc',
+                                '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da'
+                            ],
+                            [
+                                'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe',
+                                'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37'
+                            ],
+                            [
+                                '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb',
+                                'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b'
+                            ],
+                            [
+                                'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8',
+                                'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81'
+                            ],
+                            [
+                                'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e',
+                                '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58'
+                            ],
+                            [
+                                'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34',
+                                '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77'
+                            ],
+                            [
+                                '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c',
+                                '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a'
+                            ],
+                            [
+                                '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5',
+                                '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c'
+                            ],
+                            [
+                                '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f',
+                                '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67'
+                            ],
+                            [
+                                '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714',
+                                '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402'
+                            ],
+                            [
+                                'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729',
+                                'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55'
+                            ],
+                            [
+                                'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db',
+                                '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482'
+                            ],
+                            [
+                                '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4',
+                                'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82'
+                            ],
+                            [
+                                '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5',
+                                'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396'
+                            ],
+                            [
+                                '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479',
+                                '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49'
+                            ],
+                            [
+                                '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d',
+                                '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf'
+                            ],
+                            [
+                                '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f',
+                                '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a'
+                            ],
+                            [
+                                '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb',
+                                'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7'
+                            ],
+                            [
+                                'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9',
+                                'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933'
+                            ],
+                            [
+                                '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963',
+                                '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a'
+                            ],
+                            [
+                                '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74',
+                                '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6'
+                            ],
+                            [
+                                'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530',
+                                'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37'
+                            ],
+                            [
+                                '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b',
+                                '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e'
+                            ],
+                            [
+                                'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247',
+                                'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6'
+                            ],
+                            [
+                                'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1',
+                                'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476'
+                            ],
+                            [
+                                '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120',
+                                '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40'
+                            ],
+                            [
+                                '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435',
+                                '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61'
+                            ],
+                            [
+                                '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18',
+                                '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683'
+                            ],
+                            [
+                                'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8',
+                                '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5'
+                            ],
+                            [
+                                '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb',
+                                '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b'
+                            ],
+                            [
+                                'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f',
+                                '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417'
+                            ],
+                            [
+                                '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143',
+                                'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868'
+                            ],
+                            [
+                                '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba',
+                                'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a'
+                            ],
+                            [
+                                'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45',
+                                'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6'
+                            ],
+                            [
+                                '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a',
+                                '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996'
+                            ],
+                            [
+                                '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e',
+                                'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e'
+                            ],
+                            [
+                                'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8',
+                                'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d'
+                            ],
+                            [
+                                '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c',
+                                '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2'
+                            ],
+                            [
+                                '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519',
+                                'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e'
+                            ],
+                            [
+                                '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab',
+                                '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437'
+                            ],
+                            [
+                                '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca',
+                                'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311'
+                            ],
+                            [
+                                'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf',
+                                '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4'
+                            ],
+                            [
+                                '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610',
+                                '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575'
+                            ],
+                            [
+                                '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4',
+                                'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d'
+                            ],
+                            [
+                                '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c',
+                                'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d'
+                            ],
+                            [
+                                'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940',
+                                'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629'
+                            ],
+                            [
+                                'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980',
+                                'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06'
+                            ],
+                            [
+                                '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3',
+                                '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374'
+                            ],
+                            [
+                                '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf',
+                                '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee'
+                            ],
+                            [
+                                'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63',
+                                '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1'
+                            ],
+                            [
+                                'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448',
+                                'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b'
+                            ],
+                            [
+                                '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf',
+                                '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661'
+                            ],
+                            [
+                                '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5',
+                                '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6'
+                            ],
+                            [
+                                'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6',
+                                '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e'
+                            ],
+                            [
+                                '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5',
+                                '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d'
+                            ],
+                            [
+                                'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99',
+                                'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc'
+                            ],
+                            [
+                                '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51',
+                                'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4'
+                            ],
+                            [
+                                '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5',
+                                '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c'
+                            ],
+                            [
+                                'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5',
+                                '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b'
+                            ],
+                            [
+                                'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997',
+                                '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913'
+                            ],
+                            [
+                                '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881',
+                                '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154'
+                            ],
+                            [
+                                '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5',
+                                '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865'
+                            ],
+                            [
+                                '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66',
+                                'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc'
+                            ],
+                            [
+                                '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726',
+                                'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224'
+                            ],
+                            [
+                                '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede',
+                                '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e'
+                            ],
+                            [
+                                '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94',
+                                '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6'
+                            ],
+                            [
+                                '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31',
+                                '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511'
+                            ],
+                            [
+                                '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51',
+                                'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b'
+                            ],
+                            [
+                                'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252',
+                                'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2'
+                            ],
+                            [
+                                '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5',
+                                'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c'
+                            ],
+                            [
+                                'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b',
+                                '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3'
+                            ],
+                            [
+                                'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4',
+                                '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d'
+                            ],
+                            [
+                                'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f',
+                                '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700'
+                            ],
+                            [
+                                'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889',
+                                '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4'
+                            ],
+                            [
+                                '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246',
+                                'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196'
+                            ],
+                            [
+                                '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984',
+                                '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4'
+                            ],
+                            [
+                                '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a',
+                                'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257'
+                            ],
+                            [
+                                'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030',
+                                'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13'
+                            ],
+                            [
+                                'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197',
+                                '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096'
+                            ],
+                            [
+                                'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593',
+                                'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38'
+                            ],
+                            [
+                                'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef',
+                                '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f'
+                            ],
+                            [
+                                '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38',
+                                '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448'
+                            ],
+                            [
+                                'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a',
+                                '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a'
+                            ],
+                            [
+                                'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111',
+                                '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4'
+                            ],
+                            [
+                                '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502',
+                                '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437'
+                            ],
+                            [
+                                '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea',
+                                'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7'
+                            ],
+                            [
+                                'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26',
+                                '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d'
+                            ],
+                            [
+                                'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986',
+                                '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a'
+                            ],
+                            [
+                                'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e',
+                                '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54'
+                            ],
+                            [
+                                '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4',
+                                '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77'
+                            ],
+                            [
+                                'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda',
+                                'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517'
+                            ],
+                            [
+                                '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859',
+                                'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10'
+                            ],
+                            [
+                                'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f',
+                                'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125'
+                            ],
+                            [
+                                'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c',
+                                '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e'
+                            ],
+                            [
+                                '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942',
+                                'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1'
+                            ],
+                            [
+                                'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a',
+                                '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2'
+                            ],
+                            [
+                                'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80',
+                                '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423'
+                            ],
+                            [
+                                'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d',
+                                '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8'
+                            ],
+                            [
+                                '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1',
+                                'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758'
+                            ],
+                            [
+                                '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63',
+                                'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375'
+                            ],
+                            [
+                                'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352',
+                                '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d'
+                            ],
+                            [
+                                '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193',
+                                'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec'
+                            ],
+                            [
+                                '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00',
+                                '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0'
+                            ],
+                            [
+                                '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58',
+                                'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c'
+                            ],
+                            [
+                                'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7',
+                                'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4'
+                            ],
+                            [
+                                '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8',
+                                'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f'
+                            ],
+                            [
+                                '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e',
+                                '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649'
+                            ],
+                            [
+                                '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d',
+                                'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826'
+                            ],
+                            [
+                                '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b',
+                                '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5'
+                            ],
+                            [
+                                'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f',
+                                'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87'
+                            ],
+                            [
+                                '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6',
+                                '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b'
+                            ],
+                            [
+                                'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297',
+                                '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc'
+                            ],
+                            [
+                                '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a',
+                                '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c'
+                            ],
+                            [
+                                'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c',
+                                'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f'
+                            ],
+                            [
+                                'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52',
+                                '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a'
+                            ],
+                            [
+                                'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb',
+                                'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46'
+                            ],
+                            [
+                                '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065',
+                                'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f'
+                            ],
+                            [
+                                '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917',
+                                '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03'
+                            ],
+                            [
+                                '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9',
+                                'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08'
+                            ],
+                            [
+                                '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3',
+                                '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8'
+                            ],
+                            [
+                                '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57',
+                                '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373'
+                            ],
+                            [
+                                '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66',
+                                'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3'
+                            ],
+                            [
+                                '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8',
+                                '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8'
+                            ],
+                            [
+                                '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721',
+                                '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1'
+                            ],
+                            [
+                                '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180',
+                                '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9'
+                            ]
+                        ]
+                    }
+                };
+
+            }, {}],
+            88: [function (require, module, exports) {
+                'use strict';
+
+                var utils = exports;
+                var BN = require('bn.js');
+                var minAssert = require('minimalistic-assert');
+                var minUtils = require('minimalistic-crypto-utils');
+
+                utils.assert = minAssert;
+                utils.toArray = minUtils.toArray;
+                utils.zero2 = minUtils.zero2;
+                utils.toHex = minUtils.toHex;
+                utils.encode = minUtils.encode;
+
+                // Represent num in a w-NAF form
+                function getNAF(num, w) {
+                    var naf = [];
+                    var ws = 1 << (w + 1);
+                    var k = num.clone();
+                    while (k.cmpn(1) >= 0) {
+                        var z;
+                        if (k.isOdd()) {
+                            var mod = k.andln(ws - 1);
+                            if (mod > (ws >> 1) - 1)
+                                z = (ws >> 1) - mod;
+                            else
+                                z = mod;
+                            k.isubn(z);
+                        } else {
+                            z = 0;
+                        }
+                        naf.push(z);
+
+                        // Optimization, shift by word if possible
+                        var shift = (k.cmpn(0) !== 0 && k.andln(ws - 1) === 0) ? (w + 1) : 1;
+                        for (var i = 1; i < shift; i++)
+                            naf.push(0);
+                        k.iushrn(shift);
+                    }
+
+                    return naf;
+                }
+                utils.getNAF = getNAF;
+
+                // Represent k1, k2 in a Joint Sparse Form
+                function getJSF(k1, k2) {
+                    var jsf = [
+                        [],
+                        []
+                    ];
+
+                    k1 = k1.clone();
+                    k2 = k2.clone();
+                    var d1 = 0;
+                    var d2 = 0;
+                    while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
+
+                        // First phase
+                        var m14 = (k1.andln(3) + d1) & 3;
+                        var m24 = (k2.andln(3) + d2) & 3;
+                        if (m14 === 3)
+                            m14 = -1;
+                        if (m24 === 3)
+                            m24 = -1;
+                        var u1;
+                        if ((m14 & 1) === 0) {
+                            u1 = 0;
+                        } else {
+                            var m8 = (k1.andln(7) + d1) & 7;
+                            if ((m8 === 3 || m8 === 5) && m24 === 2)
+                                u1 = -m14;
+                            else
+                                u1 = m14;
+                        }
+                        jsf[0].push(u1);
+
+                        var u2;
+                        if ((m24 & 1) === 0) {
+                            u2 = 0;
+                        } else {
+                            var m8 = (k2.andln(7) + d2) & 7;
+                            if ((m8 === 3 || m8 === 5) && m14 === 2)
+                                u2 = -m24;
+                            else
+                                u2 = m24;
+                        }
+                        jsf[1].push(u2);
+
+                        // Second phase
+                        if (2 * d1 === u1 + 1)
+                            d1 = 1 - d1;
+                        if (2 * d2 === u2 + 1)
+                            d2 = 1 - d2;
+                        k1.iushrn(1);
+                        k2.iushrn(1);
+                    }
+
+                    return jsf;
+                }
+                utils.getJSF = getJSF;
+
+                function cachedProperty(obj, name, computer) {
+                    var key = '_' + name;
+                    obj.prototype[name] = function cachedProperty() {
+                        return this[key] !== undefined ? this[key] :
+                            this[key] = computer.call(this);
+                    };
+                }
+                utils.cachedProperty = cachedProperty;
+
+                function parseBytes(bytes) {
+                    return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :
+                        bytes;
+                }
+                utils.parseBytes = parseBytes;
+
+                function intFromLE(bytes) {
+                    return new BN(bytes, 'hex', 'le');
+                }
+                utils.intFromLE = intFromLE;
+
+
+            }, {
+                "bn.js": 24,
+                "minimalistic-assert": 112,
+                "minimalistic-crypto-utils": 113
+            }],
+            89: [function (require, module, exports) {
+                module.exports = {
+                    "_from": "elliptic@^6.0.0",
+                    "_id": "elliptic@6.4.0",
+                    "_inBundle": false,
+                    "_integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=",
+                    "_location": "/browserify/elliptic",
+                    "_phantomChildren": {},
+                    "_requested": {
+                        "type": "range",
+                        "registry": true,
+                        "raw": "elliptic@^6.0.0",
+                        "name": "elliptic",
+                        "escapedName": "elliptic",
+                        "rawSpec": "^6.0.0",
+                        "saveSpec": null,
+                        "fetchSpec": "^6.0.0"
+                    },
+                    "_requiredBy": [
+                        "/browserify/browserify-sign",
+                        "/browserify/create-ecdh"
+                    ],
+                    "_resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz",
+                    "_shasum": "cac9af8762c85836187003c8dfe193e5e2eae5df",
+                    "_spec": "elliptic@^6.0.0",
+                    "_where": "/usr/local/lib/node_modules/browserify/node_modules/browserify-sign",
+                    "author": {
+                        "name": "Fedor Indutny",
+                        "email": "fedor@indutny.com"
+                    },
+                    "bugs": {
+                        "url": "https://github.com/indutny/elliptic/issues"
+                    },
+                    "bundleDependencies": false,
+                    "dependencies": {
+                        "bn.js": "^4.4.0",
+                        "brorand": "^1.0.1",
+                        "hash.js": "^1.0.0",
+                        "hmac-drbg": "^1.0.0",
+                        "inherits": "^2.0.1",
+                        "minimalistic-assert": "^1.0.0",
+                        "minimalistic-crypto-utils": "^1.0.0"
+                    },
+                    "deprecated": false,
+                    "description": "EC cryptography",
+                    "devDependencies": {
+                        "brfs": "^1.4.3",
+                        "coveralls": "^2.11.3",
+                        "grunt": "^0.4.5",
+                        "grunt-browserify": "^5.0.0",
+                        "grunt-cli": "^1.2.0",
+                        "grunt-contrib-connect": "^1.0.0",
+                        "grunt-contrib-copy": "^1.0.0",
+                        "grunt-contrib-uglify": "^1.0.1",
+                        "grunt-mocha-istanbul": "^3.0.1",
+                        "grunt-saucelabs": "^8.6.2",
+                        "istanbul": "^0.4.2",
+                        "jscs": "^2.9.0",
+                        "jshint": "^2.6.0",
+                        "mocha": "^2.1.0"
+                    },
+                    "files": [
+                        "lib"
+                    ],
+                    "homepage": "https://github.com/indutny/elliptic",
+                    "keywords": [
+                        "EC",
+                        "Elliptic",
+                        "curve",
+                        "Cryptography"
+                    ],
+                    "license": "MIT",
+                    "main": "lib/elliptic.js",
+                    "name": "elliptic",
+                    "repository": {
+                        "type": "git",
+                        "url": "git+ssh://git@github.com/indutny/elliptic.git"
+                    },
+                    "scripts": {
+                        "jscs": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js",
+                        "jshint": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js",
+                        "lint": "npm run jscs && npm run jshint",
+                        "test": "npm run lint && npm run unit",
+                        "unit": "istanbul test _mocha --reporter=spec test/index.js",
+                        "version": "grunt dist && git add dist/"
+                    },
+                    "version": "6.4.0"
+                }
+
+            }, {}],
+            90: [function (require, module, exports) {
+                // Copyright Joyent, Inc. and other Node contributors.
+                //
+                // Permission is hereby granted, free of charge, to any person obtaining a
+                // copy of this software and associated documentation files (the
+                // "Software"), to deal in the Software without restriction, including
+                // without limitation the rights to use, copy, modify, merge, publish,
+                // distribute, sublicense, and/or sell copies of the Software, and to permit
+                // persons to whom the Software is furnished to do so, subject to the
+                // following conditions:
+                //
+                // The above copyright notice and this permission notice shall be included
+                // in all copies or substantial portions of the Software.
+                //
+                // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                var objectCreate = Object.create || objectCreatePolyfill
+                var objectKeys = Object.keys || objectKeysPolyfill
+                var bind = Function.prototype.bind || functionBindPolyfill
+
+                function EventEmitter() {
+                    if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
+                        this._events = objectCreate(null);
+                        this._eventsCount = 0;
+                    }
+
+                    this._maxListeners = this._maxListeners || undefined;
+                }
+                module.exports = EventEmitter;
+
+                // Backwards-compat with node 0.10.x
+                EventEmitter.EventEmitter = EventEmitter;
+
+                EventEmitter.prototype._events = undefined;
+                EventEmitter.prototype._maxListeners = undefined;
+
+                // By default EventEmitters will print a warning if more than 10 listeners are
+                // added to it. This is a useful default which helps finding memory leaks.
+                var defaultMaxListeners = 10;
+
+                var hasDefineProperty;
+                try {
+                    var o = {};
+                    if (Object.defineProperty) Object.defineProperty(o, 'x', {
+                        value: 0
+                    });
+                    hasDefineProperty = o.x === 0;
+                } catch (err) {
+                    hasDefineProperty = false
+                }
+                if (hasDefineProperty) {
+                    Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+                        enumerable: true,
+                        get: function () {
+                            return defaultMaxListeners;
+                        },
+                        set: function (arg) {
+                            // check whether the input is a positive number (whose value is zero or
+                            // greater and not a NaN).
+                            if (typeof arg !== 'number' || arg < 0 || arg !== arg)
+                                throw new TypeError(
+                                    '"defaultMaxListeners" must be a positive number');
+                            defaultMaxListeners = arg;
+                        }
                     });
                 } else {
-                    self.queryCompletionCheck(query, callback);
+                    EventEmitter.defaultMaxListeners = defaultMaxListeners;
                 }
-                return; // handled error
-            }
 
-            // we have a response, it could be an Object or Array
+                // Obviously not all Emitters should be limited to 10. This function allows
+                // that to be increased. Set to zero for unlimited.
+                EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+                    if (typeof n !== 'number' || n < 0 || isNaN(n))
+                        throw new TypeError('"n" argument must be a positive number');
+                    this._maxListeners = n;
+                    return this;
+                };
 
-            if (self.tracing) {
-                self.trace('response from ' + util.inspect(contact) +
-                    ' looking for ' + nodeId + ': ' + util.inspect(response));
-            }
-            if (Array.isArray(response)) {
-                // add the closest contacts to new nodes
-                query.newNodes = query.newNodes.concat(response);
-
-                // TODO: same code inside error handler
-                // initiate next request if there are still queries to be made
-                if (query.index < query.nodes.length
-                    && query.ongoingRequests < self.CONCURRENCY_CONSTANT) {
-                    process.nextTick(function () {
-                        self.executeQuery(query, callback);
-                    });
-                } else {
-                    self.queryCompletionCheck(query, callback);
+                function $getMaxListeners(that) {
+                    if (that._maxListeners === undefined)
+                        return EventEmitter.defaultMaxListeners;
+                    return that._maxListeners;
                 }
-                return;
-            }
 
-            // we have a response Object, found the contact!
-            // add the new contact to the closestKBucket
-            var finalClosestKBuckets = self.getClosestKBuckets(response.id);
-            if (finalClosestKBuckets.length > 0) {
-                var finalClosestKBucket =
-                    self.kBuckets[finalClosestKBuckets[0].id].kBucket;
-                var contact = clone(response);
-                contact.id = new Buffer(contact.id, "base64");
-                finalClosestKBucket.add(contact);
-            }
+                EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+                    return $getMaxListeners(this);
+                };
 
-            // return the response and stop querying
-            var latency = self.timerEndInMilliseconds('find.ms', nodeId);
-            var roundLatency = self.timerEndInMilliseconds('find.round.ms', nodeId);
-            callback(null, response);
-            query.done = true;
-            self.transport.removeListener('node', query.listener);
-            self.emit('stats.timers.find.ms', latency);
-            self.emit('stats.timers.find.round.ms', roundLatency);
-            return;
-        };
-        self.transport.on('node', query.listener);
-    }
-
-    for (query.index = query.index || 0;
-        query.index < query.nodes.length
-            && query.ongoingRequests < self.CONCURRENCY_CONSTANT;
-        query.index++) {
-
-        query.ongoingRequests++;
-        self.timerStart('find.request.ms', query.nodes[query.index].id + query.nodeId);
-        self.transport.findNode(query.nodes[query.index], query.nodeId, query.sender);
-    }
-
-    // console.log("INSIDE EXECUTE QUERY");
-    // console.dir(query);
-    self.queryCompletionCheck(query, callback);
-};
-
-/*
-  * `nodeId`: _String (base64)_ The node id to find, base64 encoded.
-  * `callback`: _Function_ The callback to call with the result of searching for
-          `nodeId`.
-  * `announce`: _Object_ _(Default: undefined)_ _**CAUTION: reserved for
-          internal use**_ Contact object, if specified, it indicates an
-          announcement to the network so we ask the network instead of
-          satisfying request locally and the sender is the `announce` contact
-          object.
-*/
-Discover.prototype.find = function find (nodeId, callback, announce) {
-    var self = this;
-    self.timerStart('find.ms', nodeId);
-
-    var traceHeader;
-
-    if (self.tracing) {
-        traceHeader = "find(" + nodeId + "): ";
-    }
-
-    // see if we have a local match, and return it if not announcing
-    if (!announce && self.kBuckets[nodeId]) {
-        var latency = self.timerEndInMilliseconds('find.ms', nodeId);
-        callback(null, self.kBuckets[nodeId].contact);
-        self.emit('stats.timers.find.ms', latency);
-        return;
-    }
-
-    // see if we have a cache match, and return it if not announcing
-    var cached = self.lruCache.get(nodeId);
-    if (!announce && cached) {
-        var latency = self.timerEndInMilliseconds('find.ms', nodeId);
-        callback(null, cached);
-        self.emit('stats.timers.find.ms', latency);
-        return;
-    }
-
-    // if we have no kBuckets, that means we haven't registered any nodes yet
-    // the only nodes we are aware of are the seed nodes
-    if (Object.keys(self.kBuckets).length == 0) {
-        if (self.tracing)
-            self.trace(traceHeader + 'no kBuckets, delegating to findViaSeeds()');
-        return self.findViaSeeds(nodeId, callback, announce);
-    }
-
-    var closestKBuckets = self.getClosestKBuckets(nodeId);
-
-    if (self.tracing) {
-        self.trace(traceHeader + 'have ' + closestKBuckets.length + ' kBuckets');
-        self.trace(traceHeader + 'kBuckets: ' + util.inspect(closestKBuckets, false, null));
-    }
-
-    var closestContacts = self.getClosestContacts(nodeId, closestKBuckets);
-
-    // if none of our local kBuckets have any contacts (should only happen
-    // when bootstrapping), talk to the seeds
-    if (closestContacts.length == 0) {
-        if (self.tracing)
-            self.trace(traceHeader + 'no contacts in kBuckets, delegating to findViaSeeds()');
-        return self.findViaSeeds(nodeId, callback, announce);
-    }
-
-    if (self.tracing)
-        self.trace(traceHeader + 'have ' + closestContacts.length + ' closest contacts');
-
-    // check if the closest contact is actually the node we are looking for
-    if (closestContacts[0].id.toString("base64") == nodeId) {
-        var contact = clone(closestContacts[0]);
-        contact.id = contact.id.toString("base64");
-        // hide internal implementation details
-        delete contact.distance;
-        var latency = self.timerEndInMilliseconds('find.ms', nodeId);
-        callback(null, contact);
-        self.emit('stats.timers.find.ms', latency);
-        return;
-    }
-
-    // closestContacts will contain contacts with id as a Buffer, we clone
-    // the contacts so that we can have id be a base64 encoded String
-    var closestNodes = [];
-    var nodesMap = {};
-    closestContacts.forEach(function (contact) {
-        var clonedContact = clone(contact);
-        clonedContact.id = clonedContact.id.toString("base64");
-        clonedContact.kBucket = closestKBuckets[0]; // for reference later
-        closestNodes.push(clonedContact);
-        nodesMap[clonedContact.id] = clonedContact;
-    });
-
-    var query = {
-        nodeId: nodeId,
-        nodes: closestNodes,
-        nodesMap: nodesMap,
-        sender: self.kBuckets[closestKBuckets[0].id].contact
-    };
-    self.executeQuery(query, callback);
-};
-
-/*
-  * `nodeId`: _String (base64)_ Base64 encoded node id to find.
-  * `callback`: _Function_ The callback to call with the result of searching for
-          `nodeId`.
-  * `announce`: _Object_ _(Default: undefined)_ Contact object, if specified, it
-          indicates an announcement and the sender is the `announce` contact
-          object.
-*/
-Discover.prototype.findViaSeeds = function findViaSeeds (nodeId, callback, announce) {
-    var self = this;
-    var traceHeader = "findViaSeeds(" + nodeId + "): ";
-
-    // if we have no seeds, that means we don't know of any other nodes to query
-    if (!self.seeds || self.seeds.length == 0) {
-        if (self.tracing) {
-            self.trace(traceHeader + 'No known seeds to query');
-        }
-        var latency = self.timerEndInMilliseconds('find.ms', nodeId);
-        callback(new Error("No known seeds to query"));
-        self.emit('stats.timers.find.ms', latency);
-        return;
-    }
-
-    var closestNodes = [];
-    var nodesMap = {};
-    var nodeIdBuffer = new Buffer(nodeId, "base64");
-    self.seeds.forEach(function (seed) {
-        var seedIdBuffer = new Buffer(seed.id, "base64");
-        var clonedSeed = clone(seed);
-        clonedSeed.distance = KBucket.distance(nodeIdBuffer, seedIdBuffer);
-        closestNodes.push(clonedSeed);
-        nodesMap[clonedSeed.id] = clonedSeed;
-    });
-
-    closestNodes = closestNodes.sort(function (a, b) {
-        return a.distance - b.distance;
-    });
-
-    // distances are now sorted, closest being first
-    // TODO: probably refactor Query object to be it's own thing
-    var query = {
-        nodeId: nodeId,
-        nodes: closestNodes,
-        nodesMap: nodesMap,
-        sender: announce
-    };
-    self.executeQuery(query, callback);
-};
-
-/*
-  * `nodeId`: _String (base64)_ Base64 encoded node id to find closest contacts
-          to.
-  * `closestKBuckets`: _Array_ Sorted array of `KBucket`s from closest to
-          furthest from `nodeId`.
-  * Return: _Array_ List of closest contacts.
-*/
-Discover.prototype.getClosestContacts = function getClosestContacts (nodeId, closestKBuckets) {
-    var self = this;
-
-    // we pick the closest kBucket to chose nodes from as it will have the
-    // most information about nodes closest to nodeId, if closest kBucket has
-    // no nodes, we pick the next one, until we find a kBucket with nodes in it
-    // or reach the end
-    var closestContacts = [];
-    var closestKBucketsIndex = 0;
-    // TODO: it is possible for closestKBucket.closest({...}, 3) to return
-    //       less than 3 contacts, in that case a list of less than 3 will
-    //       be returned, changing while condition to use
-    //       `closestContacts.length < 3` may be a bette heuristic choice
-    while (closestContacts.length == 0
-            && closestKBucketsIndex < closestKBuckets.length) {
-        var closestKBucketId = closestKBuckets[closestKBucketsIndex].id;
-        var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
-        // get three closest nodes
-        closestContacts = closestKBucket.closest(
-            {id: new Buffer(nodeId, "base64")}, 3);
-        closestKBucketsIndex++;
-    }
-
-    return closestContacts;
-};
-
-/*
-  * `nodeId`: _String (base64)_ Base64 encoded node id to find closest contacts
-          to.
-  * Return: _Array_ List of closest `KBucket`s.
-*/
-Discover.prototype.getClosestKBuckets = function getClosestKBuckets (nodeId) {
-    var self = this;
-
-    // TODO: change self.kBuckets data structure so that this operation is
-    //       O(log n) instead of O(n), although, in proritizing this task
-    //       remember the use-case of having more than one kBucket in self.kBuckets
-    //       means that we are doing discover.register(contact) quite many times.
-    //       It seems that for *most* use-cases, only one contact will ever be
-    //       `discover.register`'ed (this registers identity of the local node)
-    var closestKBuckets = [];
-    var nodeIdBuffer = new Buffer(nodeId, "base64");
-    Object.keys(self.kBuckets).forEach(function (kBucketKey) {
-        var kBucket = self.kBuckets[kBucketKey];
-        var kBucketIdBuffer = new Buffer(kBucket.id, "base64");
-        closestKBuckets.push({
-            id: kBucket.id,
-            distance: KBucket.distance(nodeIdBuffer, kBucketIdBuffer)
-        });
-    });
-
-    closestKBuckets = closestKBuckets.sort(function (a, b) {
-        return a.distance - b.distance;
-    });
-
-    return closestKBuckets;
-};
-
-/*
-  * `query`: _Object_ Object containing query state for this request.
-    * `nodeId`: _String (base64)_ Base64 encoded node id to find.
-    * `nodes`: _Array_ `contact`s to query for `nodeId` arranged from closest to
-            furthest.
-      * `node`:
-        * `id`: _String (base64)_ Base64 encoded contact id.
-    * `nodesMap`: _Object_ A map to the same `contact`s already present in
-            `nodes` for O(1) access.
-  * `callback`: _Function_ The callback to call with result.
-*/
-Discover.prototype.queryCompletionCheck = function queryCompletionCheck (query, callback) {
-    var self = this;
-    // console.log("QUERY COMPLETION CHECK");
-    // are we done?
-    if (query.index == query.nodes.length
-        && query.ongoingRequests == 0 && !query.done) {
-        // find out if any new nodes are closer than the closest
-        // node in order to determine if we should keep going or
-        // stop
-        self.emit('stats.timers.find.round.ms',
-            self.timerEndInMilliseconds('find.round.ms', query.nodeId));
-
-        // console.log('sorting new nodes');
-        // sort the new nodes according to distance
-        var newNodes = [];
-        var nodeIdBuffer = new Buffer(query.nodeId, "base64");
-        query.newNodes.forEach(function (newNode) {
-            var clonedNewNode = clone(newNode);
-            var newNodeIdBuffer = new Buffer(newNode.id, "base64");
-            clonedNewNode.distance =
-                KBucket.distance(nodeIdBuffer, newNodeIdBuffer);
-            // only add nodes that are closer to short circuit the
-            // computation
-            if (clonedNewNode.distance < query.closest.distance) {
-                newNodes.push(clonedNewNode);
-            }
-        });
-
-        // console.log('sorted new nodes');
-
-        // if we don't have any closer nodes, we didn't find
-        // what we are looking for
-        if (newNodes.length == 0) {
-            // we are done done
-            self.transport.removeListener('node', query.listener);
-
-            // console.log('listener removed');
-            // console.dir(query);
-            // sanity check, just in case closest node is the one
-            // we are looking for and wasn't short-circuited
-            // somewhere else
-            if (query.closest.id == query.nodeId) {
-                // console.log("returning closest node", query.closest);
-                return callback(null, query.closest);
-            } else {
-                // console.log("returning not found error");
-                var latency = self.timerEndInMilliseconds('find.ms', query.nodeId);
-                callback(new Error("not found"));
-                self.emit('stats.timers.find.ms', latency);
-                return;
-            }
-        }
-
-        // console.log("found closer nodes", newNodes);
-
-        // found closer node, sort according to length
-        newNodes = newNodes.sort(function (a, b) {
-            return a.distance - b.distance;
-        });
-
-        // update query state and go another round
-        query.index = 0;
-        query.ongoingRequests = 0;
-        query.nodes = newNodes; // these are sorted by distance (unlike query.newNodes)
-        query.nodesMap = {};
-        query.nodes.forEach(function (node) {
-            query.nodesMap[node.id] = node;
-        });
-        query.closest = query.nodes[0];
-        query.newNodes = [];
-
-        return process.nextTick(function () {
-            self.executeQuery(query, callback);
-        });
-    } // are we done?
-    // console.log("FAILED QUERY COMPLETION CHECK >>> KEEP GOING");
-};
-
-/*
-  * `contact`: _Object_ Contact object to register.
-    * `id`: _String (base64)_ _(Default: `crypto.randomBytes(20).toString('base64'`)_
-            The contact id, base 64 encoded; will be created if not present.
-    * `data`: _Any_ Data to be included with the contact, it is guaranteed to be
-            returned for anyone querying for this `contact` by `id`.
-  * Return: _Object_ Contact that was registered with `id` and generated arbiter
-      defaults if necessary.
-*/
-Discover.prototype.register = function register (contact) {
-    var self = this;
-    contact = contact || {};
-    contact = clone(contact); // separate references from outside
-
-    if (!contact.id) {
-        contact.id = crypto.randomBytes(20).toString('base64');
-    }
-
-    // add transport information to the stored contact
-    contact = self.transport.setTransportInfo(contact);
-
-    contact = self.arbiterDefaults(contact);
-
-    var traceHeader = "register(" + contact.id + "): ";
-
-    if (!self.kBuckets[contact.id]) {
-        if (self.tracing)
-            self.trace(traceHeader + 'creating new bucket for ' + util.inspect(contact));
-        var kBucket = new KBucket({arbiter: self.arbiter, localNodeId: contact.id});
-        kBucket.on('ping', function (oldContacts, newContact) {
-            // ping all the old contacts and if one does not respond, remove it
-            var oldContactIdsBase64 = [];
-            var reachedContactIdsBase64 = [];
-            var unreachableListener = function (contact) {
-                if (oldContactIdsBase64.indexOf(contact.id) > -1) {
-                    self.transport.removeListener('unreachable', unreachableListener);
-                    self.transport.removeListener('reached', reachedListener);
-                    kBucket.remove({id: new Buffer(contact.id, "base64")});
-                    kBucket.add(newContact);
-                }
-            };
-            var reachedListener = function (contact) {
-                var index = reachedContactIdsBase64.indexOf(contact.id);
-                if (index > -1) {
-                    reachedContactIdsBase64.splice(index, 1);
-                    if (reachedContactIdsBase64.length == 0) {
-                        // all contacts were reached, won't be adding new one
-                        self.transport.removeListener(
-                            'unreachable', unreachableListener);
-                        self.transport.removeListener(
-                            'reached', reachedListener);
+                // These standalone emit* functions are used to optimize calling of event
+                // handlers for fast cases because emit() itself often has a variable number of
+                // arguments and can be deoptimized because of that. These functions always have
+                // the same number of arguments and thus do not get deoptimized, so the code
+                // inside them can execute faster.
+                function emitNone(handler, isFn, self) {
+                    if (isFn)
+                        handler.call(self);
+                    else {
+                        var len = handler.length;
+                        var listeners = arrayClone(handler, len);
+                        for (var i = 0; i < len; ++i)
+                            listeners[i].call(self);
                     }
                 }
-            };
-            self.transport.on('reached', reachedListener);
-            self.transport.on('unreachable', unreachableListener);
-            var sender = self.kBuckets[contact.id].contact;
-            oldContacts.forEach(function (oldContact) {
-                var contact = clone(oldContact);
-                contact.id = oldContact.id.toString("base64");
-                oldContactIdsBase64.push(contact.id);
-                reachedContactIdsBase64.push(contact.id);
-                self.transport.ping(contact, sender);
-            });
-        });
-        self.kBuckets[contact.id] = {
-            contact: contact,
-            id: contact.id,
-            kBucket: kBucket
-        };
-    } else {
-        if (self.tracing)
-            self.trace(traceHeader + 'bucket already exists, updating contact with ' + util.inspect(contact));
-        self.kBuckets[contact.id].contact = contact;
-    }
 
-    // issuing find(contact.id) against own contact.id, populates the DHT
-    // with contact
-    self.find(contact.id, function () {}, contact /*announce*/);
+                function emitOne(handler, isFn, self, arg1) {
+                    if (isFn)
+                        handler.call(self, arg1);
+                    else {
+                        var len = handler.length;
+                        var listeners = arrayClone(handler, len);
+                        for (var i = 0; i < len; ++i)
+                            listeners[i].call(self, arg1);
+                    }
+                }
 
-    return clone(contact); // don't leak internal implementation
-};
+                function emitTwo(handler, isFn, self, arg1, arg2) {
+                    if (isFn)
+                        handler.call(self, arg1, arg2);
+                    else {
+                        var len = handler.length;
+                        var listeners = arrayClone(handler, len);
+                        for (var i = 0; i < len; ++i)
+                            listeners[i].call(self, arg1, arg2);
+                    }
+                }
 
-/*
-  * `type`: _String_ Timer type.
-  * `key`: _String_ Timer key.
-  * Return: _Number_ Milliseconds since the first time in the timer.
-*/
-Discover.prototype.timerEndInMilliseconds = function timerEndInMilliseconds(type, key) {
-    var self = this;
+                function emitThree(handler, isFn, self, arg1, arg2, arg3) {
+                    if (isFn)
+                        handler.call(self, arg1, arg2, arg3);
+                    else {
+                        var len = handler.length;
+                        var listeners = arrayClone(handler, len);
+                        for (var i = 0; i < len; ++i)
+                            listeners[i].call(self, arg1, arg2, arg3);
+                    }
+                }
 
-    if (!self.timers[type] || !self.timers[type][key]) {
-        return 0;
-    }
+                function emitMany(handler, isFn, self, args) {
+                    if (isFn)
+                        handler.apply(self, args);
+                    else {
+                        var len = handler.length;
+                        var listeners = arrayClone(handler, len);
+                        for (var i = 0; i < len; ++i)
+                            listeners[i].apply(self, args);
+                    }
+                }
 
-    var diff = process.hrtime(self.timers[type][key].shift());
-    if (self.timers[type][key].length == 0) {
-        delete self.timers[type][key];
-    }
-    // diff[0] : seconds
-    // diff[1] : nanoseconds
-    // 1 second = 1e9 nanoseconds
-    // 1 millisecond = 1e6 nanoseconds
-    return Math.floor((diff[0] * 1e9 + diff[1]) / 1e6);
-};
+                EventEmitter.prototype.emit = function emit(type) {
+                    var er, handler, len, args, i, events;
+                    var doError = (type === 'error');
 
-/*
-  * `type`: _String_ Timer type.
-  * `key`: _String_ Timer key.
-*/
-Discover.prototype.timerStart = function timerStart(type, key) {
-    var self = this;
-    self.timers[type][key] = self.timers[type][key] || [];
-    self.timers[type][key].push(process.hrtime());
-};
+                    events = this._events;
+                    if (events)
+                        doError = (doError && events.error == null);
+                    else if (!doError)
+                        return false;
 
-/*
-  * `message`: _String_ Message to trace.
-*/
-Discover.prototype.trace = function(message) {
-    var self = this;
-    var options = self.options;
+                    // If there is no 'error' event listener then throw.
+                    if (doError) {
+                        if (arguments.length > 1)
+                            er = arguments[1];
+                        if (er instanceof Error) {
+                            throw er; // Unhandled 'error' event
+                        } else {
+                            // At least give some kind of context to the user
+                            var err = new Error('Unhandled "error" event. (' + er + ')');
+                            err.context = er;
+                            throw err;
+                        }
+                        return false;
+                    }
 
-    if (options.inlineTrace)
-        console.log('~trace', message);
-    if (options.eventTrace)
-        self.emit('~trace', message);
-};
+                    handler = events[type];
 
-/*
-  * `contact`: _Object_ Contact object to report unreachable
-    * `id`: _String (base64)_ The previously registered contact id, base64
-            encoded.
-*/
-Discover.prototype.unreachable = function unreachable (contact) {
-    var self = this;
-    if (self.tracing)
-        self.trace('unreachable(' + util.inspect(contact) + ')');
+                    if (!handler)
+                        return false;
 
-    // even if we don't have kBuckets, remove contact from LRU cache
-    self.lruCache.del(contact.id);
+                    var isFn = typeof handler === 'function';
+                    len = arguments.length;
+                    switch (len) {
+                        // fast cases
+                        case 1:
+                            emitNone(handler, isFn, this);
+                            break;
+                        case 2:
+                            emitOne(handler, isFn, this, arguments[1]);
+                            break;
+                        case 3:
+                            emitTwo(handler, isFn, this, arguments[1], arguments[2]);
+                            break;
+                        case 4:
+                            emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
+                            break;
+                            // slower
+                        default:
+                            args = new Array(len - 1);
+                            for (i = 1; i < len; i++)
+                                args[i - 1] = arguments[i];
+                            emitMany(handler, isFn, this, args);
+                    }
 
-    // find closest KBucket to remove unreachable contact from
-    var closestKBuckets = self.getClosestKBuckets(contact.id);
-    if (closestKBuckets.length == 0) {
-        if (self.tracing)
-            self.trace('no kBuckets for unreachable(contact) ' + util.inspect(contact));
-        return;
-    }
-    var closestKBucketId = closestKBuckets[0].id;
-    var closestKBucket = self.kBuckets[closestKBucketId].kBucket;
-    if (!closestKBucket) {
-        if (self.tracing)
-            self.trace('no closest kBucket for unreachable(contact) ' + util.inspect(contact));
-        return;
-    }
-    var clonedContact = clone(contact);
-    if (self.tracing)
-        self.trace('removing ' + util.inspect(contact) + ' from kBucket ' + closestKBucketId);
-    clonedContact.id = new Buffer(contact.id, "base64");
-    closestKBucket.remove(clonedContact);
-};
+                    return true;
+                };
 
-/*
-  * `contact`: _Object_ Contact object to register
-    * `id`: _String (base64)_ The previously registered contact id, base 64
-            encoded.
-*/
-Discover.prototype.unregister = function unregister (contact) {
-    var self = this;
-    var kBucket = self.kBuckets[contact.id];
-    if (kBucket) {
-        if (kBucket.contact === self.arbiter(kBucket.contact, contact)
-            && kBucket.contact !== contact) {
-            // by returning the stored contact, arbiter determined that
-            // unregister should fail as an attempt to unregister using
-            // old data has been made
-            return;
-        }
-        delete self.kBuckets[contact.id];
-    }
+                function _addListener(target, type, listener, prepend) {
+                    var m;
+                    var events;
+                    var existing;
 
-    // current implemenation deletes all that "closest" contact information
-    // that was gathered in the unregistering kBucket
+                    if (typeof listener !== 'function')
+                        throw new TypeError('"listener" argument must be a function');
 
-    // TODO: elaborate the implementation to distribute known nodes in this
-    //       kBucket to ones that aren't being deleted
-};
-}).call(this,require('_process'),require("buffer").Buffer)
-},{"_process":125,"buffer":55,"clone":2,"crypto":63,"discover-tcp-transport":3,"events":90,"k-bucket":4,"lru-cache":5,"util":162}],2:[function(require,module,exports){
-(function (Buffer){
-"use strict";
+                    events = target._events;
+                    if (!events) {
+                        events = target._events = objectCreate(null);
+                        target._eventsCount = 0;
+                    } else {
+                        // To avoid recursion in the case that type === "newListener"! Before
+                        // adding it to the listeners, first emit "newListener".
+                        if (events.newListener) {
+                            target.emit('newListener', type,
+                                listener.listener ? listener.listener : listener);
 
-function objectToString(o) {
-  return Object.prototype.toString.call(o);
-}
+                            // Re-assign `events` because a newListener handler could have caused the
+                            // this._events to be assigned to a new object
+                            events = target._events;
+                        }
+                        existing = events[type];
+                    }
 
-var util = {
-  isArray: function (ar) {
-    return Array.isArray(ar) || (typeof ar === 'object' && objectToString(ar) === '[object Array]');
-  },
-  isDate: function (d) {
-    return typeof d === 'object' && objectToString(d) === '[object Date]';
-  },
-  isRegExp: function (re) {
-    return typeof re === 'object' && objectToString(re) === '[object RegExp]';
-  },
-  getRegExpFlags: function (re) {
-    var flags = '';
-    re.global && (flags += 'g');
-    re.ignoreCase && (flags += 'i');
-    re.multiline && (flags += 'm');
-    return flags;
-  }
-};
+                    if (!existing) {
+                        // Optimize the case of one listener. Don't need the extra array object.
+                        existing = events[type] = listener;
+                        ++target._eventsCount;
+                    } else {
+                        if (typeof existing === 'function') {
+                            // Adding the second element, need to change to array.
+                            existing = events[type] =
+                                prepend ? [listener, existing] : [existing, listener];
+                        } else {
+                            // If we've already got an array, just append.
+                            if (prepend) {
+                                existing.unshift(listener);
+                            } else {
+                                existing.push(listener);
+                            }
+                        }
 
-if (typeof module === 'object')
-  module.exports = clone;
+                        // Check for listener leak
+                        if (!existing.warned) {
+                            m = $getMaxListeners(target);
+                            if (m && m > 0 && existing.length > m) {
+                                existing.warned = true;
+                                var w = new Error('Possible EventEmitter memory leak detected. ' +
+                                    existing.length + ' "' + String(type) + '" listeners ' +
+                                    'added. Use emitter.setMaxListeners() to ' +
+                                    'increase limit.');
+                                w.name = 'MaxListenersExceededWarning';
+                                w.emitter = target;
+                                w.type = type;
+                                w.count = existing.length;
+                                if (typeof console === 'object' && console.warn) {
+                                    console.warn('%s: %s', w.name, w.message);
+                                }
+                            }
+                        }
+                    }
 
-/**
- * Clones (copies) an Object using deep copying.
- *
- * This function supports circular references by default, but if you are certain
- * there are no circular references in your object, you can save some CPU time
- * by calling clone(obj, false).
- *
- * Caution: if `circular` is false and `parent` contains circular references,
- * your program may enter an infinite loop and crash.
- *
- * @param `parent` - the object to be cloned
- * @param `circular` - set to true if the object to be cloned may contain
- *    circular references. (optional - true by default)
-*/
-function clone(parent, circular) {
-  if (typeof circular == 'undefined')
-    circular = true;
+                    return target;
+                }
 
-  var useBuffer = typeof Buffer != 'undefined';
+                EventEmitter.prototype.addListener = function addListener(type, listener) {
+                    return _addListener(this, type, listener, false);
+                };
 
-  var circularParent = {};
-  var circularResolved = {};
-  var circularReplace = [];
+                EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-  function _clone(parent, context, child, cIndex) {
-    var i; // Use local context within this function
-    // Deep clone all properties of parent into child
-    if (typeof parent == 'object') {
-      if (parent == null)
-        return parent;
-      // Check for circular references
-      for(i in circularParent)
-        if (circularParent[i] === parent) {
-          // We found a circular reference
-          circularReplace.push({'resolveTo': i, 'child': child, 'i': cIndex});
-          return null; //Just return null for now...
-          // we will resolve circular references later
-        }
+                EventEmitter.prototype.prependListener =
+                    function prependListener(type, listener) {
+                        return _addListener(this, type, listener, true);
+                    };
 
-      // Add to list of all parent objects
-      circularParent[context] = parent;
-      // Now continue cloning...
-      if (util.isArray(parent)) {
-        child = [];
-        for(i in parent)
-          child[i] = _clone(parent[i], context + '[' + i + ']', child, i);
-      }
-      else if (util.isDate(parent))
-        child = new Date(parent.getTime());
-      else if (util.isRegExp(parent)) {
-        child = new RegExp(parent.source, util.getRegExpFlags(parent));
-        if (parent.lastIndex) child.lastIndex = parent.lastIndex;
-      } else if (useBuffer && Buffer.isBuffer(parent))
-      {
-        child = new Buffer(parent.length);
-        parent.copy(child);
-      }
-      else {
-        child = {};
+                function onceWrapper() {
+                    if (!this.fired) {
+                        this.target.removeListener(this.type, this.wrapFn);
+                        this.fired = true;
+                        switch (arguments.length) {
+                            case 0:
+                                return this.listener.call(this.target);
+                            case 1:
+                                return this.listener.call(this.target, arguments[0]);
+                            case 2:
+                                return this.listener.call(this.target, arguments[0], arguments[1]);
+                            case 3:
+                                return this.listener.call(this.target, arguments[0], arguments[1],
+                                    arguments[2]);
+                            default:
+                                var args = new Array(arguments.length);
+                                for (var i = 0; i < args.length; ++i)
+                                    args[i] = arguments[i];
+                                this.listener.apply(this.target, args);
+                        }
+                    }
+                }
 
-        // Also copy prototype over to new cloned object
-        child.__proto__ = parent.__proto__;
-        for(i in parent)
-          child[i] = _clone(parent[i], context + '[' + i + ']', child, i);
-      }
+                function _onceWrap(target, type, listener) {
+                    var state = {
+                        fired: false,
+                        wrapFn: undefined,
+                        target: target,
+                        type: type,
+                        listener: listener
+                    };
+                    var wrapped = bind.call(onceWrapper, state);
+                    wrapped.listener = listener;
+                    state.wrapFn = wrapped;
+                    return wrapped;
+                }
 
-      // Add to list of all cloned objects
-      circularResolved[context] = child;
-    }
-    else
-      child = parent; //Just a simple shallow copy will do
-    return child;
-  }
+                EventEmitter.prototype.once = function once(type, listener) {
+                    if (typeof listener !== 'function')
+                        throw new TypeError('"listener" argument must be a function');
+                    this.on(type, _onceWrap(this, type, listener));
+                    return this;
+                };
 
-  var i;
-  if (circular) {
-    var cloned = _clone(parent, '*');
+                EventEmitter.prototype.prependOnceListener =
+                    function prependOnceListener(type, listener) {
+                        if (typeof listener !== 'function')
+                            throw new TypeError('"listener" argument must be a function');
+                        this.prependListener(type, _onceWrap(this, type, listener));
+                        return this;
+                    };
 
-    // Now this object has been cloned. Let's check to see if there are any
-    // circular references for it
-    for(i in circularReplace) {
-      var c = circularReplace[i];
-      if (c && c.child && c.i in c.child) {
-        c.child[c.i] = circularResolved[c.resolveTo];
-      }
-    }
-    return cloned;
-  } else {
-    // Deep clone all properties of parent into child
-    var child;
-    if (typeof parent == 'object') {
-      if (parent == null)
-        return parent;
-      if (parent.constructor.name === 'Array') {
-        child = [];
-        for(i in parent)
-          child[i] = clone(parent[i], circular);
-      }
-      else if (util.isDate(parent))
-        child = new Date(parent.getTime() );
-      else if (util.isRegExp(parent)) {
-        child = new RegExp(parent.source, util.getRegExpFlags(parent));
-        if (parent.lastIndex) child.lastIndex = parent.lastIndex;
-      } else {
-        child = {};
-        child.__proto__ = parent.__proto__;
-        for(i in parent)
-          child[i] = clone(parent[i], circular);
-      }
-    }
-    else
-      child = parent; // Just a simple shallow clone will do
-    return child;
-  }
-}
+                // Emits a 'removeListener' event if and only if the listener was removed.
+                EventEmitter.prototype.removeListener =
+                    function removeListener(type, listener) {
+                        var list, events, position, i, originalListener;
 
-/**
- * Simple flat clone using prototype, accepts only objects, usefull for property
- * override on FLAT configuration object (no nested props).
- *
- * USE WITH CAUTION! This may not behave as you wish if you do not know how this
- * works.
- */
-clone.clonePrototype = function(parent) {
-  if (parent === null)
-    return null;
+                        if (typeof listener !== 'function')
+                            throw new TypeError('"listener" argument must be a function');
 
-  var c = function () {};
-  c.prototype = parent;
-  return new c();
-};
+                        events = this._events;
+                        if (!events)
+                            return this;
 
-}).call(this,require("buffer").Buffer)
-},{"buffer":55}],3:[function(require,module,exports){
-/*
+                        list = events[type];
+                        if (!list)
+                            return this;
 
-index.js - discover-tcp-transport: TCP transport for Discover node discovery
+                        if (list === listener || list.listener === listener) {
+                            if (--this._eventsCount === 0)
+                                this._events = objectCreate(null);
+                            else {
+                                delete events[type];
+                                if (events.removeListener)
+                                    this.emit('removeListener', type, list.listener || listener);
+                            }
+                        } else if (typeof list !== 'function') {
+                            position = -1;
 
-The MIT License (MIT)
+                            for (i = list.length - 1; i >= 0; i--) {
+                                if (list[i] === listener || list[i].listener === listener) {
+                                    originalListener = list[i].listener;
+                                    position = i;
+                                    break;
+                                }
+                            }
 
-Copyright (c) 2013-2014 Tristan Slominski
+                            if (position < 0)
+                                return this;
 
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
+                            if (position === 0)
+                                list.shift();
+                            else
+                                spliceOne(list, position);
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+                            if (list.length === 1)
+                                events[type] = list[0];
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
+                            if (events.removeListener)
+                                this.emit('removeListener', type, originalListener || listener);
+                        }
 
-*/
-"use strict";
+                        return this;
+                    };
 
-var events = require('events'),
-    net = require('net'),
-    util = require('util');
+                EventEmitter.prototype.removeAllListeners =
+                    function removeAllListeners(type) {
+                        var listeners, events, i;
 
-var TcpTransport = module.exports = function TcpTransport (options) {
-    var self = this;
-    events.EventEmitter.call(self);
+                        events = this._events;
+                        if (!events)
+                            return this;
 
-    options = options || {};
+                        // not listening for removeListener, no need to emit
+                        if (!events.removeListener) {
+                            if (arguments.length === 0) {
+                                this._events = objectCreate(null);
+                                this._eventsCount = 0;
+                            } else if (events[type]) {
+                                if (--this._eventsCount === 0)
+                                    this._events = objectCreate(null);
+                                else
+                                    delete events[type];
+                            }
+                            return this;
+                        }
 
-    self.id = options.id;
-    self.host = options.host || 'localhost';
-    self.port = options.port || 6742;
+                        // emit removeListener for all listeners on all events
+                        if (arguments.length === 0) {
+                            var keys = objectKeys(events);
+                            var key;
+                            for (i = 0; i < keys.length; ++i) {
+                                key = keys[i];
+                                if (key === 'removeListener') continue;
+                                this.removeAllListeners(key);
+                            }
+                            this.removeAllListeners('removeListener');
+                            this._events = objectCreate(null);
+                            this._eventsCount = 0;
+                            return this;
+                        }
 
-    self.server = null;
-};
+                        listeners = events[type];
 
-util.inherits(TcpTransport, events.EventEmitter);
+                        if (typeof listeners === 'function') {
+                            this.removeListener(type, listeners);
+                        } else if (listeners) {
+                            // LIFO order
+                            for (i = listeners.length - 1; i >= 0; i--) {
+                                this.removeListener(type, listeners[i]);
+                            }
+                        }
 
-/*
-  * `options`: See `new TcpTransport(options)` `options`.
-  * `callback`: See `tcpTransport.listen(callback)` `callback`.
-  Return: _Object_ An instance of TcpTransport with server running.
-*/
-TcpTransport.listen = function listen (options, callback) {
-    var tcpTransport = new TcpTransport(options);
-    tcpTransport.listen(callback);
-    return tcpTransport;
-};
+                        return this;
+                    };
 
-/*
-  * `callback`: _Function_ _(Default: undefined)_ Optional callback to call once
-      the server is stopped.
-*/
-TcpTransport.prototype.close = function close (callback) {
-    var self = this;
-    if (self.server)
-        self.server.close(callback);
-};
+                function _listeners(target, type, unwrap) {
+                    var events = target._events;
 
-/*
-  * `contact`: _Object_ The node to contact with request to find `nodeId`.
-    * `id`: _String (base64)_ Base64 encoded contact node id.
-    * `transport`: _Object_ TCP transport data.
-      * `host`: _String_ IP address to connect to.
-      * `port`: _Integer_ Port to connect to.
-  * `nodeId`: _String (base64)_ Base64 encoded string representation of the node id to find.
-  * `sender`: _Object_ The node making the request
-    * `id`: _String (base64)_ Base64 encoded sender node id.
-    * `data`: _Any_ Sender node data.
-    * `transport`: _Object_ TCP transport data.
-      * `host`: _String_ Host to connect to.
-      * `port`: _Integer_ Port to connect to.
-*/
-TcpTransport.prototype.findNode = function findNode (contact, nodeId, sender) {
-    var self = this;
-    self.rpc(contact, {
-        request: {
-            findNode: nodeId
-        },
-        sender: sender
-    }, function(error, data) {
-        if (error) {
-            self.emit('node', new Error('unreachable'), contact, nodeId);
-            self.emit('unreachable', contact);
-            return;
-        }
-        if (!data)
-            return self.emit('node', new Error('no data received'), contact, nodeId);
+                    if (!events)
+                        return [];
 
-        try {
-            data = JSON.parse(data.toString());
-            return self.emit('node', null, contact, nodeId, data);
-        } catch (exception) {
-            self.emit('node',
-                new Error('JSON parse error: ' + exception.message + ' when parsing ' + data),
-                contact, nodeId);
-        }
-    });
-};
+                    var evlistener = events[type];
+                    if (!evlistener)
+                        return [];
 
-/*
-  * `callback`: _Function_ _(Default: undefined)_ Optional callback to call once
-      the server is up.
-*/
-TcpTransport.prototype.listen = function listen (callback) {
-    var self = this;
-    self.server = net.createServer(function (connection) {
-        var responseCallback = function (response) {
-            connection.write(JSON.stringify(response) + '\r\n');
-            connection.end();
-        };
-        var data = "";
-        connection.on('data', function (chunk) {
-            data += chunk.toString("utf8");
-            if (!~data.indexOf('\r\n')) {
-                return; // wait for more data
-            }
+                    if (typeof evlistener === 'function')
+                        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
 
-            try {
-                data = JSON.parse(data.toString("utf8"));
-            } catch (exception) {
-                return connection.end(); // kill connection
-            }
-            if (data.request && data.request.findNode) {
-                self.emit('findNode', data.request.findNode, data.sender, function (error, response) {
-                    if (error)
-                        return connection.end();
-                    if (responseCallback)
-                        responseCallback(response);
+                    return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+                }
+
+                EventEmitter.prototype.listeners = function listeners(type) {
+                    return _listeners(this, type, true);
+                };
+
+                EventEmitter.prototype.rawListeners = function rawListeners(type) {
+                    return _listeners(this, type, false);
+                };
+
+                EventEmitter.listenerCount = function (emitter, type) {
+                    if (typeof emitter.listenerCount === 'function') {
+                        return emitter.listenerCount(type);
+                    } else {
+                        return listenerCount.call(emitter, type);
+                    }
+                };
+
+                EventEmitter.prototype.listenerCount = listenerCount;
+
+                function listenerCount(type) {
+                    var events = this._events;
+
+                    if (events) {
+                        var evlistener = events[type];
+
+                        if (typeof evlistener === 'function') {
+                            return 1;
+                        } else if (evlistener) {
+                            return evlistener.length;
+                        }
+                    }
+
+                    return 0;
+                }
+
+                EventEmitter.prototype.eventNames = function eventNames() {
+                    return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+                };
+
+                // About 1.5x faster than the two-arg version of Array#splice().
+                function spliceOne(list, index) {
+                    for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
+                        list[i] = list[k];
+                    list.pop();
+                }
+
+                function arrayClone(arr, n) {
+                    var copy = new Array(n);
+                    for (var i = 0; i < n; ++i)
+                        copy[i] = arr[i];
+                    return copy;
+                }
+
+                function unwrapListeners(arr) {
+                    var ret = new Array(arr.length);
+                    for (var i = 0; i < ret.length; ++i) {
+                        ret[i] = arr[i].listener || arr[i];
+                    }
+                    return ret;
+                }
+
+                function objectCreatePolyfill(proto) {
+                    var F = function () {};
+                    F.prototype = proto;
+                    return new F;
+                }
+
+                function objectKeysPolyfill(obj) {
+                    var keys = [];
+                    for (var k in obj)
+                        if (Object.prototype.hasOwnProperty.call(obj, k)) {
+                            keys.push(k);
+                        }
+                    return k;
+                }
+
+                function functionBindPolyfill(context) {
+                    var fn = this;
+                    return function () {
+                        return fn.apply(context, arguments);
+                    };
+                }
+
+            }, {}],
+            91: [function (require, module, exports) {
+                var Buffer = require('safe-buffer').Buffer
+                var MD5 = require('md5.js')
+
+                /* eslint-disable camelcase */
+                function EVP_BytesToKey(password, salt, keyBits, ivLen) {
+                    if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary')
+                    if (salt) {
+                        if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary')
+                        if (salt.length !== 8) throw new RangeError(
+                            'salt should be Buffer with 8 byte length')
+                    }
+
+                    var keyLen = keyBits / 8
+                    var key = Buffer.alloc(keyLen)
+                    var iv = Buffer.alloc(ivLen || 0)
+                    var tmp = Buffer.alloc(0)
+
+                    while (keyLen > 0 || ivLen > 0) {
+                        var hash = new MD5()
+                        hash.update(tmp)
+                        hash.update(password)
+                        if (salt) hash.update(salt)
+                        tmp = hash.digest()
+
+                        var used = 0
+
+                        if (keyLen > 0) {
+                            var keyStart = key.length - keyLen
+                            used = Math.min(keyLen, tmp.length)
+                            tmp.copy(key, keyStart, 0, used)
+                            keyLen -= used
+                        }
+
+                        if (used < tmp.length && ivLen > 0) {
+                            var ivStart = iv.length - ivLen
+                            var length = Math.min(ivLen, tmp.length - used)
+                            tmp.copy(iv, ivStart, used, used + length)
+                            ivLen -= length
+                        }
+                    }
+
+                    tmp.fill(0)
+                    return {
+                        key: key,
+                        iv: iv
+                    }
+                }
+
+                module.exports = EVP_BytesToKey
+
+            }, {
+                "md5.js": 110,
+                "safe-buffer": 148
+            }],
+            92: [function (require, module, exports) {
+                'use strict'
+                var Buffer = require('safe-buffer').Buffer
+                var Transform = require('stream').Transform
+                var inherits = require('inherits')
+
+                function throwIfNotStringOrBuffer(val, prefix) {
+                    if (!Buffer.isBuffer(val) && typeof val !== 'string') {
+                        throw new TypeError(prefix + ' must be a string or a buffer')
+                    }
+                }
+
+                function HashBase(blockSize) {
+                    Transform.call(this)
+
+                    this._block = Buffer.allocUnsafe(blockSize)
+                    this._blockSize = blockSize
+                    this._blockOffset = 0
+                    this._length = [0, 0, 0, 0]
+
+                    this._finalized = false
+                }
+
+                inherits(HashBase, Transform)
+
+                HashBase.prototype._transform = function (chunk, encoding, callback) {
+                    var error = null
+                    try {
+                        this.update(chunk, encoding)
+                    } catch (err) {
+                        error = err
+                    }
+
+                    callback(error)
+                }
+
+                HashBase.prototype._flush = function (callback) {
+                    var error = null
+                    try {
+                        this.push(this.digest())
+                    } catch (err) {
+                        error = err
+                    }
+
+                    callback(error)
+                }
+
+                HashBase.prototype.update = function (data, encoding) {
+                    throwIfNotStringOrBuffer(data, 'Data')
+                    if (this._finalized) throw new Error('Digest already called')
+                    if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)
+
+                    // consume data
+                    var block = this._block
+                    var offset = 0
+                    while (this._blockOffset + data.length - offset >= this._blockSize) {
+                        for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]
+                        this._update()
+                        this._blockOffset = 0
+                    }
+                    while (offset < data.length) block[this._blockOffset++] = data[offset++]
+
+                    // update length
+                    for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
+                        this._length[j] += carry
+                        carry = (this._length[j] / 0x0100000000) | 0
+                        if (carry > 0) this._length[j] -= 0x0100000000 * carry
+                    }
+
+                    return this
+                }
+
+                HashBase.prototype._update = function () {
+                    throw new Error('_update is not implemented')
+                }
+
+                HashBase.prototype.digest = function (encoding) {
+                    if (this._finalized) throw new Error('Digest already called')
+                    this._finalized = true
+
+                    var digest = this._digest()
+                    if (encoding !== undefined) digest = digest.toString(encoding)
+
+                    // reset state
+                    this._block.fill(0)
+                    this._blockOffset = 0
+                    for (var i = 0; i < 4; ++i) this._length[i] = 0
+
+                    return digest
+                }
+
+                HashBase.prototype._digest = function () {
+                    throw new Error('_digest is not implemented')
+                }
+
+                module.exports = HashBase
+
+            }, {
+                "inherits": 107,
+                "safe-buffer": 148,
+                "stream": 157
+            }],
+            93: [function (require, module, exports) {
+                var hash = exports;
+
+                hash.utils = require('./hash/utils');
+                hash.common = require('./hash/common');
+                hash.sha = require('./hash/sha');
+                hash.ripemd = require('./hash/ripemd');
+                hash.hmac = require('./hash/hmac');
+
+                // Proxy hash functions to the main object
+                hash.sha1 = hash.sha.sha1;
+                hash.sha256 = hash.sha.sha256;
+                hash.sha224 = hash.sha.sha224;
+                hash.sha384 = hash.sha.sha384;
+                hash.sha512 = hash.sha.sha512;
+                hash.ripemd160 = hash.ripemd.ripemd160;
+
+            }, {
+                "./hash/common": 94,
+                "./hash/hmac": 95,
+                "./hash/ripemd": 96,
+                "./hash/sha": 97,
+                "./hash/utils": 104
+            }],
+            94: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('./utils');
+                var assert = require('minimalistic-assert');
+
+                function BlockHash() {
+                    this.pending = null;
+                    this.pendingTotal = 0;
+                    this.blockSize = this.constructor.blockSize;
+                    this.outSize = this.constructor.outSize;
+                    this.hmacStrength = this.constructor.hmacStrength;
+                    this.padLength = this.constructor.padLength / 8;
+                    this.endian = 'big';
+
+                    this._delta8 = this.blockSize / 8;
+                    this._delta32 = this.blockSize / 32;
+                }
+                exports.BlockHash = BlockHash;
+
+                BlockHash.prototype.update = function update(msg, enc) {
+                    // Convert message to array, pad it, and join into 32bit blocks
+                    msg = utils.toArray(msg, enc);
+                    if (!this.pending)
+                        this.pending = msg;
+                    else
+                        this.pending = this.pending.concat(msg);
+                    this.pendingTotal += msg.length;
+
+                    // Enough data, try updating
+                    if (this.pending.length >= this._delta8) {
+                        msg = this.pending;
+
+                        // Process pending data in blocks
+                        var r = msg.length % this._delta8;
+                        this.pending = msg.slice(msg.length - r, msg.length);
+                        if (this.pending.length === 0)
+                            this.pending = null;
+
+                        msg = utils.join32(msg, 0, msg.length - r, this.endian);
+                        for (var i = 0; i < msg.length; i += this._delta32)
+                            this._update(msg, i, i + this._delta32);
+                    }
+
+                    return this;
+                };
+
+                BlockHash.prototype.digest = function digest(enc) {
+                    this.update(this._pad());
+                    assert(this.pending === null);
+
+                    return this._digest(enc);
+                };
+
+                BlockHash.prototype._pad = function pad() {
+                    var len = this.pendingTotal;
+                    var bytes = this._delta8;
+                    var k = bytes - ((len + this.padLength) % bytes);
+                    var res = new Array(k + this.padLength);
+                    res[0] = 0x80;
+                    for (var i = 1; i < k; i++)
+                        res[i] = 0;
+
+                    // Append length
+                    len <<= 3;
+                    if (this.endian === 'big') {
+                        for (var t = 8; t < this.padLength; t++)
+                            res[i++] = 0;
+
+                        res[i++] = 0;
+                        res[i++] = 0;
+                        res[i++] = 0;
+                        res[i++] = 0;
+                        res[i++] = (len >>> 24) & 0xff;
+                        res[i++] = (len >>> 16) & 0xff;
+                        res[i++] = (len >>> 8) & 0xff;
+                        res[i++] = len & 0xff;
+                    } else {
+                        res[i++] = len & 0xff;
+                        res[i++] = (len >>> 8) & 0xff;
+                        res[i++] = (len >>> 16) & 0xff;
+                        res[i++] = (len >>> 24) & 0xff;
+                        res[i++] = 0;
+                        res[i++] = 0;
+                        res[i++] = 0;
+                        res[i++] = 0;
+
+                        for (t = 8; t < this.padLength; t++)
+                            res[i++] = 0;
+                    }
+
+                    return res;
+                };
+
+            }, {
+                "./utils": 104,
+                "minimalistic-assert": 112
+            }],
+            95: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('./utils');
+                var assert = require('minimalistic-assert');
+
+                function Hmac(hash, key, enc) {
+                    if (!(this instanceof Hmac))
+                        return new Hmac(hash, key, enc);
+                    this.Hash = hash;
+                    this.blockSize = hash.blockSize / 8;
+                    this.outSize = hash.outSize / 8;
+                    this.inner = null;
+                    this.outer = null;
+
+                    this._init(utils.toArray(key, enc));
+                }
+                module.exports = Hmac;
+
+                Hmac.prototype._init = function init(key) {
+                    // Shorten key, if needed
+                    if (key.length > this.blockSize)
+                        key = new this.Hash().update(key).digest();
+                    assert(key.length <= this.blockSize);
+
+                    // Add padding to key
+                    for (var i = key.length; i < this.blockSize; i++)
+                        key.push(0);
+
+                    for (i = 0; i < key.length; i++)
+                        key[i] ^= 0x36;
+                    this.inner = new this.Hash().update(key);
+
+                    // 0x36 ^ 0x5c = 0x6a
+                    for (i = 0; i < key.length; i++)
+                        key[i] ^= 0x6a;
+                    this.outer = new this.Hash().update(key);
+                };
+
+                Hmac.prototype.update = function update(msg, enc) {
+                    this.inner.update(msg, enc);
+                    return this;
+                };
+
+                Hmac.prototype.digest = function digest(enc) {
+                    this.outer.update(this.inner.digest());
+                    return this.outer.digest(enc);
+                };
+
+            }, {
+                "./utils": 104,
+                "minimalistic-assert": 112
+            }],
+            96: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('./utils');
+                var common = require('./common');
+
+                var rotl32 = utils.rotl32;
+                var sum32 = utils.sum32;
+                var sum32_3 = utils.sum32_3;
+                var sum32_4 = utils.sum32_4;
+                var BlockHash = common.BlockHash;
+
+                function RIPEMD160() {
+                    if (!(this instanceof RIPEMD160))
+                        return new RIPEMD160();
+
+                    BlockHash.call(this);
+
+                    this.h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+                    this.endian = 'little';
+                }
+                utils.inherits(RIPEMD160, BlockHash);
+                exports.ripemd160 = RIPEMD160;
+
+                RIPEMD160.blockSize = 512;
+                RIPEMD160.outSize = 160;
+                RIPEMD160.hmacStrength = 192;
+                RIPEMD160.padLength = 64;
+
+                RIPEMD160.prototype._update = function update(msg, start) {
+                    var A = this.h[0];
+                    var B = this.h[1];
+                    var C = this.h[2];
+                    var D = this.h[3];
+                    var E = this.h[4];
+                    var Ah = A;
+                    var Bh = B;
+                    var Ch = C;
+                    var Dh = D;
+                    var Eh = E;
+                    for (var j = 0; j < 80; j++) {
+                        var T = sum32(
+                            rotl32(
+                                sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
+                                s[j]),
+                            E);
+                        A = E;
+                        E = D;
+                        D = rotl32(C, 10);
+                        C = B;
+                        B = T;
+                        T = sum32(
+                            rotl32(
+                                sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
+                                sh[j]),
+                            Eh);
+                        Ah = Eh;
+                        Eh = Dh;
+                        Dh = rotl32(Ch, 10);
+                        Ch = Bh;
+                        Bh = T;
+                    }
+                    T = sum32_3(this.h[1], C, Dh);
+                    this.h[1] = sum32_3(this.h[2], D, Eh);
+                    this.h[2] = sum32_3(this.h[3], E, Ah);
+                    this.h[3] = sum32_3(this.h[4], A, Bh);
+                    this.h[4] = sum32_3(this.h[0], B, Ch);
+                    this.h[0] = T;
+                };
+
+                RIPEMD160.prototype._digest = function digest(enc) {
+                    if (enc === 'hex')
+                        return utils.toHex32(this.h, 'little');
+                    else
+                        return utils.split32(this.h, 'little');
+                };
+
+                function f(j, x, y, z) {
+                    if (j <= 15)
+                        return x ^ y ^ z;
+                    else if (j <= 31)
+                        return (x & y) | ((~x) & z);
+                    else if (j <= 47)
+                        return (x | (~y)) ^ z;
+                    else if (j <= 63)
+                        return (x & z) | (y & (~z));
+                    else
+                        return x ^ (y | (~z));
+                }
+
+                function K(j) {
+                    if (j <= 15)
+                        return 0x00000000;
+                    else if (j <= 31)
+                        return 0x5a827999;
+                    else if (j <= 47)
+                        return 0x6ed9eba1;
+                    else if (j <= 63)
+                        return 0x8f1bbcdc;
+                    else
+                        return 0xa953fd4e;
+                }
+
+                function Kh(j) {
+                    if (j <= 15)
+                        return 0x50a28be6;
+                    else if (j <= 31)
+                        return 0x5c4dd124;
+                    else if (j <= 47)
+                        return 0x6d703ef3;
+                    else if (j <= 63)
+                        return 0x7a6d76e9;
+                    else
+                        return 0x00000000;
+                }
+
+                var r = [
+                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+                    7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+                    3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+                    1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+                    4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
+                ];
+
+                var rh = [
+                    5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+                    6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+                    15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+                    8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+                    12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
+                ];
+
+                var s = [
+                    11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+                    7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+                    11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+                    11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+                    9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
+                ];
+
+                var sh = [
+                    8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+                    9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+                    9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+                    15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+                    8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
+                ];
+
+            }, {
+                "./common": 94,
+                "./utils": 104
+            }],
+            97: [function (require, module, exports) {
+                'use strict';
+
+                exports.sha1 = require('./sha/1');
+                exports.sha224 = require('./sha/224');
+                exports.sha256 = require('./sha/256');
+                exports.sha384 = require('./sha/384');
+                exports.sha512 = require('./sha/512');
+
+            }, {
+                "./sha/1": 98,
+                "./sha/224": 99,
+                "./sha/256": 100,
+                "./sha/384": 101,
+                "./sha/512": 102
+            }],
+            98: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('../utils');
+                var common = require('../common');
+                var shaCommon = require('./common');
+
+                var rotl32 = utils.rotl32;
+                var sum32 = utils.sum32;
+                var sum32_5 = utils.sum32_5;
+                var ft_1 = shaCommon.ft_1;
+                var BlockHash = common.BlockHash;
+
+                var sha1_K = [
+                    0x5A827999, 0x6ED9EBA1,
+                    0x8F1BBCDC, 0xCA62C1D6
+                ];
+
+                function SHA1() {
+                    if (!(this instanceof SHA1))
+                        return new SHA1();
+
+                    BlockHash.call(this);
+                    this.h = [
+                        0x67452301, 0xefcdab89, 0x98badcfe,
+                        0x10325476, 0xc3d2e1f0
+                    ];
+                    this.W = new Array(80);
+                }
+
+                utils.inherits(SHA1, BlockHash);
+                module.exports = SHA1;
+
+                SHA1.blockSize = 512;
+                SHA1.outSize = 160;
+                SHA1.hmacStrength = 80;
+                SHA1.padLength = 64;
+
+                SHA1.prototype._update = function _update(msg, start) {
+                    var W = this.W;
+
+                    for (var i = 0; i < 16; i++)
+                        W[i] = msg[start + i];
+
+                    for (; i < W.length; i++)
+                        W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
+
+                    var a = this.h[0];
+                    var b = this.h[1];
+                    var c = this.h[2];
+                    var d = this.h[3];
+                    var e = this.h[4];
+
+                    for (i = 0; i < W.length; i++) {
+                        var s = ~~(i / 20);
+                        var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
+                        e = d;
+                        d = c;
+                        c = rotl32(b, 30);
+                        b = a;
+                        a = t;
+                    }
+
+                    this.h[0] = sum32(this.h[0], a);
+                    this.h[1] = sum32(this.h[1], b);
+                    this.h[2] = sum32(this.h[2], c);
+                    this.h[3] = sum32(this.h[3], d);
+                    this.h[4] = sum32(this.h[4], e);
+                };
+
+                SHA1.prototype._digest = function digest(enc) {
+                    if (enc === 'hex')
+                        return utils.toHex32(this.h, 'big');
+                    else
+                        return utils.split32(this.h, 'big');
+                };
+
+            }, {
+                "../common": 94,
+                "../utils": 104,
+                "./common": 103
+            }],
+            99: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('../utils');
+                var SHA256 = require('./256');
+
+                function SHA224() {
+                    if (!(this instanceof SHA224))
+                        return new SHA224();
+
+                    SHA256.call(this);
+                    this.h = [
+                        0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
+                        0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
+                    ];
+                }
+                utils.inherits(SHA224, SHA256);
+                module.exports = SHA224;
+
+                SHA224.blockSize = 512;
+                SHA224.outSize = 224;
+                SHA224.hmacStrength = 192;
+                SHA224.padLength = 64;
+
+                SHA224.prototype._digest = function digest(enc) {
+                    // Just truncate output
+                    if (enc === 'hex')
+                        return utils.toHex32(this.h.slice(0, 7), 'big');
+                    else
+                        return utils.split32(this.h.slice(0, 7), 'big');
+                };
+
+
+            }, {
+                "../utils": 104,
+                "./256": 100
+            }],
+            100: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('../utils');
+                var common = require('../common');
+                var shaCommon = require('./common');
+                var assert = require('minimalistic-assert');
+
+                var sum32 = utils.sum32;
+                var sum32_4 = utils.sum32_4;
+                var sum32_5 = utils.sum32_5;
+                var ch32 = shaCommon.ch32;
+                var maj32 = shaCommon.maj32;
+                var s0_256 = shaCommon.s0_256;
+                var s1_256 = shaCommon.s1_256;
+                var g0_256 = shaCommon.g0_256;
+                var g1_256 = shaCommon.g1_256;
+
+                var BlockHash = common.BlockHash;
+
+                var sha256_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
+                ];
+
+                function SHA256() {
+                    if (!(this instanceof SHA256))
+                        return new SHA256();
+
+                    BlockHash.call(this);
+                    this.h = [
+                        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+                        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+                    ];
+                    this.k = sha256_K;
+                    this.W = new Array(64);
+                }
+                utils.inherits(SHA256, BlockHash);
+                module.exports = SHA256;
+
+                SHA256.blockSize = 512;
+                SHA256.outSize = 256;
+                SHA256.hmacStrength = 192;
+                SHA256.padLength = 64;
+
+                SHA256.prototype._update = function _update(msg, start) {
+                    var W = this.W;
+
+                    for (var i = 0; i < 16; i++)
+                        W[i] = msg[start + i];
+                    for (; i < W.length; i++)
+                        W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
+
+                    var a = this.h[0];
+                    var b = this.h[1];
+                    var c = this.h[2];
+                    var d = this.h[3];
+                    var e = this.h[4];
+                    var f = this.h[5];
+                    var g = this.h[6];
+                    var h = this.h[7];
+
+                    assert(this.k.length === W.length);
+                    for (i = 0; i < W.length; i++) {
+                        var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
+                        var T2 = sum32(s0_256(a), maj32(a, b, c));
+                        h = g;
+                        g = f;
+                        f = e;
+                        e = sum32(d, T1);
+                        d = c;
+                        c = b;
+                        b = a;
+                        a = sum32(T1, T2);
+                    }
+
+                    this.h[0] = sum32(this.h[0], a);
+                    this.h[1] = sum32(this.h[1], b);
+                    this.h[2] = sum32(this.h[2], c);
+                    this.h[3] = sum32(this.h[3], d);
+                    this.h[4] = sum32(this.h[4], e);
+                    this.h[5] = sum32(this.h[5], f);
+                    this.h[6] = sum32(this.h[6], g);
+                    this.h[7] = sum32(this.h[7], h);
+                };
+
+                SHA256.prototype._digest = function digest(enc) {
+                    if (enc === 'hex')
+                        return utils.toHex32(this.h, 'big');
+                    else
+                        return utils.split32(this.h, 'big');
+                };
+
+            }, {
+                "../common": 94,
+                "../utils": 104,
+                "./common": 103,
+                "minimalistic-assert": 112
+            }],
+            101: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('../utils');
+
+                var SHA512 = require('./512');
+
+                function SHA384() {
+                    if (!(this instanceof SHA384))
+                        return new SHA384();
+
+                    SHA512.call(this);
+                    this.h = [
+                        0xcbbb9d5d, 0xc1059ed8,
+                        0x629a292a, 0x367cd507,
+                        0x9159015a, 0x3070dd17,
+                        0x152fecd8, 0xf70e5939,
+                        0x67332667, 0xffc00b31,
+                        0x8eb44a87, 0x68581511,
+                        0xdb0c2e0d, 0x64f98fa7,
+                        0x47b5481d, 0xbefa4fa4
+                    ];
+                }
+                utils.inherits(SHA384, SHA512);
+                module.exports = SHA384;
+
+                SHA384.blockSize = 1024;
+                SHA384.outSize = 384;
+                SHA384.hmacStrength = 192;
+                SHA384.padLength = 128;
+
+                SHA384.prototype._digest = function digest(enc) {
+                    if (enc === 'hex')
+                        return utils.toHex32(this.h.slice(0, 12), 'big');
+                    else
+                        return utils.split32(this.h.slice(0, 12), 'big');
+                };
+
+            }, {
+                "../utils": 104,
+                "./512": 102
+            }],
+            102: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('../utils');
+                var common = require('../common');
+                var assert = require('minimalistic-assert');
+
+                var rotr64_hi = utils.rotr64_hi;
+                var rotr64_lo = utils.rotr64_lo;
+                var shr64_hi = utils.shr64_hi;
+                var shr64_lo = utils.shr64_lo;
+                var sum64 = utils.sum64;
+                var sum64_hi = utils.sum64_hi;
+                var sum64_lo = utils.sum64_lo;
+                var sum64_4_hi = utils.sum64_4_hi;
+                var sum64_4_lo = utils.sum64_4_lo;
+                var sum64_5_hi = utils.sum64_5_hi;
+                var sum64_5_lo = utils.sum64_5_lo;
+
+                var BlockHash = common.BlockHash;
+
+                var sha512_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 SHA512() {
+                    if (!(this instanceof SHA512))
+                        return new SHA512();
+
+                    BlockHash.call(this);
+                    this.h = [
+                        0x6a09e667, 0xf3bcc908,
+                        0xbb67ae85, 0x84caa73b,
+                        0x3c6ef372, 0xfe94f82b,
+                        0xa54ff53a, 0x5f1d36f1,
+                        0x510e527f, 0xade682d1,
+                        0x9b05688c, 0x2b3e6c1f,
+                        0x1f83d9ab, 0xfb41bd6b,
+                        0x5be0cd19, 0x137e2179
+                    ];
+                    this.k = sha512_K;
+                    this.W = new Array(160);
+                }
+                utils.inherits(SHA512, BlockHash);
+                module.exports = SHA512;
+
+                SHA512.blockSize = 1024;
+                SHA512.outSize = 512;
+                SHA512.hmacStrength = 192;
+                SHA512.padLength = 128;
+
+                SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
+                    var W = this.W;
+
+                    // 32 x 32bit words
+                    for (var i = 0; i < 32; i++)
+                        W[i] = msg[start + i];
+                    for (; i < W.length; i += 2) {
+                        var c0_hi = g1_512_hi(W[i - 4], W[i - 3]); // i - 2
+                        var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
+                        var c1_hi = W[i - 14]; // i - 7
+                        var c1_lo = W[i - 13];
+                        var c2_hi = g0_512_hi(W[i - 30], W[i - 29]); // i - 15
+                        var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
+                        var c3_hi = W[i - 32]; // i - 16
+                        var c3_lo = W[i - 31];
+
+                        W[i] = sum64_4_hi(
+                            c0_hi, c0_lo,
+                            c1_hi, c1_lo,
+                            c2_hi, c2_lo,
+                            c3_hi, c3_lo);
+                        W[i + 1] = sum64_4_lo(
+                            c0_hi, c0_lo,
+                            c1_hi, c1_lo,
+                            c2_hi, c2_lo,
+                            c3_hi, c3_lo);
+                    }
+                };
+
+                SHA512.prototype._update = function _update(msg, start) {
+                    this._prepareBlock(msg, start);
+
+                    var W = this.W;
+
+                    var ah = this.h[0];
+                    var al = this.h[1];
+                    var bh = this.h[2];
+                    var bl = this.h[3];
+                    var ch = this.h[4];
+                    var cl = this.h[5];
+                    var dh = this.h[6];
+                    var dl = this.h[7];
+                    var eh = this.h[8];
+                    var el = this.h[9];
+                    var fh = this.h[10];
+                    var fl = this.h[11];
+                    var gh = this.h[12];
+                    var gl = this.h[13];
+                    var hh = this.h[14];
+                    var hl = this.h[15];
+
+                    assert(this.k.length === W.length);
+                    for (var i = 0; i < W.length; i += 2) {
+                        var c0_hi = hh;
+                        var c0_lo = hl;
+                        var c1_hi = s1_512_hi(eh, el);
+                        var c1_lo = s1_512_lo(eh, el);
+                        var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
+                        var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
+                        var c3_hi = this.k[i];
+                        var c3_lo = this.k[i + 1];
+                        var c4_hi = W[i];
+                        var c4_lo = W[i + 1];
+
+                        var T1_hi = sum64_5_hi(
+                            c0_hi, c0_lo,
+                            c1_hi, c1_lo,
+                            c2_hi, c2_lo,
+                            c3_hi, c3_lo,
+                            c4_hi, c4_lo);
+                        var T1_lo = sum64_5_lo(
+                            c0_hi, c0_lo,
+                            c1_hi, c1_lo,
+                            c2_hi, c2_lo,
+                            c3_hi, c3_lo,
+                            c4_hi, c4_lo);
+
+                        c0_hi = s0_512_hi(ah, al);
+                        c0_lo = s0_512_lo(ah, al);
+                        c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
+                        c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
+
+                        var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
+                        var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
+
+                        hh = gh;
+                        hl = gl;
+
+                        gh = fh;
+                        gl = fl;
+
+                        fh = eh;
+                        fl = el;
+
+                        eh = sum64_hi(dh, dl, T1_hi, T1_lo);
+                        el = sum64_lo(dl, dl, T1_hi, T1_lo);
+
+                        dh = ch;
+                        dl = cl;
+
+                        ch = bh;
+                        cl = bl;
+
+                        bh = ah;
+                        bl = al;
+
+                        ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
+                        al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
+                    }
+
+                    sum64(this.h, 0, ah, al);
+                    sum64(this.h, 2, bh, bl);
+                    sum64(this.h, 4, ch, cl);
+                    sum64(this.h, 6, dh, dl);
+                    sum64(this.h, 8, eh, el);
+                    sum64(this.h, 10, fh, fl);
+                    sum64(this.h, 12, gh, gl);
+                    sum64(this.h, 14, hh, hl);
+                };
+
+                SHA512.prototype._digest = function digest(enc) {
+                    if (enc === 'hex')
+                        return utils.toHex32(this.h, 'big');
+                    else
+                        return utils.split32(this.h, 'big');
+                };
+
+                function ch64_hi(xh, xl, yh, yl, zh) {
+                    var r = (xh & yh) ^ ((~xh) & zh);
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function ch64_lo(xh, xl, yh, yl, zh, zl) {
+                    var r = (xl & yl) ^ ((~xl) & zl);
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function maj64_hi(xh, xl, yh, yl, zh) {
+                    var r = (xh & yh) ^ (xh & zh) ^ (yh & zh);
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function maj64_lo(xh, xl, yh, yl, zh, zl) {
+                    var r = (xl & yl) ^ (xl & zl) ^ (yl & zl);
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function s0_512_hi(xh, xl) {
+                    var c0_hi = rotr64_hi(xh, xl, 28);
+                    var c1_hi = rotr64_hi(xl, xh, 2); // 34
+                    var c2_hi = rotr64_hi(xl, xh, 7); // 39
+
+                    var r = c0_hi ^ c1_hi ^ c2_hi;
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function s0_512_lo(xh, xl) {
+                    var c0_lo = rotr64_lo(xh, xl, 28);
+                    var c1_lo = rotr64_lo(xl, xh, 2); // 34
+                    var c2_lo = rotr64_lo(xl, xh, 7); // 39
+
+                    var r = c0_lo ^ c1_lo ^ c2_lo;
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function s1_512_hi(xh, xl) {
+                    var c0_hi = rotr64_hi(xh, xl, 14);
+                    var c1_hi = rotr64_hi(xh, xl, 18);
+                    var c2_hi = rotr64_hi(xl, xh, 9); // 41
+
+                    var r = c0_hi ^ c1_hi ^ c2_hi;
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function s1_512_lo(xh, xl) {
+                    var c0_lo = rotr64_lo(xh, xl, 14);
+                    var c1_lo = rotr64_lo(xh, xl, 18);
+                    var c2_lo = rotr64_lo(xl, xh, 9); // 41
+
+                    var r = c0_lo ^ c1_lo ^ c2_lo;
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function g0_512_hi(xh, xl) {
+                    var c0_hi = rotr64_hi(xh, xl, 1);
+                    var c1_hi = rotr64_hi(xh, xl, 8);
+                    var c2_hi = shr64_hi(xh, xl, 7);
+
+                    var r = c0_hi ^ c1_hi ^ c2_hi;
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function g0_512_lo(xh, xl) {
+                    var c0_lo = rotr64_lo(xh, xl, 1);
+                    var c1_lo = rotr64_lo(xh, xl, 8);
+                    var c2_lo = shr64_lo(xh, xl, 7);
+
+                    var r = c0_lo ^ c1_lo ^ c2_lo;
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function g1_512_hi(xh, xl) {
+                    var c0_hi = rotr64_hi(xh, xl, 19);
+                    var c1_hi = rotr64_hi(xl, xh, 29); // 61
+                    var c2_hi = shr64_hi(xh, xl, 6);
+
+                    var r = c0_hi ^ c1_hi ^ c2_hi;
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+                function g1_512_lo(xh, xl) {
+                    var c0_lo = rotr64_lo(xh, xl, 19);
+                    var c1_lo = rotr64_lo(xl, xh, 29); // 61
+                    var c2_lo = shr64_lo(xh, xl, 6);
+
+                    var r = c0_lo ^ c1_lo ^ c2_lo;
+                    if (r < 0)
+                        r += 0x100000000;
+                    return r;
+                }
+
+            }, {
+                "../common": 94,
+                "../utils": 104,
+                "minimalistic-assert": 112
+            }],
+            103: [function (require, module, exports) {
+                'use strict';
+
+                var utils = require('../utils');
+                var rotr32 = utils.rotr32;
+
+                function ft_1(s, x, y, z) {
+                    if (s === 0)
+                        return ch32(x, y, z);
+                    if (s === 1 || s === 3)
+                        return p32(x, y, z);
+                    if (s === 2)
+                        return maj32(x, y, z);
+                }
+                exports.ft_1 = ft_1;
+
+                function ch32(x, y, z) {
+                    return (x & y) ^ ((~x) & z);
+                }
+                exports.ch32 = ch32;
+
+                function maj32(x, y, z) {
+                    return (x & y) ^ (x & z) ^ (y & z);
+                }
+                exports.maj32 = maj32;
+
+                function p32(x, y, z) {
+                    return x ^ y ^ z;
+                }
+                exports.p32 = p32;
+
+                function s0_256(x) {
+                    return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
+                }
+                exports.s0_256 = s0_256;
+
+                function s1_256(x) {
+                    return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
+                }
+                exports.s1_256 = s1_256;
+
+                function g0_256(x) {
+                    return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);
+                }
+                exports.g0_256 = g0_256;
+
+                function g1_256(x) {
+                    return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);
+                }
+                exports.g1_256 = g1_256;
+
+            }, {
+                "../utils": 104
+            }],
+            104: [function (require, module, exports) {
+                'use strict';
+
+                var assert = require('minimalistic-assert');
+                var inherits = require('inherits');
+
+                exports.inherits = inherits;
+
+                function toArray(msg, enc) {
+                    if (Array.isArray(msg))
+                        return msg.slice();
+                    if (!msg)
+                        return [];
+                    var res = [];
+                    if (typeof msg === 'string') {
+                        if (!enc) {
+                            for (var i = 0; i < msg.length; i++) {
+                                var c = msg.charCodeAt(i);
+                                var hi = c >> 8;
+                                var lo = c & 0xff;
+                                if (hi)
+                                    res.push(hi, lo);
+                                else
+                                    res.push(lo);
+                            }
+                        } else if (enc === 'hex') {
+                            msg = msg.replace(/[^a-z0-9]+/ig, '');
+                            if (msg.length % 2 !== 0)
+                                msg = '0' + msg;
+                            for (i = 0; i < msg.length; i += 2)
+                                res.push(parseInt(msg[i] + msg[i + 1], 16));
+                        }
+                    } else {
+                        for (i = 0; i < msg.length; i++)
+                            res[i] = msg[i] | 0;
+                    }
+                    return res;
+                }
+                exports.toArray = toArray;
+
+                function toHex(msg) {
+                    var res = '';
+                    for (var i = 0; i < msg.length; i++)
+                        res += zero2(msg[i].toString(16));
+                    return res;
+                }
+                exports.toHex = toHex;
+
+                function htonl(w) {
+                    var res = (w >>> 24) |
+                        ((w >>> 8) & 0xff00) |
+                        ((w << 8) & 0xff0000) |
+                        ((w & 0xff) << 24);
+                    return res >>> 0;
+                }
+                exports.htonl = htonl;
+
+                function toHex32(msg, endian) {
+                    var res = '';
+                    for (var i = 0; i < msg.length; i++) {
+                        var w = msg[i];
+                        if (endian === 'little')
+                            w = htonl(w);
+                        res += zero8(w.toString(16));
+                    }
+                    return res;
+                }
+                exports.toHex32 = toHex32;
+
+                function zero2(word) {
+                    if (word.length === 1)
+                        return '0' + word;
+                    else
+                        return word;
+                }
+                exports.zero2 = zero2;
+
+                function zero8(word) {
+                    if (word.length === 7)
+                        return '0' + word;
+                    else if (word.length === 6)
+                        return '00' + word;
+                    else if (word.length === 5)
+                        return '000' + word;
+                    else if (word.length === 4)
+                        return '0000' + word;
+                    else if (word.length === 3)
+                        return '00000' + word;
+                    else if (word.length === 2)
+                        return '000000' + word;
+                    else if (word.length === 1)
+                        return '0000000' + word;
+                    else
+                        return word;
+                }
+                exports.zero8 = zero8;
+
+                function join32(msg, start, end, endian) {
+                    var len = end - start;
+                    assert(len % 4 === 0);
+                    var res = new Array(len / 4);
+                    for (var i = 0, k = start; i < res.length; i++, k += 4) {
+                        var w;
+                        if (endian === 'big')
+                            w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];
+                        else
+                            w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];
+                        res[i] = w >>> 0;
+                    }
+                    return res;
+                }
+                exports.join32 = join32;
+
+                function split32(msg, endian) {
+                    var res = new Array(msg.length * 4);
+                    for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
+                        var m = msg[i];
+                        if (endian === 'big') {
+                            res[k] = m >>> 24;
+                            res[k + 1] = (m >>> 16) & 0xff;
+                            res[k + 2] = (m >>> 8) & 0xff;
+                            res[k + 3] = m & 0xff;
+                        } else {
+                            res[k + 3] = m >>> 24;
+                            res[k + 2] = (m >>> 16) & 0xff;
+                            res[k + 1] = (m >>> 8) & 0xff;
+                            res[k] = m & 0xff;
+                        }
+                    }
+                    return res;
+                }
+                exports.split32 = split32;
+
+                function rotr32(w, b) {
+                    return (w >>> b) | (w << (32 - b));
+                }
+                exports.rotr32 = rotr32;
+
+                function rotl32(w, b) {
+                    return (w << b) | (w >>> (32 - b));
+                }
+                exports.rotl32 = rotl32;
+
+                function sum32(a, b) {
+                    return (a + b) >>> 0;
+                }
+                exports.sum32 = sum32;
+
+                function sum32_3(a, b, c) {
+                    return (a + b + c) >>> 0;
+                }
+                exports.sum32_3 = sum32_3;
+
+                function sum32_4(a, b, c, d) {
+                    return (a + b + c + d) >>> 0;
+                }
+                exports.sum32_4 = sum32_4;
+
+                function sum32_5(a, b, c, d, e) {
+                    return (a + b + c + d + e) >>> 0;
+                }
+                exports.sum32_5 = sum32_5;
+
+                function sum64(buf, pos, ah, al) {
+                    var bh = buf[pos];
+                    var bl = buf[pos + 1];
+
+                    var lo = (al + bl) >>> 0;
+                    var hi = (lo < al ? 1 : 0) + ah + bh;
+                    buf[pos] = hi >>> 0;
+                    buf[pos + 1] = lo;
+                }
+                exports.sum64 = sum64;
+
+                function sum64_hi(ah, al, bh, bl) {
+                    var lo = (al + bl) >>> 0;
+                    var hi = (lo < al ? 1 : 0) + ah + bh;
+                    return hi >>> 0;
+                }
+                exports.sum64_hi = sum64_hi;
+
+                function sum64_lo(ah, al, bh, bl) {
+                    var lo = al + bl;
+                    return lo >>> 0;
+                }
+                exports.sum64_lo = sum64_lo;
+
+                function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
+                    var carry = 0;
+                    var lo = al;
+                    lo = (lo + bl) >>> 0;
+                    carry += lo < al ? 1 : 0;
+                    lo = (lo + cl) >>> 0;
+                    carry += lo < cl ? 1 : 0;
+                    lo = (lo + dl) >>> 0;
+                    carry += lo < dl ? 1 : 0;
+
+                    var hi = ah + bh + ch + dh + carry;
+                    return hi >>> 0;
+                }
+                exports.sum64_4_hi = sum64_4_hi;
+
+                function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
+                    var lo = al + bl + cl + dl;
+                    return lo >>> 0;
+                }
+                exports.sum64_4_lo = sum64_4_lo;
+
+                function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+                    var carry = 0;
+                    var lo = al;
+                    lo = (lo + bl) >>> 0;
+                    carry += lo < al ? 1 : 0;
+                    lo = (lo + cl) >>> 0;
+                    carry += lo < cl ? 1 : 0;
+                    lo = (lo + dl) >>> 0;
+                    carry += lo < dl ? 1 : 0;
+                    lo = (lo + el) >>> 0;
+                    carry += lo < el ? 1 : 0;
+
+                    var hi = ah + bh + ch + dh + eh + carry;
+                    return hi >>> 0;
+                }
+                exports.sum64_5_hi = sum64_5_hi;
+
+                function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+                    var lo = al + bl + cl + dl + el;
+
+                    return lo >>> 0;
+                }
+                exports.sum64_5_lo = sum64_5_lo;
+
+                function rotr64_hi(ah, al, num) {
+                    var r = (al << (32 - num)) | (ah >>> num);
+                    return r >>> 0;
+                }
+                exports.rotr64_hi = rotr64_hi;
+
+                function rotr64_lo(ah, al, num) {
+                    var r = (ah << (32 - num)) | (al >>> num);
+                    return r >>> 0;
+                }
+                exports.rotr64_lo = rotr64_lo;
+
+                function shr64_hi(ah, al, num) {
+                    return ah >>> num;
+                }
+                exports.shr64_hi = shr64_hi;
+
+                function shr64_lo(ah, al, num) {
+                    var r = (ah << (32 - num)) | (al >>> num);
+                    return r >>> 0;
+                }
+                exports.shr64_lo = shr64_lo;
+
+            }, {
+                "inherits": 107,
+                "minimalistic-assert": 112
+            }],
+            105: [function (require, module, exports) {
+                'use strict';
+
+                var hash = require('hash.js');
+                var utils = require('minimalistic-crypto-utils');
+                var assert = require('minimalistic-assert');
+
+                function HmacDRBG(options) {
+                    if (!(this instanceof HmacDRBG))
+                        return new HmacDRBG(options);
+                    this.hash = options.hash;
+                    this.predResist = !!options.predResist;
+
+                    this.outLen = this.hash.outSize;
+                    this.minEntropy = options.minEntropy || this.hash.hmacStrength;
+
+                    this._reseed = null;
+                    this.reseedInterval = null;
+                    this.K = null;
+                    this.V = null;
+
+                    var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');
+                    var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');
+                    var pers = utils.toArray(options.pers, options.persEnc || 'hex');
+                    assert(entropy.length >= (this.minEntropy / 8),
+                        'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
+                    this._init(entropy, nonce, pers);
+                }
+                module.exports = HmacDRBG;
+
+                HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
+                    var seed = entropy.concat(nonce).concat(pers);
+
+                    this.K = new Array(this.outLen / 8);
+                    this.V = new Array(this.outLen / 8);
+                    for (var i = 0; i < this.V.length; i++) {
+                        this.K[i] = 0x00;
+                        this.V[i] = 0x01;
+                    }
+
+                    this._update(seed);
+                    this._reseed = 1;
+                    this.reseedInterval = 0x1000000000000; // 2^48
+                };
+
+                HmacDRBG.prototype._hmac = function hmac() {
+                    return new hash.hmac(this.hash, this.K);
+                };
+
+                HmacDRBG.prototype._update = function update(seed) {
+                    var kmac = this._hmac()
+                        .update(this.V)
+                        .update([0x00]);
+                    if (seed)
+                        kmac = kmac.update(seed);
+                    this.K = kmac.digest();
+                    this.V = this._hmac().update(this.V).digest();
+                    if (!seed)
+                        return;
+
+                    this.K = this._hmac()
+                        .update(this.V)
+                        .update([0x01])
+                        .update(seed)
+                        .digest();
+                    this.V = this._hmac().update(this.V).digest();
+                };
+
+                HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
+                    // Optional entropy enc
+                    if (typeof entropyEnc !== 'string') {
+                        addEnc = add;
+                        add = entropyEnc;
+                        entropyEnc = null;
+                    }
+
+                    entropy = utils.toArray(entropy, entropyEnc);
+                    add = utils.toArray(add, addEnc);
+
+                    assert(entropy.length >= (this.minEntropy / 8),
+                        'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
+
+                    this._update(entropy.concat(add || []));
+                    this._reseed = 1;
+                };
+
+                HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
+                    if (this._reseed > this.reseedInterval)
+                        throw new Error('Reseed is required');
+
+                    // Optional encoding
+                    if (typeof enc !== 'string') {
+                        addEnc = add;
+                        add = enc;
+                        enc = null;
+                    }
+
+                    // Optional additional data
+                    if (add) {
+                        add = utils.toArray(add, addEnc || 'hex');
+                        this._update(add);
+                    }
+
+                    var temp = [];
+                    while (temp.length < len) {
+                        this.V = this._hmac().update(this.V).digest();
+                        temp = temp.concat(this.V);
+                    }
+
+                    var res = temp.slice(0, len);
+                    this._update(add);
+                    this._reseed++;
+                    return utils.encode(res, enc);
+                };
+
+            }, {
+                "hash.js": 93,
+                "minimalistic-assert": 112,
+                "minimalistic-crypto-utils": 113
+            }],
+            106: [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
+                }
+
+            }, {}],
+            107: [function (require, module, exports) {
+                if (typeof Object.create === 'function') {
+                    // implementation from standard node.js 'util' module
+                    module.exports = function inherits(ctor, superCtor) {
+                        ctor.super_ = superCtor
+                        ctor.prototype = Object.create(superCtor.prototype, {
+                            constructor: {
+                                value: ctor,
+                                enumerable: false,
+                                writable: true,
+                                configurable: true
+                            }
+                        });
+                    };
+                } else {
+                    // old school shim for old browsers
+                    module.exports = function inherits(ctor, superCtor) {
+                        ctor.super_ = superCtor
+                        var TempCtor = function () {}
+                        TempCtor.prototype = superCtor.prototype
+                        ctor.prototype = new TempCtor()
+                        ctor.prototype.constructor = ctor
+                    }
+                }
+
+            }, {}],
+            108: [function (require, module, exports) {
+                /*!
+                * Determine if an object is a Buffer
+                *
+                * @author   Feross Aboukhadijeh <https://feross.org>
+                * @license  MIT
+                */
+
+                // The _isBuffer check is for Safari 5-7 support, because it's missing
+                // Object.prototype.constructor. Remove this eventually
+                module.exports = function (obj) {
+                    return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+                }
+
+                function isBuffer(obj) {
+                    return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor
+                        .isBuffer(obj)
+                }
+
+                // For Node v0.10 support. Remove this eventually.
+                function isSlowBuffer(obj) {
+                    return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' &&
+                        isBuffer(obj.slice(0, 0))
+                }
+
+            }, {}],
+            109: [function (require, module, exports) {
+                var toString = {}.toString;
+
+                module.exports = Array.isArray || function (arr) {
+                    return toString.call(arr) == '[object Array]';
+                };
+
+            }, {}],
+            110: [function (require, module, exports) {
+                (function (Buffer) {
+                    'use strict'
+                    var inherits = require('inherits')
+                    var HashBase = require('hash-base')
+
+                    var ARRAY16 = new Array(16)
+
+                    function MD5() {
+                        HashBase.call(this, 64)
+
+                        // state
+                        this._a = 0x67452301
+                        this._b = 0xefcdab89
+                        this._c = 0x98badcfe
+                        this._d = 0x10325476
+                    }
+
+                    inherits(MD5, HashBase)
+
+                    MD5.prototype._update = function () {
+                        var M = ARRAY16
+                        for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)
+
+                        var a = this._a
+                        var b = this._b
+                        var c = this._c
+                        var d = this._d
+
+                        a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)
+                        d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)
+                        c = fnF(c, d, a, b, M[2], 0x242070db, 17)
+                        b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)
+                        a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)
+                        d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)
+                        c = fnF(c, d, a, b, M[6], 0xa8304613, 17)
+                        b = fnF(b, c, d, a, M[7], 0xfd469501, 22)
+                        a = fnF(a, b, c, d, M[8], 0x698098d8, 7)
+                        d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)
+                        c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)
+                        b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)
+                        a = fnF(a, b, c, d, M[12], 0x6b901122, 7)
+                        d = fnF(d, a, b, c, M[13], 0xfd987193, 12)
+                        c = fnF(c, d, a, b, M[14], 0xa679438e, 17)
+                        b = fnF(b, c, d, a, M[15], 0x49b40821, 22)
+
+                        a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)
+                        d = fnG(d, a, b, c, M[6], 0xc040b340, 9)
+                        c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)
+                        b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)
+                        a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)
+                        d = fnG(d, a, b, c, M[10], 0x02441453, 9)
+                        c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)
+                        b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)
+                        a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)
+                        d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)
+                        c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)
+                        b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)
+                        a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)
+                        d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)
+                        c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)
+                        b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)
+
+                        a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)
+                        d = fnH(d, a, b, c, M[8], 0x8771f681, 11)
+                        c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)
+                        b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)
+                        a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)
+                        d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)
+                        c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)
+                        b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)
+                        a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)
+                        d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)
+                        c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)
+                        b = fnH(b, c, d, a, M[6], 0x04881d05, 23)
+                        a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)
+                        d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)
+                        c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)
+                        b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)
+
+                        a = fnI(a, b, c, d, M[0], 0xf4292244, 6)
+                        d = fnI(d, a, b, c, M[7], 0x432aff97, 10)
+                        c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)
+                        b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)
+                        a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)
+                        d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)
+                        c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)
+                        b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)
+                        a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)
+                        d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)
+                        c = fnI(c, d, a, b, M[6], 0xa3014314, 15)
+                        b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)
+                        a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)
+                        d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)
+                        c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)
+                        b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)
+
+                        this._a = (this._a + a) | 0
+                        this._b = (this._b + b) | 0
+                        this._c = (this._c + c) | 0
+                        this._d = (this._d + d) | 0
+                    }
+
+                    MD5.prototype._digest = function () {
+                        // create padding and handle blocks
+                        this._block[this._blockOffset++] = 0x80
+                        if (this._blockOffset > 56) {
+                            this._block.fill(0, this._blockOffset, 64)
+                            this._update()
+                            this._blockOffset = 0
+                        }
+
+                        this._block.fill(0, this._blockOffset, 56)
+                        this._block.writeUInt32LE(this._length[0], 56)
+                        this._block.writeUInt32LE(this._length[1], 60)
+                        this._update()
+
+                        // produce result
+                        var buffer = new Buffer(16)
+                        buffer.writeInt32LE(this._a, 0)
+                        buffer.writeInt32LE(this._b, 4)
+                        buffer.writeInt32LE(this._c, 8)
+                        buffer.writeInt32LE(this._d, 12)
+                        return buffer
+                    }
+
+                    function rotl(x, n) {
+                        return (x << n) | (x >>> (32 - n))
+                    }
+
+                    function fnF(a, b, c, d, m, k, s) {
+                        return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0
+                    }
+
+                    function fnG(a, b, c, d, m, k, s) {
+                        return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0
+                    }
+
+                    function fnH(a, b, c, d, m, k, s) {
+                        return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0
+                    }
+
+                    function fnI(a, b, c, d, m, k, s) {
+                        return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0
+                    }
+
+                    module.exports = MD5
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "buffer": 55,
+                "hash-base": 92,
+                "inherits": 107
+            }],
+            111: [function (require, module, exports) {
+                var bn = require('bn.js');
+                var brorand = require('brorand');
+
+                function MillerRabin(rand) {
+                    this.rand = rand || new brorand.Rand();
+                }
+                module.exports = MillerRabin;
+
+                MillerRabin.create = function create(rand) {
+                    return new MillerRabin(rand);
+                };
+
+                MillerRabin.prototype._randbelow = function _randbelow(n) {
+                    var len = n.bitLength();
+                    var min_bytes = Math.ceil(len / 8);
+
+                    // Generage random bytes until a number less than n is found.
+                    // This ensures that 0..n-1 have an equal probability of being selected.
+                    do
+                        var a = new bn(this.rand.generate(min_bytes));
+                    while (a.cmp(n) >= 0);
+
+                    return a;
+                };
+
+                MillerRabin.prototype._randrange = function _randrange(start, stop) {
+                    // Generate a random number greater than or equal to start and less than stop.
+                    var size = stop.sub(start);
+                    return start.add(this._randbelow(size));
+                };
+
+                MillerRabin.prototype.test = function test(n, k, cb) {
+                    var len = n.bitLength();
+                    var red = bn.mont(n);
+                    var rone = new bn(1).toRed(red);
+
+                    if (!k)
+                        k = Math.max(1, (len / 48) | 0);
+
+                    // Find d and s, (n - 1) = (2 ^ s) * d;
+                    var n1 = n.subn(1);
+                    for (var s = 0; !n1.testn(s); s++) {}
+                    var d = n.shrn(s);
+
+                    var rn1 = n1.toRed(red);
+
+                    var prime = true;
+                    for (; k > 0; k--) {
+                        var a = this._randrange(new bn(2), n1);
+                        if (cb)
+                            cb(a);
+
+                        var x = a.toRed(red).redPow(d);
+                        if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
+                            continue;
+
+                        for (var i = 1; i < s; i++) {
+                            x = x.redSqr();
+
+                            if (x.cmp(rone) === 0)
+                                return false;
+                            if (x.cmp(rn1) === 0)
+                                break;
+                        }
+
+                        if (i === s)
+                            return false;
+                    }
+
+                    return prime;
+                };
+
+                MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
+                    var len = n.bitLength();
+                    var red = bn.mont(n);
+                    var rone = new bn(1).toRed(red);
+
+                    if (!k)
+                        k = Math.max(1, (len / 48) | 0);
+
+                    // Find d and s, (n - 1) = (2 ^ s) * d;
+                    var n1 = n.subn(1);
+                    for (var s = 0; !n1.testn(s); s++) {}
+                    var d = n.shrn(s);
+
+                    var rn1 = n1.toRed(red);
+
+                    for (; k > 0; k--) {
+                        var a = this._randrange(new bn(2), n1);
+
+                        var g = n.gcd(a);
+                        if (g.cmpn(1) !== 0)
+                            return g;
+
+                        var x = a.toRed(red).redPow(d);
+                        if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
+                            continue;
+
+                        for (var i = 1; i < s; i++) {
+                            x = x.redSqr();
+
+                            if (x.cmp(rone) === 0)
+                                return x.fromRed().subn(1).gcd(n);
+                            if (x.cmp(rn1) === 0)
+                                break;
+                        }
+
+                        if (i === s) {
+                            x = x.redSqr();
+                            return x.fromRed().subn(1).gcd(n);
+                        }
+                    }
+
+                    return false;
+                };
+
+            }, {
+                "bn.js": 24,
+                "brorand": 25
+            }],
+            112: [function (require, module, exports) {
+                module.exports = assert;
+
+                function assert(val, msg) {
+                    if (!val)
+                        throw new Error(msg || 'Assertion failed');
+                }
+
+                assert.equal = function assertEqual(l, r, msg) {
+                    if (l != r)
+                        throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
+                };
+
+            }, {}],
+            113: [function (require, module, exports) {
+                'use strict';
+
+                var utils = exports;
+
+                function toArray(msg, enc) {
+                    if (Array.isArray(msg))
+                        return msg.slice();
+                    if (!msg)
+                        return [];
+                    var res = [];
+                    if (typeof msg !== 'string') {
+                        for (var i = 0; i < msg.length; i++)
+                            res[i] = msg[i] | 0;
+                        return res;
+                    }
+                    if (enc === 'hex') {
+                        msg = msg.replace(/[^a-z0-9]+/ig, '');
+                        if (msg.length % 2 !== 0)
+                            msg = '0' + msg;
+                        for (var i = 0; i < msg.length; i += 2)
+                            res.push(parseInt(msg[i] + msg[i + 1], 16));
+                    } else {
+                        for (var i = 0; i < msg.length; i++) {
+                            var c = msg.charCodeAt(i);
+                            var hi = c >> 8;
+                            var lo = c & 0xff;
+                            if (hi)
+                                res.push(hi, lo);
+                            else
+                                res.push(lo);
+                        }
+                    }
+                    return res;
+                }
+                utils.toArray = toArray;
+
+                function zero2(word) {
+                    if (word.length === 1)
+                        return '0' + word;
+                    else
+                        return word;
+                }
+                utils.zero2 = zero2;
+
+                function toHex(msg) {
+                    var res = '';
+                    for (var i = 0; i < msg.length; i++)
+                        res += zero2(msg[i].toString(16));
+                    return res;
+                }
+                utils.toHex = toHex;
+
+                utils.encode = function encode(arr, enc) {
+                    if (enc === 'hex')
+                        return toHex(arr);
+                    else
+                        return arr;
+                };
+
+            }, {}],
+            114: [function (require, module, exports) {
+                module.exports = {
+                    "2.16.840.1.101.3.4.1.1": "aes-128-ecb",
+                    "2.16.840.1.101.3.4.1.2": "aes-128-cbc",
+                    "2.16.840.1.101.3.4.1.3": "aes-128-ofb",
+                    "2.16.840.1.101.3.4.1.4": "aes-128-cfb",
+                    "2.16.840.1.101.3.4.1.21": "aes-192-ecb",
+                    "2.16.840.1.101.3.4.1.22": "aes-192-cbc",
+                    "2.16.840.1.101.3.4.1.23": "aes-192-ofb",
+                    "2.16.840.1.101.3.4.1.24": "aes-192-cfb",
+                    "2.16.840.1.101.3.4.1.41": "aes-256-ecb",
+                    "2.16.840.1.101.3.4.1.42": "aes-256-cbc",
+                    "2.16.840.1.101.3.4.1.43": "aes-256-ofb",
+                    "2.16.840.1.101.3.4.1.44": "aes-256-cfb"
+                }
+            }, {}],
+            115: [function (require, module, exports) {
+                // from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js
+                // Fedor, you are amazing.
+                'use strict'
+
+                var asn1 = require('asn1.js')
+
+                exports.certificate = require('./certificate')
+
+                var RSAPrivateKey = asn1.define('RSAPrivateKey', function () {
+                    this.seq().obj(
+                        this.key('version').int(),
+                        this.key('modulus').int(),
+                        this.key('publicExponent').int(),
+                        this.key('privateExponent').int(),
+                        this.key('prime1').int(),
+                        this.key('prime2').int(),
+                        this.key('exponent1').int(),
+                        this.key('exponent2').int(),
+                        this.key('coefficient').int()
+                    )
+                })
+                exports.RSAPrivateKey = RSAPrivateKey
+
+                var RSAPublicKey = asn1.define('RSAPublicKey', function () {
+                    this.seq().obj(
+                        this.key('modulus').int(),
+                        this.key('publicExponent').int()
+                    )
+                })
+                exports.RSAPublicKey = RSAPublicKey
+
+                var PublicKey = asn1.define('SubjectPublicKeyInfo', function () {
+                    this.seq().obj(
+                        this.key('algorithm').use(AlgorithmIdentifier),
+                        this.key('subjectPublicKey').bitstr()
+                    )
+                })
+                exports.PublicKey = PublicKey
+
+                var AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () {
+                    this.seq().obj(
+                        this.key('algorithm').objid(),
+                        this.key('none').null_().optional(),
+                        this.key('curve').objid().optional(),
+                        this.key('params').seq().obj(
+                            this.key('p').int(),
+                            this.key('q').int(),
+                            this.key('g').int()
+                        ).optional()
+                    )
+                })
+
+                var PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () {
+                    this.seq().obj(
+                        this.key('version').int(),
+                        this.key('algorithm').use(AlgorithmIdentifier),
+                        this.key('subjectPrivateKey').octstr()
+                    )
+                })
+                exports.PrivateKey = PrivateKeyInfo
+                var EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () {
+                    this.seq().obj(
+                        this.key('algorithm').seq().obj(
+                            this.key('id').objid(),
+                            this.key('decrypt').seq().obj(
+                                this.key('kde').seq().obj(
+                                    this.key('id').objid(),
+                                    this.key('kdeparams').seq().obj(
+                                        this.key('salt').octstr(),
+                                        this.key('iters').int()
+                                    )
+                                ),
+                                this.key('cipher').seq().obj(
+                                    this.key('algo').objid(),
+                                    this.key('iv').octstr()
+                                )
+                            )
+                        ),
+                        this.key('subjectPrivateKey').octstr()
+                    )
+                })
+
+                exports.EncryptedPrivateKey = EncryptedPrivateKeyInfo
+
+                var DSAPrivateKey = asn1.define('DSAPrivateKey', function () {
+                    this.seq().obj(
+                        this.key('version').int(),
+                        this.key('p').int(),
+                        this.key('q').int(),
+                        this.key('g').int(),
+                        this.key('pub_key').int(),
+                        this.key('priv_key').int()
+                    )
+                })
+                exports.DSAPrivateKey = DSAPrivateKey
+
+                exports.DSAparam = asn1.define('DSAparam', function () {
+                    this.int()
+                })
+
+                var ECPrivateKey = asn1.define('ECPrivateKey', function () {
+                    this.seq().obj(
+                        this.key('version').int(),
+                        this.key('privateKey').octstr(),
+                        this.key('parameters').optional().explicit(0).use(ECParameters),
+                        this.key('publicKey').optional().explicit(1).bitstr()
+                    )
+                })
+                exports.ECPrivateKey = ECPrivateKey
+
+                var ECParameters = asn1.define('ECParameters', function () {
+                    this.choice({
+                        namedCurve: this.objid()
+                    })
+                })
+
+                exports.signature = asn1.define('signature', function () {
+                    this.seq().obj(
+                        this.key('r').int(),
+                        this.key('s').int()
+                    )
+                })
+
+            }, {
+                "./certificate": 116,
+                "asn1.js": 9
+            }],
+            116: [function (require, module, exports) {
+                // from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js
+                // thanks to @Rantanen
+
+                'use strict'
+
+                var asn = require('asn1.js')
+
+                var Time = asn.define('Time', function () {
+                    this.choice({
+                        utcTime: this.utctime(),
+                        generalTime: this.gentime()
+                    })
+                })
+
+                var AttributeTypeValue = asn.define('AttributeTypeValue', function () {
+                    this.seq().obj(
+                        this.key('type').objid(),
+                        this.key('value').any()
+                    )
+                })
+
+                var AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () {
+                    this.seq().obj(
+                        this.key('algorithm').objid(),
+                        this.key('parameters').optional()
+                    )
+                })
+
+                var SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () {
+                    this.seq().obj(
+                        this.key('algorithm').use(AlgorithmIdentifier),
+                        this.key('subjectPublicKey').bitstr()
+                    )
+                })
+
+                var RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () {
+                    this.setof(AttributeTypeValue)
+                })
+
+                var RDNSequence = asn.define('RDNSequence', function () {
+                    this.seqof(RelativeDistinguishedName)
+                })
+
+                var Name = asn.define('Name', function () {
+                    this.choice({
+                        rdnSequence: this.use(RDNSequence)
+                    })
+                })
+
+                var Validity = asn.define('Validity', function () {
+                    this.seq().obj(
+                        this.key('notBefore').use(Time),
+                        this.key('notAfter').use(Time)
+                    )
+                })
+
+                var Extension = asn.define('Extension', function () {
+                    this.seq().obj(
+                        this.key('extnID').objid(),
+                        this.key('critical').bool().def(false),
+                        this.key('extnValue').octstr()
+                    )
+                })
+
+                var TBSCertificate = asn.define('TBSCertificate', function () {
+                    this.seq().obj(
+                        this.key('version').explicit(0).int(),
+                        this.key('serialNumber').int(),
+                        this.key('signature').use(AlgorithmIdentifier),
+                        this.key('issuer').use(Name),
+                        this.key('validity').use(Validity),
+                        this.key('subject').use(Name),
+                        this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo),
+                        this.key('issuerUniqueID').implicit(1).bitstr().optional(),
+                        this.key('subjectUniqueID').implicit(2).bitstr().optional(),
+                        this.key('extensions').explicit(3).seqof(Extension).optional()
+                    )
+                })
+
+                var X509Certificate = asn.define('X509Certificate', function () {
+                    this.seq().obj(
+                        this.key('tbsCertificate').use(TBSCertificate),
+                        this.key('signatureAlgorithm').use(AlgorithmIdentifier),
+                        this.key('signatureValue').bitstr()
+                    )
+                })
+
+                module.exports = X509Certificate
+
+            }, {
+                "asn1.js": 9
+            }],
+            117: [function (require, module, exports) {
+                (function (Buffer) {
+                    // adapted from https://github.com/apatil/pemstrip
+                    var findProc =
+                        /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r\+\/\=]+)[\n\r]+/m
+                    var startRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----/m
+                    var fullRegex =
+                        /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----([0-9A-z\n\r\+\/\=]+)-----END \1-----$/m
+                    var evp = require('evp_bytestokey')
+                    var ciphers = require('browserify-aes')
+                    module.exports = function (okey, password) {
+                        var key = okey.toString()
+                        var match = key.match(findProc)
+                        var decrypted
+                        if (!match) {
+                            var match2 = key.match(fullRegex)
+                            decrypted = new Buffer(match2[2].replace(/[\r\n]/g, ''), 'base64')
+                        } else {
+                            var suite = 'aes' + match[1]
+                            var iv = new Buffer(match[2], 'hex')
+                            var cipherText = new Buffer(match[3].replace(/[\r\n]/g, ''), 'base64')
+                            var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key
+                            var out = []
+                            var cipher = ciphers.createDecipheriv(suite, cipherKey, iv)
+                            out.push(cipher.update(cipherText))
+                            out.push(cipher.final())
+                            decrypted = Buffer.concat(out)
+                        }
+                        var tag = key.match(startRegex)[1]
+                        return {
+                            tag: tag,
+                            data: decrypted
+                        }
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "browserify-aes": 29,
+                "buffer": 55,
+                "evp_bytestokey": 91
+            }],
+            118: [function (require, module, exports) {
+                (function (Buffer) {
+                    var asn1 = require('./asn1')
+                    var aesid = require('./aesid.json')
+                    var fixProc = require('./fixProc')
+                    var ciphers = require('browserify-aes')
+                    var compat = require('pbkdf2')
+                    module.exports = parseKeys
+
+                    function parseKeys(buffer) {
+                        var password
+                        if (typeof buffer === 'object' && !Buffer.isBuffer(buffer)) {
+                            password = buffer.passphrase
+                            buffer = buffer.key
+                        }
+                        if (typeof buffer === 'string') {
+                            buffer = new Buffer(buffer)
+                        }
+
+                        var stripped = fixProc(buffer, password)
+
+                        var type = stripped.tag
+                        var data = stripped.data
+                        var subtype, ndata
+                        switch (type) {
+                            case 'CERTIFICATE':
+                                ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo
+                                // falls through
+                            case 'PUBLIC KEY':
+                                if (!ndata) {
+                                    ndata = asn1.PublicKey.decode(data, 'der')
+                                }
+                                subtype = ndata.algorithm.algorithm.join('.')
+                                switch (subtype) {
+                                    case '1.2.840.113549.1.1.1':
+                                        return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data,
+                                            'der')
+                                    case '1.2.840.10045.2.1':
+                                        ndata.subjectPrivateKey = ndata.subjectPublicKey
+                                        return {
+                                            type: 'ec',
+                                            data: ndata
+                                        }
+                                    case '1.2.840.10040.4.1':
+                                        ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey
+                                            .data, 'der')
+                                        return {
+                                            type: 'dsa',
+                                            data: ndata.algorithm.params
+                                        }
+                                    default:
+                                        throw new Error('unknown key id ' + subtype)
+                                }
+                                throw new Error('unknown key type ' + type)
+                            case 'ENCRYPTED PRIVATE KEY':
+                                data = asn1.EncryptedPrivateKey.decode(data, 'der')
+                                data = decrypt(data, password)
+                                // falls through
+                            case 'PRIVATE KEY':
+                                ndata = asn1.PrivateKey.decode(data, 'der')
+                                subtype = ndata.algorithm.algorithm.join('.')
+                                switch (subtype) {
+                                    case '1.2.840.113549.1.1.1':
+                                        return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der')
+                                    case '1.2.840.10045.2.1':
+                                        return {
+                                            curve: ndata.algorithm.curve,
+                                            privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey,
+                                                'der').privateKey
+                                        }
+                                    case '1.2.840.10040.4.1':
+                                        ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey,
+                                            'der')
+                                        return {
+                                            type: 'dsa',
+                                            params: ndata.algorithm.params
+                                        }
+                                    default:
+                                        throw new Error('unknown key id ' + subtype)
+                                }
+                                throw new Error('unknown key type ' + type)
+                            case 'RSA PUBLIC KEY':
+                                return asn1.RSAPublicKey.decode(data, 'der')
+                            case 'RSA PRIVATE KEY':
+                                return asn1.RSAPrivateKey.decode(data, 'der')
+                            case 'DSA PRIVATE KEY':
+                                return {
+                                    type: 'dsa',
+                                    params: asn1.DSAPrivateKey.decode(data, 'der')
+                                }
+                            case 'EC PRIVATE KEY':
+                                data = asn1.ECPrivateKey.decode(data, 'der')
+                                return {
+                                    curve: data.parameters.value,
+                                    privateKey: data.privateKey
+                                }
+                            default:
+                                throw new Error('unknown key type ' + type)
+                        }
+                    }
+                    parseKeys.signature = asn1.signature
+
+                    function decrypt(data, password) {
+                        var salt = data.algorithm.decrypt.kde.kdeparams.salt
+                        var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10)
+                        var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')]
+                        var iv = data.algorithm.decrypt.cipher.iv
+                        var cipherText = data.subjectPrivateKey
+                        var keylen = parseInt(algo.split('-')[1], 10) / 8
+                        var key = compat.pbkdf2Sync(password, salt, iters, keylen)
+                        var cipher = ciphers.createDecipheriv(algo, key, iv)
+                        var out = []
+                        out.push(cipher.update(cipherText))
+                        out.push(cipher.final())
+                        return Buffer.concat(out)
+                    }
+
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "./aesid.json": 114,
+                "./asn1": 115,
+                "./fixProc": 117,
+                "browserify-aes": 29,
+                "buffer": 55,
+                "pbkdf2": 119
+            }],
+            119: [function (require, module, exports) {
+                exports.pbkdf2 = require('./lib/async')
+                exports.pbkdf2Sync = require('./lib/sync')
+
+            }, {
+                "./lib/async": 120,
+                "./lib/sync": 123
+            }],
+            120: [function (require, module, exports) {
+                (function (process, global) {
+                    var checkParameters = require('./precondition')
+                    var defaultEncoding = require('./default-encoding')
+                    var sync = require('./sync')
+                    var Buffer = require('safe-buffer').Buffer
+
+                    var ZERO_BUF
+                    var subtle = global.crypto && global.crypto.subtle
+                    var toBrowser = {
+                        'sha': 'SHA-1',
+                        'sha-1': 'SHA-1',
+                        'sha1': 'SHA-1',
+                        'sha256': 'SHA-256',
+                        'sha-256': 'SHA-256',
+                        'sha384': 'SHA-384',
+                        'sha-384': 'SHA-384',
+                        'sha-512': 'SHA-512',
+                        'sha512': 'SHA-512'
+                    }
+                    var checks = []
+
+                    function checkNative(algo) {
+                        if (global.process && !global.process.browser) {
+                            return Promise.resolve(false)
+                        }
+                        if (!subtle || !subtle.importKey || !subtle.deriveBits) {
+                            return Promise.resolve(false)
+                        }
+                        if (checks[algo] !== undefined) {
+                            return checks[algo]
+                        }
+                        ZERO_BUF = ZERO_BUF || Buffer.alloc(8)
+                        var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo)
+                            .then(function () {
+                                return true
+                            }).catch(function () {
+                                return false
+                            })
+                        checks[algo] = prom
+                        return prom
+                    }
+
+                    function browserPbkdf2(password, salt, iterations, length, algo) {
+                        return subtle.importKey(
+                            'raw', password, {
+                                name: 'PBKDF2'
+                            }, false, ['deriveBits']
+                        ).then(function (key) {
+                            return subtle.deriveBits({
+                                name: 'PBKDF2',
+                                salt: salt,
+                                iterations: iterations,
+                                hash: {
+                                    name: algo
+                                }
+                            }, key, length << 3)
+                        }).then(function (res) {
+                            return Buffer.from(res)
+                        })
+                    }
+
+                    function resolvePromise(promise, callback) {
+                        promise.then(function (out) {
+                            process.nextTick(function () {
+                                callback(null, out)
+                            })
+                        }, function (e) {
+                            process.nextTick(function () {
+                                callback(e)
+                            })
+                        })
+                    }
+                    module.exports = function (password, salt, iterations, keylen, digest, callback) {
+                        if (typeof digest === 'function') {
+                            callback = digest
+                            digest = undefined
+                        }
+
+                        digest = digest || 'sha1'
+                        var algo = toBrowser[digest.toLowerCase()]
+
+                        if (!algo || typeof global.Promise !== 'function') {
+                            return process.nextTick(function () {
+                                var out
+                                try {
+                                    out = sync(password, salt, iterations, keylen, digest)
+                                } catch (e) {
+                                    return callback(e)
+                                }
+                                callback(null, out)
+                            })
+                        }
+
+                        checkParameters(password, salt, iterations, keylen)
+                        if (typeof callback !== 'function') throw new Error(
+                            'No callback provided to pbkdf2')
+                        if (!Buffer.isBuffer(password)) password = Buffer.from(password,
+                            defaultEncoding)
+                        if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding)
+
+                        resolvePromise(checkNative(algo).then(function (resp) {
+                            if (resp) return browserPbkdf2(password, salt, iterations,
+                                keylen, algo)
+
+                            return sync(password, salt, iterations, keylen, digest)
+                        }), callback)
+                    }
+
+                }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !==
+                    "undefined" ? self : typeof window !== "undefined" ? window : {})
+            }, {
+                "./default-encoding": 121,
+                "./precondition": 122,
+                "./sync": 123,
+                "_process": 125,
+                "safe-buffer": 148
+            }],
+            121: [function (require, module, exports) {
+                (function (process) {
+                    var defaultEncoding
+                    /* istanbul ignore next */
+                    if (process.browser) {
+                        defaultEncoding = 'utf-8'
+                    } else {
+                        var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10)
+
+                        defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary'
+                    }
+                    module.exports = defaultEncoding
+
+                }).call(this, require('_process'))
+            }, {
+                "_process": 125
+            }],
+            122: [function (require, module, exports) {
+                (function (Buffer) {
+                    var MAX_ALLOC = Math.pow(2, 30) - 1 // default in iojs
+
+                    function checkBuffer(buf, name) {
+                        if (typeof buf !== 'string' && !Buffer.isBuffer(buf)) {
+                            throw new TypeError(name + ' must be a buffer or string')
+                        }
+                    }
+
+                    module.exports = function (password, salt, iterations, keylen) {
+                        checkBuffer(password, 'Password')
+                        checkBuffer(salt, 'Salt')
+
+                        if (typeof iterations !== 'number') {
+                            throw new TypeError('Iterations not a number')
+                        }
+
+                        if (iterations < 0) {
+                            throw new TypeError('Bad iterations')
+                        }
+
+                        if (typeof keylen !== 'number') {
+                            throw new TypeError('Key length not a number')
+                        }
+
+                        if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) {
+                            /* eslint no-self-compare: 0 */
+                            throw new TypeError('Bad key length')
+                        }
+                    }
+
+                }).call(this, {
+                    "isBuffer": require("../../is-buffer/index.js")
+                })
+            }, {
+                "../../is-buffer/index.js": 108
+            }],
+            123: [function (require, module, exports) {
+                var md5 = require('create-hash/md5')
+                var rmd160 = require('ripemd160')
+                var sha = require('sha.js')
+
+                var checkParameters = require('./precondition')
+                var defaultEncoding = require('./default-encoding')
+                var Buffer = require('safe-buffer').Buffer
+                var ZEROS = Buffer.alloc(128)
+                var sizes = {
+                    md5: 16,
+                    sha1: 20,
+                    sha224: 28,
+                    sha256: 32,
+                    sha384: 48,
+                    sha512: 64,
+                    rmd160: 20,
+                    ripemd160: 20
+                }
+
+                function Hmac(alg, key, saltLen) {
+                    var hash = getDigest(alg)
+                    var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64
+
+                    if (key.length > blocksize) {
+                        key = hash(key)
+                    } else if (key.length < blocksize) {
+                        key = Buffer.concat([key, ZEROS], blocksize)
+                    }
+
+                    var ipad = Buffer.allocUnsafe(blocksize + sizes[alg])
+                    var opad = Buffer.allocUnsafe(blocksize + sizes[alg])
+                    for (var i = 0; i < blocksize; i++) {
+                        ipad[i] = key[i] ^ 0x36
+                        opad[i] = key[i] ^ 0x5C
+                    }
+
+                    var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4)
+                    ipad.copy(ipad1, 0, 0, blocksize)
+                    this.ipad1 = ipad1
+                    this.ipad2 = ipad
+                    this.opad = opad
+                    this.alg = alg
+                    this.blocksize = blocksize
+                    this.hash = hash
+                    this.size = sizes[alg]
+                }
+
+                Hmac.prototype.run = function (data, ipad) {
+                    data.copy(ipad, this.blocksize)
+                    var h = this.hash(ipad)
+                    h.copy(this.opad, this.blocksize)
+                    return this.hash(this.opad)
+                }
+
+                function getDigest(alg) {
+                    function shaFunc(data) {
+                        return sha(alg).update(data).digest()
+                    }
+
+                    if (alg === 'rmd160' || alg === 'ripemd160') return rmd160
+                    if (alg === 'md5') return md5
+                    return shaFunc
+                }
+
+                function pbkdf2(password, salt, iterations, keylen, digest) {
+                    checkParameters(password, salt, iterations, keylen)
+
+                    if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding)
+                    if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding)
+
+                    digest = digest || 'sha1'
+
+                    var hmac = new Hmac(digest, password, salt.length)
+
+                    var DK = Buffer.allocUnsafe(keylen)
+                    var block1 = Buffer.allocUnsafe(salt.length + 4)
+                    salt.copy(block1, 0, 0, salt.length)
+
+                    var destPos = 0
+                    var hLen = sizes[digest]
+                    var l = Math.ceil(keylen / hLen)
+
+                    for (var i = 1; i <= l; i++) {
+                        block1.writeUInt32BE(i, salt.length)
+
+                        var T = hmac.run(block1, hmac.ipad1)
+                        var U = T
+
+                        for (var j = 1; j < iterations; j++) {
+                            U = hmac.run(U, hmac.ipad2)
+                            for (var k = 0; k < hLen; k++) T[k] ^= U[k]
+                        }
+
+                        T.copy(DK, destPos)
+                        destPos += hLen
+                    }
+
+                    return DK
+                }
+
+                module.exports = pbkdf2
+
+            }, {
+                "./default-encoding": 121,
+                "./precondition": 122,
+                "create-hash/md5": 60,
+                "ripemd160": 147,
+                "safe-buffer": 148,
+                "sha.js": 150
+            }],
+            124: [function (require, module, exports) {
+                (function (process) {
+                    'use strict';
+
+                    if (!process.version ||
+                        process.version.indexOf('v0.') === 0 ||
+                        process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+                        module.exports = {
+                            nextTick: nextTick
+                        };
+                    } else {
+                        module.exports = process
+                    }
+
+                    function nextTick(fn, arg1, arg2, arg3) {
+                        if (typeof fn !== 'function') {
+                            throw new TypeError('"callback" argument must be a function');
+                        }
+                        var len = arguments.length;
+                        var args, i;
+                        switch (len) {
+                            case 0:
+                            case 1:
+                                return process.nextTick(fn);
+                            case 2:
+                                return process.nextTick(function afterTickOne() {
+                                    fn.call(null, arg1);
+                                });
+                            case 3:
+                                return process.nextTick(function afterTickTwo() {
+                                    fn.call(null, arg1, arg2);
+                                });
+                            case 4:
+                                return process.nextTick(function afterTickThree() {
+                                    fn.call(null, arg1, arg2, arg3);
+                                });
+                            default:
+                                args = new Array(len - 1);
+                                i = 0;
+                                while (i < args.length) {
+                                    args[i++] = arguments[i];
+                                }
+                                return process.nextTick(function afterTick() {
+                                    fn.apply(null, args);
+                                });
+                        }
+                    }
+
+
+                }).call(this, require('_process'))
+            }, {
+                "_process": 125
+            }],
+            125: [function (require, module, exports) {
+                // shim for using process in browser
+                var process = module.exports = {};
+
+                // cached from whatever global is present so that test runners that stub it
+                // don't break things.  But we need to wrap it in a try catch in case it is
+                // wrapped in strict mode code which doesn't define any globals.  It's inside a
+                // function because try/catches deoptimize in certain engines.
+
+                var cachedSetTimeout;
+                var cachedClearTimeout;
+
+                function defaultSetTimout() {
+                    throw new Error('setTimeout has not been defined');
+                }
+
+                function defaultClearTimeout() {
+                    throw new Error('clearTimeout has not been defined');
+                }
+                (function () {
+                    try {
+                        if (typeof setTimeout === 'function') {
+                            cachedSetTimeout = setTimeout;
+                        } else {
+                            cachedSetTimeout = defaultSetTimout;
+                        }
+                    } catch (e) {
+                        cachedSetTimeout = defaultSetTimout;
+                    }
+                    try {
+                        if (typeof clearTimeout === 'function') {
+                            cachedClearTimeout = clearTimeout;
+                        } else {
+                            cachedClearTimeout = defaultClearTimeout;
+                        }
+                    } catch (e) {
+                        cachedClearTimeout = defaultClearTimeout;
+                    }
+                }())
+
+                function runTimeout(fun) {
+                    if (cachedSetTimeout === setTimeout) {
+                        //normal enviroments in sane situations
+                        return setTimeout(fun, 0);
+                    }
+                    // if setTimeout wasn't available but was latter defined
+                    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+                        cachedSetTimeout = setTimeout;
+                        return setTimeout(fun, 0);
+                    }
+                    try {
+                        // when when somebody has screwed with setTimeout but no I.E. maddness
+                        return cachedSetTimeout(fun, 0);
+                    } catch (e) {
+                        try {
+                            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+                            return cachedSetTimeout.call(null, fun, 0);
+                        } catch (e) {
+                            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+                            return cachedSetTimeout.call(this, fun, 0);
+                        }
+                    }
+
+
+                }
+
+                function runClearTimeout(marker) {
+                    if (cachedClearTimeout === clearTimeout) {
+                        //normal enviroments in sane situations
+                        return clearTimeout(marker);
+                    }
+                    // if clearTimeout wasn't available but was latter defined
+                    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+                        cachedClearTimeout = clearTimeout;
+                        return clearTimeout(marker);
+                    }
+                    try {
+                        // when when somebody has screwed with setTimeout but no I.E. maddness
+                        return cachedClearTimeout(marker);
+                    } catch (e) {
+                        try {
+                            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+                            return cachedClearTimeout.call(null, marker);
+                        } catch (e) {
+                            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+                            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+                            return cachedClearTimeout.call(this, marker);
+                        }
+                    }
+
+
+
+                }
+                var queue = [];
+                var draining = false;
+                var currentQueue;
+                var queueIndex = -1;
+
+                function cleanUpNextTick() {
+                    if (!draining || !currentQueue) {
+                        return;
+                    }
+                    draining = false;
+                    if (currentQueue.length) {
+                        queue = currentQueue.concat(queue);
+                    } else {
+                        queueIndex = -1;
+                    }
+                    if (queue.length) {
+                        drainQueue();
+                    }
+                }
+
+                function drainQueue() {
+                    if (draining) {
+                        return;
+                    }
+                    var timeout = runTimeout(cleanUpNextTick);
+                    draining = true;
+
+                    var len = queue.length;
+                    while (len) {
+                        currentQueue = queue;
+                        queue = [];
+                        while (++queueIndex < len) {
+                            if (currentQueue) {
+                                currentQueue[queueIndex].run();
+                            }
+                        }
+                        queueIndex = -1;
+                        len = queue.length;
+                    }
+                    currentQueue = null;
+                    draining = false;
+                    runClearTimeout(timeout);
+                }
+
+                process.nextTick = function (fun) {
+                    var args = new Array(arguments.length - 1);
+                    if (arguments.length > 1) {
+                        for (var i = 1; i < arguments.length; i++) {
+                            args[i - 1] = arguments[i];
+                        }
+                    }
+                    queue.push(new Item(fun, args));
+                    if (queue.length === 1 && !draining) {
+                        runTimeout(drainQueue);
+                    }
+                };
+
+                // v8 likes predictible objects
+                function Item(fun, array) {
+                    this.fun = fun;
+                    this.array = array;
+                }
+                Item.prototype.run = function () {
+                    this.fun.apply(null, this.array);
+                };
+                process.title = 'browser';
+                process.browser = true;
+                process.env = {};
+                process.argv = [];
+                process.version = ''; // empty string to avoid regexp issues
+                process.versions = {};
+
+                function noop() {}
+
+                process.on = noop;
+                process.addListener = noop;
+                process.once = noop;
+                process.off = noop;
+                process.removeListener = noop;
+                process.removeAllListeners = noop;
+                process.emit = noop;
+                process.prependListener = noop;
+                process.prependOnceListener = noop;
+
+                process.listeners = function (name) {
+                    return []
+                }
+
+                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;
+                };
+
+            }, {}],
+            126: [function (require, module, exports) {
+                exports.publicEncrypt = require('./publicEncrypt');
+                exports.privateDecrypt = require('./privateDecrypt');
+
+                exports.privateEncrypt = function privateEncrypt(key, buf) {
+                    return exports.publicEncrypt(key, buf, true);
+                };
+
+                exports.publicDecrypt = function publicDecrypt(key, buf) {
+                    return exports.privateDecrypt(key, buf, true);
+                };
+            }, {
+                "./privateDecrypt": 128,
+                "./publicEncrypt": 129
+            }],
+            127: [function (require, module, exports) {
+                (function (Buffer) {
+                    var createHash = require('create-hash');
+                    module.exports = function (seed, len) {
+                        var t = new Buffer('');
+                        var i = 0,
+                            c;
+                        while (t.length < len) {
+                            c = i2ops(i++);
+                            t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()]);
+                        }
+                        return t.slice(0, len);
+                    };
+
+                    function i2ops(c) {
+                        var out = new Buffer(4);
+                        out.writeUInt32BE(c, 0);
+                        return out;
+                    }
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "buffer": 55,
+                "create-hash": 59
+            }],
+            128: [function (require, module, exports) {
+                (function (Buffer) {
+                    var parseKeys = require('parse-asn1');
+                    var mgf = require('./mgf');
+                    var xor = require('./xor');
+                    var bn = require('bn.js');
+                    var crt = require('browserify-rsa');
+                    var createHash = require('create-hash');
+                    var withPublic = require('./withPublic');
+                    module.exports = function privateDecrypt(private_key, enc, reverse) {
+                        var padding;
+                        if (private_key.padding) {
+                            padding = private_key.padding;
+                        } else if (reverse) {
+                            padding = 1;
+                        } else {
+                            padding = 4;
+                        }
+
+                        var key = parseKeys(private_key);
+                        var k = key.modulus.byteLength();
+                        if (enc.length > k || new bn(enc).cmp(key.modulus) >= 0) {
+                            throw new Error('decryption error');
+                        }
+                        var msg;
+                        if (reverse) {
+                            msg = withPublic(new bn(enc), key);
+                        } else {
+                            msg = crt(enc, key);
+                        }
+                        var zBuffer = new Buffer(k - msg.length);
+                        zBuffer.fill(0);
+                        msg = Buffer.concat([zBuffer, msg], k);
+                        if (padding === 4) {
+                            return oaep(key, msg);
+                        } else if (padding === 1) {
+                            return pkcs1(key, msg, reverse);
+                        } else if (padding === 3) {
+                            return msg;
+                        } else {
+                            throw new Error('unknown padding');
+                        }
+                    };
+
+                    function oaep(key, msg) {
+                        var n = key.modulus;
+                        var k = key.modulus.byteLength();
+                        var mLen = msg.length;
+                        var iHash = createHash('sha1').update(new Buffer('')).digest();
+                        var hLen = iHash.length;
+                        var hLen2 = 2 * hLen;
+                        if (msg[0] !== 0) {
+                            throw new Error('decryption error');
+                        }
+                        var maskedSeed = msg.slice(1, hLen + 1);
+                        var maskedDb = msg.slice(hLen + 1);
+                        var seed = xor(maskedSeed, mgf(maskedDb, hLen));
+                        var db = xor(maskedDb, mgf(seed, k - hLen - 1));
+                        if (compare(iHash, db.slice(0, hLen))) {
+                            throw new Error('decryption error');
+                        }
+                        var i = hLen;
+                        while (db[i] === 0) {
+                            i++;
+                        }
+                        if (db[i++] !== 1) {
+                            throw new Error('decryption error');
+                        }
+                        return db.slice(i);
+                    }
+
+                    function pkcs1(key, msg, reverse) {
+                        var p1 = msg.slice(0, 2);
+                        var i = 2;
+                        var status = 0;
+                        while (msg[i++] !== 0) {
+                            if (i >= msg.length) {
+                                status++;
+                                break;
+                            }
+                        }
+                        var ps = msg.slice(2, i - 1);
+                        var p2 = msg.slice(i - 1, i);
+
+                        if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !==
+                                '0001' && reverse)) {
+                            status++;
+                        }
+                        if (ps.length < 8) {
+                            status++;
+                        }
+                        if (status) {
+                            throw new Error('decryption error');
+                        }
+                        return msg.slice(i);
+                    }
+
+                    function compare(a, b) {
+                        a = new Buffer(a);
+                        b = new Buffer(b);
+                        var dif = 0;
+                        var len = a.length;
+                        if (a.length !== b.length) {
+                            dif++;
+                            len = Math.min(a.length, b.length);
+                        }
+                        var i = -1;
+                        while (++i < len) {
+                            dif += (a[i] ^ b[i]);
+                        }
+                        return dif;
+                    }
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "./mgf": 127,
+                "./withPublic": 130,
+                "./xor": 131,
+                "bn.js": 24,
+                "browserify-rsa": 47,
+                "buffer": 55,
+                "create-hash": 59,
+                "parse-asn1": 118
+            }],
+            129: [function (require, module, exports) {
+                (function (Buffer) {
+                    var parseKeys = require('parse-asn1');
+                    var randomBytes = require('randombytes');
+                    var createHash = require('create-hash');
+                    var mgf = require('./mgf');
+                    var xor = require('./xor');
+                    var bn = require('bn.js');
+                    var withPublic = require('./withPublic');
+                    var crt = require('browserify-rsa');
+
+                    var constants = {
+                        RSA_PKCS1_OAEP_PADDING: 4,
+                        RSA_PKCS1_PADDIN: 1,
+                        RSA_NO_PADDING: 3
+                    };
+
+                    module.exports = function publicEncrypt(public_key, msg, reverse) {
+                        var padding;
+                        if (public_key.padding) {
+                            padding = public_key.padding;
+                        } else if (reverse) {
+                            padding = 1;
+                        } else {
+                            padding = 4;
+                        }
+                        var key = parseKeys(public_key);
+                        var paddedMsg;
+                        if (padding === 4) {
+                            paddedMsg = oaep(key, msg);
+                        } else if (padding === 1) {
+                            paddedMsg = pkcs1(key, msg, reverse);
+                        } else if (padding === 3) {
+                            paddedMsg = new bn(msg);
+                            if (paddedMsg.cmp(key.modulus) >= 0) {
+                                throw new Error('data too long for modulus');
+                            }
+                        } else {
+                            throw new Error('unknown padding');
+                        }
+                        if (reverse) {
+                            return crt(paddedMsg, key);
+                        } else {
+                            return withPublic(paddedMsg, key);
+                        }
+                    };
+
+                    function oaep(key, msg) {
+                        var k = key.modulus.byteLength();
+                        var mLen = msg.length;
+                        var iHash = createHash('sha1').update(new Buffer('')).digest();
+                        var hLen = iHash.length;
+                        var hLen2 = 2 * hLen;
+                        if (mLen > k - hLen2 - 2) {
+                            throw new Error('message too long');
+                        }
+                        var ps = new Buffer(k - mLen - hLen2 - 2);
+                        ps.fill(0);
+                        var dblen = k - hLen - 1;
+                        var seed = randomBytes(hLen);
+                        var maskedDb = xor(Buffer.concat([iHash, ps, new Buffer([1]), msg], dblen), mgf(
+                            seed, dblen));
+                        var maskedSeed = xor(seed, mgf(maskedDb, hLen));
+                        return new bn(Buffer.concat([new Buffer([0]), maskedSeed, maskedDb], k));
+                    }
+
+                    function pkcs1(key, msg, reverse) {
+                        var mLen = msg.length;
+                        var k = key.modulus.byteLength();
+                        if (mLen > k - 11) {
+                            throw new Error('message too long');
+                        }
+                        var ps;
+                        if (reverse) {
+                            ps = new Buffer(k - mLen - 3);
+                            ps.fill(0xff);
+                        } else {
+                            ps = nonZero(k - mLen - 3);
+                        }
+                        return new bn(Buffer.concat([new Buffer([0, reverse ? 1 : 2]), ps, new Buffer([
+                            0
+                        ]), msg], k));
+                    }
+
+                    function nonZero(len, crypto) {
+                        var out = new Buffer(len);
+                        var i = 0;
+                        var cache = randomBytes(len * 2);
+                        var cur = 0;
+                        var num;
+                        while (i < len) {
+                            if (cur === cache.length) {
+                                cache = randomBytes(len * 2);
+                                cur = 0;
+                            }
+                            num = cache[cur++];
+                            if (num) {
+                                out[i++] = num;
+                            }
+                        }
+                        return out;
+                    }
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "./mgf": 127,
+                "./withPublic": 130,
+                "./xor": 131,
+                "bn.js": 24,
+                "browserify-rsa": 47,
+                "buffer": 55,
+                "create-hash": 59,
+                "parse-asn1": 118,
+                "randombytes": 132
+            }],
+            130: [function (require, module, exports) {
+                (function (Buffer) {
+                    var bn = require('bn.js');
+
+                    function withPublic(paddedMsg, key) {
+                        return new Buffer(paddedMsg
+                            .toRed(bn.mont(key.modulus))
+                            .redPow(new bn(key.publicExponent))
+                            .fromRed()
+                            .toArray());
+                    }
+
+                    module.exports = withPublic;
+                }).call(this, require("buffer").Buffer)
+            }, {
+                "bn.js": 24,
+                "buffer": 55
+            }],
+            131: [function (require, module, exports) {
+                module.exports = function xor(a, b) {
+                    var len = a.length;
+                    var i = -1;
+                    while (++i < len) {
+                        a[i] ^= b[i];
+                    }
+                    return a
+                };
+            }, {}],
+            132: [function (require, module, exports) {
+                arguments[4][6][0].apply(exports, arguments)
+            }, {
+                "_process": 125,
+                "dup": 6,
+                "safe-buffer": 148
+            }],
+            133: [function (require, module, exports) {
+                (function (process, global) {
+                    'use strict'
+
+                    function oldBrowser() {
+                        throw new Error(
+                            'secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11'
+                        )
+                    }
+                    var safeBuffer = require('safe-buffer')
+                    var randombytes = require('randombytes')
+                    var Buffer = safeBuffer.Buffer
+                    var kBufferMaxLength = safeBuffer.kMaxLength
+                    var crypto = global.crypto || global.msCrypto
+                    var kMaxUint32 = Math.pow(2, 32) - 1
+
+                    function assertOffset(offset, length) {
+                        if (typeof offset !== 'number' || offset !== offset) { // eslint-disable-line no-self-compare
+                            throw new TypeError('offset must be a number')
+                        }
+
+                        if (offset > kMaxUint32 || offset < 0) {
+                            throw new TypeError('offset must be a uint32')
+                        }
+
+                        if (offset > kBufferMaxLength || offset > length) {
+                            throw new RangeError('offset out of range')
+                        }
+                    }
+
+                    function assertSize(size, offset, length) {
+                        if (typeof size !== 'number' || size !== size) { // eslint-disable-line no-self-compare
+                            throw new TypeError('size must be a number')
+                        }
+
+                        if (size > kMaxUint32 || size < 0) {
+                            throw new TypeError('size must be a uint32')
+                        }
+
+                        if (size + offset > length || size > kBufferMaxLength) {
+                            throw new RangeError('buffer too small')
+                        }
+                    }
+                    if ((crypto && crypto.getRandomValues) || !process.browser) {
+                        exports.randomFill = randomFill
+                        exports.randomFillSync = randomFillSync
+                    } else {
+                        exports.randomFill = oldBrowser
+                        exports.randomFillSync = oldBrowser
+                    }
+
+                    function randomFill(buf, offset, size, cb) {
+                        if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
+                            throw new TypeError('"buf" argument must be a Buffer or Uint8Array')
+                        }
+
+                        if (typeof offset === 'function') {
+                            cb = offset
+                            offset = 0
+                            size = buf.length
+                        } else if (typeof size === 'function') {
+                            cb = size
+                            size = buf.length - offset
+                        } else if (typeof cb !== 'function') {
+                            throw new TypeError('"cb" argument must be a function')
+                        }
+                        assertOffset(offset, buf.length)
+                        assertSize(size, offset, buf.length)
+                        return actualFill(buf, offset, size, cb)
+                    }
+
+                    function actualFill(buf, offset, size, cb) {
+                        if (process.browser) {
+                            var ourBuf = buf.buffer
+                            var uint = new Uint8Array(ourBuf, offset, size)
+                            crypto.getRandomValues(uint)
+                            if (cb) {
+                                process.nextTick(function () {
+                                    cb(null, buf)
+                                })
+                                return
+                            }
+                            return buf
+                        }
+                        if (cb) {
+                            randombytes(size, function (err, bytes) {
+                                if (err) {
+                                    return cb(err)
+                                }
+                                bytes.copy(buf, offset)
+                                cb(null, buf)
+                            })
+                            return
+                        }
+                        var bytes = randombytes(size)
+                        bytes.copy(buf, offset)
+                        return buf
+                    }
+
+                    function randomFillSync(buf, offset, size) {
+                        if (typeof offset === 'undefined') {
+                            offset = 0
+                        }
+                        if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
+                            throw new TypeError('"buf" argument must be a Buffer or Uint8Array')
+                        }
+
+                        assertOffset(offset, buf.length)
+
+                        if (size === undefined) size = buf.length - offset
+
+                        assertSize(size, offset, buf.length)
+
+                        return actualFill(buf, offset, size)
+                    }
+
+                }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !==
+                    "undefined" ? self : typeof window !== "undefined" ? window : {})
+            }, {
+                "_process": 125,
+                "randombytes": 132,
+                "safe-buffer": 148
+            }],
+            134: [function (require, module, exports) {
+                module.exports = require('./lib/_stream_duplex.js');
+
+            }, {
+                "./lib/_stream_duplex.js": 135
+            }],
+            135: [function (require, module, exports) {
+                // Copyright Joyent, Inc. and other Node contributors.
+                //
+                // Permission is hereby granted, free of charge, to any person obtaining a
+                // copy of this software and associated documentation files (the
+                // "Software"), to deal in the Software without restriction, including
+                // without limitation the rights to use, copy, modify, merge, publish,
+                // distribute, sublicense, and/or sell copies of the Software, and to permit
+                // persons to whom the Software is furnished to do so, subject to the
+                // following conditions:
+                //
+                // The above copyright notice and this permission notice shall be included
+                // in all copies or substantial portions of the Software.
+                //
+                // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                // a duplex stream is just a stream that is both readable and writable.
+                // Since JS doesn't have multiple prototypal inheritance, this class
+                // prototypally inherits from Readable, and then parasitically from
+                // Writable.
+
+                'use strict';
+
+                /*<replacement>*/
+
+                var pna = require('process-nextick-args');
+                /*</replacement>*/
+
+                /*<replacement>*/
+                var objectKeys = Object.keys || function (obj) {
+                    var keys = [];
+                    for (var key in obj) {
+                        keys.push(key);
+                    }
+                    return keys;
+                };
+                /*</replacement>*/
+
+                module.exports = Duplex;
+
+                /*<replacement>*/
+                var util = require('core-util-is');
+                util.inherits = require('inherits');
+                /*</replacement>*/
+
+                var Readable = require('./_stream_readable');
+                var Writable = require('./_stream_writable');
+
+                util.inherits(Duplex, Readable);
+
+                {
+                    // avoid scope creep, the keys array can then be collected
+                    var keys = objectKeys(Writable.prototype);
+                    for (var v = 0; v < keys.length; v++) {
+                        var method = keys[v];
+                        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+                    }
+                }
+
+                function Duplex(options) {
+                    if (!(this instanceof Duplex)) return new Duplex(options);
+
+                    Readable.call(this, options);
+                    Writable.call(this, options);
+
+                    if (options && options.readable === false) this.readable = false;
+
+                    if (options && options.writable === false) this.writable = false;
+
+                    this.allowHalfOpen = true;
+                    if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+
+                    this.once('end', onend);
+                }
+
+                Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
+                    // making it explicit this property is not enumerable
+                    // because otherwise some prototype manipulation in
+                    // userland will fail
+                    enumerable: false,
+                    get: function () {
+                        return this._writableState.highWaterMark;
+                    }
                 });
-            } else if (data.request && data.request.ping) {
-                self.emit('ping', data.request.ping, data.sender, function (error, response) {
-                    if (error)
-                        return connection.end();
-                    if (responseCallback)
-                        responseCallback(response);
+
+                // the no-half-open enforcer
+                function onend() {
+                    // if we allow half-open state, or if the writable side ended,
+                    // then we're ok.
+                    if (this.allowHalfOpen || this._writableState.ended) return;
+
+                    // no more data can be written.
+                    // But allow more writes to happen in this tick.
+                    pna.nextTick(onEndNT, this);
+                }
+
+                function onEndNT(self) {
+                    self.end();
+                }
+
+                Object.defineProperty(Duplex.prototype, 'destroyed', {
+                    get: function () {
+                        if (this._readableState === undefined || this._writableState ===
+                            undefined) {
+                            return false;
+                        }
+                        return this._readableState.destroyed && this._writableState.destroyed;
+                    },
+                    set: function (value) {
+                        // we ignore the value if the stream
+                        // has not been initialized yet
+                        if (this._readableState === undefined || this._writableState ===
+                            undefined) {
+                            return;
+                        }
+
+                        // backward compatibility, the user is explicitly
+                        // managing destroyed
+                        this._readableState.destroyed = value;
+                        this._writableState.destroyed = value;
+                    }
                 });
-            } else {
-                return connection.end(); // kill connection
-            }
-        });
-        connection.on('end', function () {
-            responseCallback = undefined;
-        });
-        connection.on('error', function (error) {
-            responseCallback = undefined;
-        });
-    });
-    self.server.listen(self.port, self.host, callback);
-};
-
-/*
-  * `contact`: _Object_ Contact to ping.
-    * `id`: _String (base64)_ Base64 encoded contact node id.
-    * `transport`: _Object_ TCP transport data.
-      * `host`: _String_ Host to connect to.
-      * `port`: _Integer_ Port to connect to.
-  * `sender`: _Object_ The contact making the request.
-    * `id`: _String (base64)_ Base64 encoded sender node id.
-    * `data`: _Any_ Sender node data.
-    * `transport`: _Object_ TCP transport data.
-      * `host`: _String_ Host of the sender.
-      * `port`: _Integer_ Port of the sender.
-*/
-TcpTransport.prototype.ping = function ping (contact, sender) {
-    var self = this;
-    self.rpc(contact, {
-        request: {
-            ping: contact.id
-        },
-        sender: sender
-    }, function(error, data) {
-        if (error || !data)
-            return self.emit('unreachable', contact);
-
-        try {
-            data = JSON.parse(data);
-            if (data.id === undefined || data.transport === undefined
-                || data.transport.host === undefined
-                || data.transport.port === undefined) { // data.data is optional
-                return self.emit('unreachable', contact);
-            }
-            return self.emit('reached', contact);
-        } catch (exception) {
-            // console.dir(exception);
-            return self.emit('unreachable', contact);
-        }
-    });
-};
-
-/*
-  * `contact`: _Object_ Contact to ping.
-    * `id`: _String (base64)_ Base64 encoded contact node id.
-    * `transport`: _Object_ TCP transport data.
-      * `host`: _String_ Host to connect to.
-      * `port`: _Integer_ Port to connect to.
-  * `payload`: _String_ or _Object_ Payload to send on the wire. If an _Object_
-      is provided, it will be `JSON.stringify()`'ed.
-  * `callback`: _Function_ Callback to call with an error or response.
-*/
-TcpTransport.prototype.rpc = function rpc (contact, payload, callback) {
-    var self = this;
-    var client = net.connect(
-        {
-            host: contact.transport.host,
-            port: contact.transport.port
-        },
-        function () {
-            if (typeof payload != "string")
-                payload = JSON.stringify(payload);
-            client.write(payload + '\r\n');
-        });
-
-    var hasError = false;
-    var data = "";
-    client.on('data', function (buf) {
-        data += buf.toString("utf8");
-    });
-    client.on('end', function () {
-        if (!hasError)
-            callback(null, data);
-    });
-    client.on('error', function (error) {
-        hasError = true;
-        callback(error);
-    });
-};
-
-/*
-  * `contact`: _Object_ A contact.
-  * Return: _Object_ `contact` with `contact.transport` populated.
-*/
-TcpTransport.prototype.setTransportInfo = function setTransportInfo(contact) {
-    var self = this;
-
-    contact.transport = {
-        host: self.host,
-        port: self.port
-    };
-    return contact;
-};
-
-},{"events":90,"net":8,"util":162}],4:[function(require,module,exports){
-/*
-index.js - Kademlia DHT K-bucket implementation as a binary tree.
-
-The MIT License (MIT)
-
-Copyright (c) 2013-2018 Tristan Slominski
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-'use strict'
-
-const randomBytes = require('randombytes')
-const { EventEmitter } = require('events')
-
-/**
- * @param  {Uint8Array} array1
- * @param  {Uint8Array} array2
- * @return {Boolean}
- */
-function arrayEquals (array1, array2) {
-  if (array1 === array2) {
-    return true
-  }
-  if (array1.length !== array2.length) {
-    return false
-  }
-  for (let i = 0, length = array1.length; i < length; ++i) {
-    if (array1[i] !== array2[i]) {
-      return false
-    }
-  }
-  return true
-}
-
-function createNode () {
-  return { contacts: [], dontSplit: false, left: null, right: null }
-}
-
-function ensureInt8 (name, val) {
-  if (!(val instanceof Uint8Array)) {
-    throw new TypeError(name + ' is not a Uint8Array')
-  }
-}
-
-/**
- * Implementation of a Kademlia DHT k-bucket used for storing
- * contact (peer node) information.
- *
- * @extends EventEmitter
- */
-class KBucket extends EventEmitter {
-  /**
-   * `options`:
-   *   `distance`: _Function_
-   *     `function (firstId, secondId) { return distance }` An optional
-   *     `distance` function that gets two `id` Uint8Arrays
-   *     and return distance (as number) between them.
-   *   `arbiter`: _Function_ _(Default: vectorClock arbiter)_
-   *     `function (incumbent, candidate) { return contact; }` An optional
-   *     `arbiter` function that givent two `contact` objects with the same `id`
-   *     returns the desired object to be used for updating the k-bucket. For
-   *     more details, see [arbiter function](#arbiter-function).
-   *   `localNodeId`: _Uint8Array_ An optional Uint8Array representing the local node id.
-   *     If not provided, a local node id will be created via `randomBytes(20)`.
-   *     `metadata`: _Object_ _(Default: {})_ Optional satellite data to include
-   *     with the k-bucket. `metadata` property is guaranteed not be altered by,
-   *     it is provided as an explicit container for users of k-bucket to store
-   *     implementation-specific data.
-   *   `numberOfNodesPerKBucket`: _Integer_ _(Default: 20)_ The number of nodes
-   *     that a k-bucket can contain before being full or split.
-   *     `numberOfNodesToPing`: _Integer_ _(Default: 3)_ The number of nodes to
-   *     ping when a bucket that should not be split becomes full. KBucket will
-   *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
-   *     not been contacted the longest.
-   *
-   * @param {Object=} options optional
-   */
-  constructor (options = {}) {
-    super()
-
-    this.localNodeId = options.localNodeId || randomBytes(20)
-    this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
-    this.numberOfNodesToPing = options.numberOfNodesToPing || 3
-    this.distance = options.distance || KBucket.distance
-    // use an arbiter from options or vectorClock arbiter by default
-    this.arbiter = options.arbiter || KBucket.arbiter
-    this.metadata = Object.assign({}, options.metadata)
-
-    ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
-
-    this.root = createNode()
-  }
-
-  /**
-   * Default arbiter function for contacts with the same id. Uses
-   * contact.vectorClock to select which contact to update the k-bucket with.
-   * Contact with larger vectorClock field will be selected. If vectorClock is
-   * the same, candidat will be selected.
-   *
-   * @param  {Object} incumbent Contact currently stored in the k-bucket.
-   * @param  {Object} candidate Contact being added to the k-bucket.
-   * @return {Object}           Contact to updated the k-bucket with.
-   */
-  static arbiter (incumbent, candidate) {
-    return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
-  }
-
-  /**
-   * Default distance function. Finds the XOR
-   * distance between firstId and secondId.
-   *
-   * @param  {Uint8Array} firstId  Uint8Array containing first id.
-   * @param  {Uint8Array} secondId Uint8Array containing second id.
-   * @return {Number}              Integer The XOR distance between firstId
-   *                               and secondId.
-   */
-  static distance (firstId, secondId) {
-    let distance = 0
-    let i = 0
-    const min = Math.min(firstId.length, secondId.length)
-    const max = Math.max(firstId.length, secondId.length)
-    for (; i < min; ++i) {
-      distance = distance * 256 + (firstId[i] ^ secondId[i])
-    }
-    for (; i < max; ++i) distance = distance * 256 + 255
-    return distance
-  }
-
-  /**
-   * Adds a contact to the k-bucket.
-   *
-   * @param {Object} contact the contact object to add
-   */
-  add (contact) {
-    ensureInt8('contact.id', (contact || {}).id)
-
-    let bitIndex = 0
-    let node = this.root
-
-    while (node.contacts === null) {
-      // this is not a leaf node but an inner node with 'low' and 'high'
-      // branches; we will check the appropriate bit of the identifier and
-      // delegate to the appropriate node for further processing
-      node = this._determineNode(node, contact.id, bitIndex++)
-    }
-
-    // check if the contact already exists
-    const index = this._indexOf(node, contact.id)
-    if (index >= 0) {
-      this._update(node, index, contact)
-      return this
-    }
-
-    if (node.contacts.length < this.numberOfNodesPerKBucket) {
-      node.contacts.push(contact)
-      this.emit('added', contact)
-      return this
-    }
-
-    // the bucket is full
-    if (node.dontSplit) {
-      // we are not allowed to split the bucket
-      // we need to ping the first this.numberOfNodesToPing
-      // in order to determine if they are alive
-      // only if one of the pinged nodes does not respond, can the new contact
-      // be added (this prevents DoS flodding with new invalid contacts)
-      this.emit('ping', node.contacts.slice(0, this.numberOfNodesToPing), contact)
-      return this
-    }
-
-    this._split(node, bitIndex)
-    return this.add(contact)
-  }
-
-  /**
-   * Get the n closest contacts to the provided node id. "Closest" here means:
-   * closest according to the XOR metric of the contact node id.
-   *
-   * @param  {Uint8Array} id  Contact node id
-   * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
-   *                          closest contacts to return
-   * @return {Array}          Array Maximum of n closest contacts to the node id
-   */
-  closest (id, n = Infinity) {
-    ensureInt8('id', id)
-
-    if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
-      throw new TypeError('n is not positive number')
-    }
-
-    let contacts = []
-
-    for (let nodes = [ this.root ], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
-      const node = nodes.pop()
-      if (node.contacts === null) {
-        const detNode = this._determineNode(node, id, bitIndex++)
-        nodes.push(node.left === detNode ? node.right : node.left)
-        nodes.push(detNode)
-      } else {
-        contacts = contacts.concat(node.contacts)
-      }
-    }
-
-    return contacts
-      .map(a => [this.distance(a.id, id), a])
-      .sort((a, b) => a[0] - b[0])
-      .slice(0, n)
-      .map(a => a[1])
-  }
-
-  /**
-   * Counts the total number of contacts in the tree.
-   *
-   * @return {Number} The number of contacts held in the tree
-   */
-  count () {
-    // return this.toArray().length
-    let count = 0
-    for (const nodes = [ this.root ]; nodes.length > 0;) {
-      const node = nodes.pop()
-      if (node.contacts === null) nodes.push(node.right, node.left)
-      else count += node.contacts.length
-    }
-    return count
-  }
-
-  /**
-   * Determines whether the id at the bitIndex is 0 or 1.
-   * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
-   *
-   * @param  {Object} node     internal object that has 2 leafs: left and right
-   * @param  {Uint8Array} id   Id to compare localNodeId with.
-   * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
-   *                           to check in the id Uint8Array.
-   * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
-   */
-  _determineNode (node, id, bitIndex) {
-    // **NOTE** remember that id is a Uint8Array and has granularity of
-    // bytes (8 bits), whereas the bitIndex is the _bit_ index (not byte)
-
-    // id's that are too short are put in low bucket (1 byte = 8 bits)
-    // (bitIndex >> 3) finds how many bytes the bitIndex describes
-    // bitIndex % 8 checks if we have extra bits beyond byte multiples
-    // if number of bytes is <= no. of bytes described by bitIndex and there
-    // are extra bits to consider, this means id has less bits than what
-    // bitIndex describes, id therefore is too short, and will be put in low
-    // bucket
-    const bytesDescribedByBitIndex = bitIndex >> 3
-    const bitIndexWithinByte = bitIndex % 8
-    if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
-      return node.left
-    }
-
-    const byteUnderConsideration = id[bytesDescribedByBitIndex]
-
-    // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
-    // where 255 is 11111111 and 0 is 00000000
-    // in order to find out whether the bit at bitIndexWithinByte is set
-    // we construct (1 << (7 - bitIndexWithinByte)) which will consist
-    // of all bits being 0, with only one bit set to 1
-    // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
-    // (1 << (7 - 3)) -> (1 << 4) -> 16
-    if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
-      return node.right
-    }
-
-    return node.left
-  }
-
-  /**
-   * Get a contact by its exact ID.
-   * If this is a leaf, loop through the bucket contents and return the correct
-   * contact if we have it or null if not. If this is an inner node, determine
-   * which branch of the tree to traverse and repeat.
-   *
-   * @param  {Uint8Array} id The ID of the contact to fetch.
-   * @return {Object|Null}   The contact if available, otherwise null
-   */
-  get (id) {
-    ensureInt8('id', id)
-
-    let bitIndex = 0
-
-    let node = this.root
-    while (node.contacts === null) {
-      node = this._determineNode(node, id, bitIndex++)
-    }
-
-    // index of uses contact id for matching
-    const index = this._indexOf(node, id)
-    return index >= 0 ? node.contacts[index] : null
-  }
-
-  /**
-   * Returns the index of the contact with provided
-   * id if it exists, returns -1 otherwise.
-   *
-   * @param  {Object} node    internal object that has 2 leafs: left and right
-   * @param  {Uint8Array} id  Contact node id.
-   * @return {Number}         Integer Index of contact with provided id if it
-   *                          exists, -1 otherwise.
-   */
-  _indexOf (node, id) {
-    for (let i = 0; i < node.contacts.length; ++i) {
-      if (arrayEquals(node.contacts[i].id, id)) return i
-    }
-
-    return -1
-  }
-
-  /**
-   * Removes contact with the provided id.
-   *
-   * @param  {Uint8Array} id The ID of the contact to remove.
-   * @return {Object}        The k-bucket itself.
-   */
-  remove (id) {
-    ensureInt8('the id as parameter 1', id)
-
-    let bitIndex = 0
-    let node = this.root
-
-    while (node.contacts === null) {
-      node = this._determineNode(node, id, bitIndex++)
-    }
-
-    const index = this._indexOf(node, id)
-    if (index >= 0) {
-      const contact = node.contacts.splice(index, 1)[0]
-      this.emit('removed', contact)
-    }
-
-    return this
-  }
-
-  /**
-   * Splits the node, redistributes contacts to the new nodes, and marks the
-   * node that was split as an inner node of the binary tree of nodes by
-   * setting this.root.contacts = null
-   *
-   * @param  {Object} node     node for splitting
-   * @param  {Number} bitIndex the bitIndex to which byte to check in the
-   *                           Uint8Array for navigating the binary tree
-   */
-  _split (node, bitIndex) {
-    node.left = createNode()
-    node.right = createNode()
-
-    // redistribute existing contacts amongst the two newly created nodes
-    for (const contact of node.contacts) {
-      this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
-    }
-
-    node.contacts = null // mark as inner tree node
-
-    // don't split the "far away" node
-    // we check where the local node would end up and mark the other one as
-    // "dontSplit" (i.e. "far away")
-    const detNode = this._determineNode(node, this.localNodeId, bitIndex)
-    const otherNode = node.left === detNode ? node.right : node.left
-    otherNode.dontSplit = true
-  }
-
-  /**
-   * Returns all the contacts contained in the tree as an array.
-   * If this is a leaf, return a copy of the bucket. `slice` is used so that we
-   * don't accidentally leak an internal reference out that might be
-   * accidentally misused. If this is not a leaf, return the union of the low
-   * and high branches (themselves also as arrays).
-   *
-   * @return {Array} All of the contacts in the tree, as an array
-   */
-  toArray () {
-    let result = []
-    for (const nodes = [ this.root ]; nodes.length > 0;) {
-      const node = nodes.pop()
-      if (node.contacts === null) nodes.push(node.right, node.left)
-      else result = result.concat(node.contacts)
-    }
-    return result
-  }
-
-  /**
-   * Updates the contact selected by the arbiter.
-   * If the selection is our old contact and the candidate is some new contact
-   * then the new contact is abandoned (not added).
-   * If the selection is our old contact and the candidate is our old contact
-   * then we are refreshing the contact and it is marked as most recently
-   * contacted (by being moved to the right/end of the bucket array).
-   * If the selection is our new contact, the old contact is removed and the new
-   * contact is marked as most recently contacted.
-   *
-   * @param  {Object} node    internal object that has 2 leafs: left and right
-   * @param  {Number} index   the index in the bucket where contact exists
-   *                          (index has already been computed in a previous
-   *                          calculation)
-   * @param  {Object} contact The contact object to update.
-   */
-  _update (node, index, contact) {
-    // sanity check
-    if (!arrayEquals(node.contacts[index].id, contact.id)) {
-      throw new Error('wrong index for _update')
-    }
-
-    const incumbent = node.contacts[index]
-    const selection = this.arbiter(incumbent, contact)
-    // if the selection is our old contact and the candidate is some new
-    // contact, then there is nothing to do
-    if (selection === incumbent && incumbent !== contact) return
-
-    node.contacts.splice(index, 1) // remove old contact
-    node.contacts.push(selection) // add more recent contact version
-    this.emit('updated', incumbent, selection)
-  }
-}
-
-module.exports = KBucket
-
-},{"events":90,"randombytes":6}],5:[function(require,module,exports){
-;(function () { // closure for web browsers
-
-if (typeof module === 'object' && module.exports) {
-  module.exports = LRUCache
-} else {
-  // just set the global for non-node platforms.
-  this.LRUCache = LRUCache
-}
-
-function hOP (obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key)
-}
-
-function naiveLength () { return 1 }
-
-function LRUCache (options) {
-  if (!(this instanceof LRUCache))
-    return new LRUCache(options)
-
-  if (typeof options === 'number')
-    options = { max: options }
-
-  if (!options)
-    options = {}
-
-  this._max = options.max
-  // Kind of weird to have a default max of Infinity, but oh well.
-  if (!this._max || !(typeof this._max === "number") || this._max <= 0 )
-    this._max = Infinity
-
-  this._lengthCalculator = options.length || naiveLength
-  if (typeof this._lengthCalculator !== "function")
-    this._lengthCalculator = naiveLength
-
-  this._allowStale = options.stale || false
-  this._maxAge = options.maxAge || null
-  this._dispose = options.dispose
-  this.reset()
-}
-
-// resize the cache when the max changes.
-Object.defineProperty(LRUCache.prototype, "max",
-  { set : function (mL) {
-      if (!mL || !(typeof mL === "number") || mL <= 0 ) mL = Infinity
-      this._max = mL
-      if (this._length > this._max) trim(this)
-    }
-  , get : function () { return this._max }
-  , enumerable : true
-  })
-
-// resize the cache when the lengthCalculator changes.
-Object.defineProperty(LRUCache.prototype, "lengthCalculator",
-  { set : function (lC) {
-      if (typeof lC !== "function") {
-        this._lengthCalculator = naiveLength
-        this._length = this._itemCount
-        for (var key in this._cache) {
-          this._cache[key].length = 1
-        }
-      } else {
-        this._lengthCalculator = lC
-        this._length = 0
-        for (var key in this._cache) {
-          this._cache[key].length = this._lengthCalculator(this._cache[key].value)
-          this._length += this._cache[key].length
-        }
-      }
-
-      if (this._length > this._max) trim(this)
-    }
-  , get : function () { return this._lengthCalculator }
-  , enumerable : true
-  })
-
-Object.defineProperty(LRUCache.prototype, "length",
-  { get : function () { return this._length }
-  , enumerable : true
-  })
-
-
-Object.defineProperty(LRUCache.prototype, "itemCount",
-  { get : function () { return this._itemCount }
-  , enumerable : true
-  })
-
-LRUCache.prototype.forEach = function (fn, thisp) {
-  thisp = thisp || this
-  var i = 0;
-  for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--) if (this._lruList[k]) {
-    i++
-    var hit = this._lruList[k]
-    if (this._maxAge && (Date.now() - hit.now > this._maxAge)) {
-      del(this, hit)
-      if (!this._allowStale) hit = undefined
-    }
-    if (hit) {
-      fn.call(thisp, hit.value, hit.key, this)
-    }
-  }
-}
-
-LRUCache.prototype.keys = function () {
-  var keys = new Array(this._itemCount)
-  var i = 0
-  for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--) if (this._lruList[k]) {
-    var hit = this._lruList[k]
-    keys[i++] = hit.key
-  }
-  return keys
-}
-
-LRUCache.prototype.values = function () {
-  var values = new Array(this._itemCount)
-  var i = 0
-  for (var k = this._mru - 1; k >= 0 && i < this._itemCount; k--) if (this._lruList[k]) {
-    var hit = this._lruList[k]
-    values[i++] = hit.value
-  }
-  return values
-}
-
-LRUCache.prototype.reset = function () {
-  if (this._dispose && this._cache) {
-    for (var k in this._cache) {
-      this._dispose(k, this._cache[k].value)
-    }
-  }
-
-  this._cache = Object.create(null) // hash of items by key
-  this._lruList = Object.create(null) // list of items in order of use recency
-  this._mru = 0 // most recently used
-  this._lru = 0 // least recently used
-  this._length = 0 // number of items in the list
-  this._itemCount = 0
-}
-
-// Provided for debugging/dev purposes only. No promises whatsoever that
-// this API stays stable.
-LRUCache.prototype.dump = function () {
-  return this._cache
-}
-
-LRUCache.prototype.dumpLru = function () {
-  return this._lruList
-}
-
-LRUCache.prototype.set = function (key, value) {
-  if (hOP(this._cache, key)) {
-    // dispose of the old one before overwriting
-    if (this._dispose) this._dispose(key, this._cache[key].value)
-    if (this._maxAge) this._cache[key].now = Date.now()
-    this._cache[key].value = value
-    this.get(key)
-    return true
-  }
-
-  var len = this._lengthCalculator(value)
-  var age = this._maxAge ? Date.now() : 0
-  var hit = new Entry(key, value, this._mru++, len, age)
-
-  // oversized objects fall out of cache automatically.
-  if (hit.length > this._max) {
-    if (this._dispose) this._dispose(key, value)
-    return false
-  }
-
-  this._length += hit.length
-  this._lruList[hit.lu] = this._cache[key] = hit
-  this._itemCount ++
-
-  if (this._length > this._max) trim(this)
-  return true
-}
-
-LRUCache.prototype.has = function (key) {
-  if (!hOP(this._cache, key)) return false
-  var hit = this._cache[key]
-  if (this._maxAge && (Date.now() - hit.now > this._maxAge)) {
-    return false
-  }
-  return true
-}
-
-LRUCache.prototype.get = function (key) {
-  return get(this, key, true)
-}
-
-LRUCache.prototype.peek = function (key) {
-  return get(this, key, false)
-}
-
-LRUCache.prototype.pop = function () {
-  var hit = this._lruList[this._lru]
-  del(this, hit)
-  return hit || null
-}
-
-LRUCache.prototype.del = function (key) {
-  del(this, this._cache[key])
-}
-
-function get (self, key, doUse) {
-  var hit = self._cache[key]
-  if (hit) {
-    if (self._maxAge && (Date.now() - hit.now > self._maxAge)) {
-      del(self, hit)
-      if (!self._allowStale) hit = undefined
-    } else {
-      if (doUse) use(self, hit)
-    }
-    if (hit) hit = hit.value
-  }
-  return hit
-}
-
-function use (self, hit) {
-  shiftLU(self, hit)
-  hit.lu = self._mru ++
-  self._lruList[hit.lu] = hit
-}
-
-function trim (self) {
-  while (self._lru < self._mru && self._length > self._max)
-    del(self, self._lruList[self._lru])
-}
-
-function shiftLU (self, hit) {
-  delete self._lruList[ hit.lu ]
-  while (self._lru < self._mru && !self._lruList[self._lru]) self._lru ++
-}
-
-function del (self, hit) {
-  if (hit) {
-    if (self._dispose) self._dispose(hit.key, hit.value)
-    self._length -= hit.length
-    self._itemCount --
-    delete self._cache[ hit.key ]
-    shiftLU(self, hit)
-  }
-}
-
-// classy, since V8 prefers predictable objects.
-function Entry (key, value, lu, length, now) {
-  this.key = key
-  this.value = value
-  this.lu = lu
-  this.length = length
-  this.now = now
-}
-
-})()
-
-},{}],6:[function(require,module,exports){
-(function (process,global){
-'use strict'
-
-function oldBrowser () {
-  throw new Error('Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11')
-}
-
-var Buffer = require('safe-buffer').Buffer
-var crypto = global.crypto || global.msCrypto
-
-if (crypto && crypto.getRandomValues) {
-  module.exports = randomBytes
-} else {
-  module.exports = oldBrowser
-}
-
-function randomBytes (size, cb) {
-  // phantomjs needs to throw
-  if (size > 65536) throw new Error('requested too many random bytes')
-  // in case browserify  isn't using the Uint8Array version
-  var rawBytes = new global.Uint8Array(size)
-
-  // This will not work in older browsers.
-  // See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
-  if (size > 0) {  // getRandomValues fails on IE if size == 0
-    crypto.getRandomValues(rawBytes)
-  }
-
-  // XXX: phantomjs doesn't like a buffer being passed here
-  var bytes = Buffer.from(rawBytes.buffer)
-
-  if (typeof cb === 'function') {
-    return process.nextTick(function () {
-      cb(null, bytes)
-    })
-  }
-
-  return bytes
-}
-
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"_process":125,"safe-buffer":7}],7:[function(require,module,exports){
-/* eslint-disable node/no-deprecated-api */
-var buffer = require('buffer')
-var Buffer = buffer.Buffer
-
-// alternative to using Object.keys for old browsers
-function copyProps (src, dst) {
-  for (var key in src) {
-    dst[key] = src[key]
-  }
-}
-if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
-  module.exports = buffer
-} else {
-  // Copy properties from require('buffer')
-  copyProps(buffer, exports)
-  exports.Buffer = SafeBuffer
-}
-
-function SafeBuffer (arg, encodingOrOffset, length) {
-  return Buffer(arg, encodingOrOffset, length)
-}
-
-// Copy static methods from Buffer
-copyProps(Buffer, SafeBuffer)
-
-SafeBuffer.from = function (arg, encodingOrOffset, length) {
-  if (typeof arg === 'number') {
-    throw new TypeError('Argument must not be a number')
-  }
-  return Buffer(arg, encodingOrOffset, length)
-}
-
-SafeBuffer.alloc = function (size, fill, encoding) {
-  if (typeof size !== 'number') {
-    throw new TypeError('Argument must be a number')
-  }
-  var buf = Buffer(size)
-  if (fill !== undefined) {
-    if (typeof encoding === 'string') {
-      buf.fill(fill, encoding)
-    } else {
-      buf.fill(fill)
-    }
-  } else {
-    buf.fill(0)
-  }
-  return buf
-}
-
-SafeBuffer.allocUnsafe = function (size) {
-  if (typeof size !== 'number') {
-    throw new TypeError('Argument must be a number')
-  }
-  return Buffer(size)
-}
-
-SafeBuffer.allocUnsafeSlow = function (size) {
-  if (typeof size !== 'number') {
-    throw new TypeError('Argument must be a number')
-  }
-  return buffer.SlowBuffer(size)
-}
-
-},{"buffer":55}],8:[function(require,module,exports){
-
-},{}],9:[function(require,module,exports){
-var asn1 = exports;
-
-asn1.bignum = require('bn.js');
-
-asn1.define = require('./asn1/api').define;
-asn1.base = require('./asn1/base');
-asn1.constants = require('./asn1/constants');
-asn1.decoders = require('./asn1/decoders');
-asn1.encoders = require('./asn1/encoders');
-
-},{"./asn1/api":10,"./asn1/base":12,"./asn1/constants":16,"./asn1/decoders":18,"./asn1/encoders":21,"bn.js":24}],10:[function(require,module,exports){
-var asn1 = require('../asn1');
-var inherits = require('inherits');
-
-var api = exports;
-
-api.define = function define(name, body) {
-  return new Entity(name, body);
-};
-
-function Entity(name, body) {
-  this.name = name;
-  this.body = body;
-
-  this.decoders = {};
-  this.encoders = {};
-};
-
-Entity.prototype._createNamed = function createNamed(base) {
-  var named;
-  try {
-    named = require('vm').runInThisContext(
-      '(function ' + this.name + '(entity) {\n' +
-      '  this._initNamed(entity);\n' +
-      '})'
-    );
-  } catch (e) {
-    named = function (entity) {
-      this._initNamed(entity);
-    };
-  }
-  inherits(named, base);
-  named.prototype._initNamed = function initnamed(entity) {
-    base.call(this, entity);
-  };
-
-  return new named(this);
-};
-
-Entity.prototype._getDecoder = function _getDecoder(enc) {
-  enc = enc || 'der';
-  // Lazily create decoder
-  if (!this.decoders.hasOwnProperty(enc))
-    this.decoders[enc] = this._createNamed(asn1.decoders[enc]);
-  return this.decoders[enc];
-};
-
-Entity.prototype.decode = function decode(data, enc, options) {
-  return this._getDecoder(enc).decode(data, options);
-};
-
-Entity.prototype._getEncoder = function _getEncoder(enc) {
-  enc = enc || 'der';
-  // Lazily create encoder
-  if (!this.encoders.hasOwnProperty(enc))
-    this.encoders[enc] = this._createNamed(asn1.encoders[enc]);
-  return this.encoders[enc];
-};
-
-Entity.prototype.encode = function encode(data, enc, /* internal */ reporter) {
-  return this._getEncoder(enc).encode(data, reporter);
-};
-
-},{"../asn1":9,"inherits":107,"vm":163}],11:[function(require,module,exports){
-var inherits = require('inherits');
-var Reporter = require('../base').Reporter;
-var Buffer = require('buffer').Buffer;
-
-function DecoderBuffer(base, options) {
-  Reporter.call(this, options);
-  if (!Buffer.isBuffer(base)) {
-    this.error('Input not Buffer');
-    return;
-  }
-
-  this.base = base;
-  this.offset = 0;
-  this.length = base.length;
-}
-inherits(DecoderBuffer, Reporter);
-exports.DecoderBuffer = DecoderBuffer;
-
-DecoderBuffer.prototype.save = function save() {
-  return { offset: this.offset, reporter: Reporter.prototype.save.call(this) };
-};
-
-DecoderBuffer.prototype.restore = function restore(save) {
-  // Return skipped data
-  var res = new DecoderBuffer(this.base);
-  res.offset = save.offset;
-  res.length = this.offset;
-
-  this.offset = save.offset;
-  Reporter.prototype.restore.call(this, save.reporter);
-
-  return res;
-};
-
-DecoderBuffer.prototype.isEmpty = function isEmpty() {
-  return this.offset === this.length;
-};
-
-DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {
-  if (this.offset + 1 <= this.length)
-    return this.base.readUInt8(this.offset++, true);
-  else
-    return this.error(fail || 'DecoderBuffer overrun');
-}
-
-DecoderBuffer.prototype.skip = function skip(bytes, fail) {
-  if (!(this.offset + bytes <= this.length))
-    return this.error(fail || 'DecoderBuffer overrun');
-
-  var res = new DecoderBuffer(this.base);
-
-  // Share reporter state
-  res._reporterState = this._reporterState;
-
-  res.offset = this.offset;
-  res.length = this.offset + bytes;
-  this.offset += bytes;
-  return res;
-}
-
-DecoderBuffer.prototype.raw = function raw(save) {
-  return this.base.slice(save ? save.offset : this.offset, this.length);
-}
-
-function EncoderBuffer(value, reporter) {
-  if (Array.isArray(value)) {
-    this.length = 0;
-    this.value = value.map(function(item) {
-      if (!(item instanceof EncoderBuffer))
-        item = new EncoderBuffer(item, reporter);
-      this.length += item.length;
-      return item;
-    }, this);
-  } else if (typeof value === 'number') {
-    if (!(0 <= value && value <= 0xff))
-      return reporter.error('non-byte EncoderBuffer value');
-    this.value = value;
-    this.length = 1;
-  } else if (typeof value === 'string') {
-    this.value = value;
-    this.length = Buffer.byteLength(value);
-  } else if (Buffer.isBuffer(value)) {
-    this.value = value;
-    this.length = value.length;
-  } else {
-    return reporter.error('Unsupported type: ' + typeof value);
-  }
-}
-exports.EncoderBuffer = EncoderBuffer;
-
-EncoderBuffer.prototype.join = function join(out, offset) {
-  if (!out)
-    out = new Buffer(this.length);
-  if (!offset)
-    offset = 0;
-
-  if (this.length === 0)
-    return out;
-
-  if (Array.isArray(this.value)) {
-    this.value.forEach(function(item) {
-      item.join(out, offset);
-      offset += item.length;
-    });
-  } else {
-    if (typeof this.value === 'number')
-      out[offset] = this.value;
-    else if (typeof this.value === 'string')
-      out.write(this.value, offset);
-    else if (Buffer.isBuffer(this.value))
-      this.value.copy(out, offset);
-    offset += this.length;
-  }
-
-  return out;
-};
-
-},{"../base":12,"buffer":55,"inherits":107}],12:[function(require,module,exports){
-var base = exports;
-
-base.Reporter = require('./reporter').Reporter;
-base.DecoderBuffer = require('./buffer').DecoderBuffer;
-base.EncoderBuffer = require('./buffer').EncoderBuffer;
-base.Node = require('./node');
-
-},{"./buffer":11,"./node":13,"./reporter":14}],13:[function(require,module,exports){
-var Reporter = require('../base').Reporter;
-var EncoderBuffer = require('../base').EncoderBuffer;
-var DecoderBuffer = require('../base').DecoderBuffer;
-var assert = require('minimalistic-assert');
-
-// Supported tags
-var tags = [
-  'seq', 'seqof', 'set', 'setof', 'objid', 'bool',
-  'gentime', 'utctime', 'null_', 'enum', 'int', 'objDesc',
-  'bitstr', 'bmpstr', 'charstr', 'genstr', 'graphstr', 'ia5str', 'iso646str',
-  'numstr', 'octstr', 'printstr', 't61str', 'unistr', 'utf8str', 'videostr'
-];
-
-// Public methods list
-var methods = [
-  'key', 'obj', 'use', 'optional', 'explicit', 'implicit', 'def', 'choice',
-  'any', 'contains'
-].concat(tags);
-
-// Overrided methods list
-var overrided = [
-  '_peekTag', '_decodeTag', '_use',
-  '_decodeStr', '_decodeObjid', '_decodeTime',
-  '_decodeNull', '_decodeInt', '_decodeBool', '_decodeList',
-
-  '_encodeComposite', '_encodeStr', '_encodeObjid', '_encodeTime',
-  '_encodeNull', '_encodeInt', '_encodeBool'
-];
-
-function Node(enc, parent) {
-  var state = {};
-  this._baseState = state;
-
-  state.enc = enc;
-
-  state.parent = parent || null;
-  state.children = null;
-
-  // State
-  state.tag = null;
-  state.args = null;
-  state.reverseArgs = null;
-  state.choice = null;
-  state.optional = false;
-  state.any = false;
-  state.obj = false;
-  state.use = null;
-  state.useDecoder = null;
-  state.key = null;
-  state['default'] = null;
-  state.explicit = null;
-  state.implicit = null;
-  state.contains = null;
-
-  // Should create new instance on each method
-  if (!state.parent) {
-    state.children = [];
-    this._wrap();
-  }
-}
-module.exports = Node;
-
-var stateProps = [
-  'enc', 'parent', 'children', 'tag', 'args', 'reverseArgs', 'choice',
-  'optional', 'any', 'obj', 'use', 'alteredUse', 'key', 'default', 'explicit',
-  'implicit', 'contains'
-];
-
-Node.prototype.clone = function clone() {
-  var state = this._baseState;
-  var cstate = {};
-  stateProps.forEach(function(prop) {
-    cstate[prop] = state[prop];
-  });
-  var res = new this.constructor(cstate.parent);
-  res._baseState = cstate;
-  return res;
-};
-
-Node.prototype._wrap = function wrap() {
-  var state = this._baseState;
-  methods.forEach(function(method) {
-    this[method] = function _wrappedMethod() {
-      var clone = new this.constructor(this);
-      state.children.push(clone);
-      return clone[method].apply(clone, arguments);
-    };
-  }, this);
-};
-
-Node.prototype._init = function init(body) {
-  var state = this._baseState;
-
-  assert(state.parent === null);
-  body.call(this);
-
-  // Filter children
-  state.children = state.children.filter(function(child) {
-    return child._baseState.parent === this;
-  }, this);
-  assert.equal(state.children.length, 1, 'Root node can have only one child');
-};
-
-Node.prototype._useArgs = function useArgs(args) {
-  var state = this._baseState;
-
-  // Filter children and args
-  var children = args.filter(function(arg) {
-    return arg instanceof this.constructor;
-  }, this);
-  args = args.filter(function(arg) {
-    return !(arg instanceof this.constructor);
-  }, this);
-
-  if (children.length !== 0) {
-    assert(state.children === null);
-    state.children = children;
-
-    // Replace parent to maintain backward link
-    children.forEach(function(child) {
-      child._baseState.parent = this;
-    }, this);
-  }
-  if (args.length !== 0) {
-    assert(state.args === null);
-    state.args = args;
-    state.reverseArgs = args.map(function(arg) {
-      if (typeof arg !== 'object' || arg.constructor !== Object)
-        return arg;
-
-      var res = {};
-      Object.keys(arg).forEach(function(key) {
-        if (key == (key | 0))
-          key |= 0;
-        var value = arg[key];
-        res[value] = key;
-      });
-      return res;
-    });
-  }
-};
-
-//
-// Overrided methods
-//
-
-overrided.forEach(function(method) {
-  Node.prototype[method] = function _overrided() {
-    var state = this._baseState;
-    throw new Error(method + ' not implemented for encoding: ' + state.enc);
-  };
-});
-
-//
-// Public methods
-//
-
-tags.forEach(function(tag) {
-  Node.prototype[tag] = function _tagMethod() {
-    var state = this._baseState;
-    var args = Array.prototype.slice.call(arguments);
-
-    assert(state.tag === null);
-    state.tag = tag;
-
-    this._useArgs(args);
-
-    return this;
-  };
-});
-
-Node.prototype.use = function use(item) {
-  assert(item);
-  var state = this._baseState;
 
-  assert(state.use === null);
-  state.use = item;
+                Duplex.prototype._destroy = function (err, cb) {
+                    this.push(null);
+                    this.end();
+
+                    pna.nextTick(cb, err);
+                };
+            }, {
+                "./_stream_readable": 137,
+                "./_stream_writable": 139,
+                "core-util-is": 57,
+                "inherits": 107,
+                "process-nextick-args": 124
+            }],
+            136: [function (require, module, exports) {
+                // Copyright Joyent, Inc. and other Node contributors.
+                //
+                // Permission is hereby granted, free of charge, to any person obtaining a
+                // copy of this software and associated documentation files (the
+                // "Software"), to deal in the Software without restriction, including
+                // without limitation the rights to use, copy, modify, merge, publish,
+                // distribute, sublicense, and/or sell copies of the Software, and to permit
+                // persons to whom the Software is furnished to do so, subject to the
+                // following conditions:
+                //
+                // The above copyright notice and this permission notice shall be included
+                // in all copies or substantial portions of the Software.
+                //
+                // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                // a passthrough stream.
+                // basically just the most minimal sort of Transform stream.
+                // Every written chunk gets output as-is.
+
+                'use strict';
+
+                module.exports = PassThrough;
+
+                var Transform = require('./_stream_transform');
+
+                /*<replacement>*/
+                var util = require('core-util-is');
+                util.inherits = require('inherits');
+                /*</replacement>*/
+
+                util.inherits(PassThrough, Transform);
+
+                function PassThrough(options) {
+                    if (!(this instanceof PassThrough)) return new PassThrough(options);
+
+                    Transform.call(this, options);
+                }
+
+                PassThrough.prototype._transform = function (chunk, encoding, cb) {
+                    cb(null, chunk);
+                };
+            }, {
+                "./_stream_transform": 138,
+                "core-util-is": 57,
+                "inherits": 107
+            }],
+            137: [function (require, module, exports) {
+                (function (process, global) {
+                    // Copyright Joyent, Inc. and other Node contributors.
+                    //
+                    // Permission is hereby granted, free of charge, to any person obtaining a
+                    // copy of this software and associated documentation files (the
+                    // "Software"), to deal in the Software without restriction, including
+                    // without limitation the rights to use, copy, modify, merge, publish,
+                    // distribute, sublicense, and/or sell copies of the Software, and to permit
+                    // persons to whom the Software is furnished to do so, subject to the
+                    // following conditions:
+                    //
+                    // The above copyright notice and this permission notice shall be included
+                    // in all copies or substantial portions of the Software.
+                    //
+                    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                    // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                    // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                    // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                    // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                    // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                    // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                    'use strict';
+
+                    /*<replacement>*/
+
+                    var pna = require('process-nextick-args');
+                    /*</replacement>*/
+
+                    module.exports = Readable;
+
+                    /*<replacement>*/
+                    var isArray = require('isarray');
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+                    var Duplex;
+                    /*</replacement>*/
+
+                    Readable.ReadableState = ReadableState;
+
+                    /*<replacement>*/
+                    var EE = require('events').EventEmitter;
+
+                    var EElistenerCount = function (emitter, type) {
+                        return emitter.listeners(type).length;
+                    };
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+                    var Stream = require('./internal/streams/stream');
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+
+                    var Buffer = require('safe-buffer').Buffer;
+                    var OurUint8Array = global.Uint8Array || function () {};
+
+                    function _uint8ArrayToBuffer(chunk) {
+                        return Buffer.from(chunk);
+                    }
+
+                    function _isUint8Array(obj) {
+                        return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+                    }
+
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+                    var util = require('core-util-is');
+                    util.inherits = require('inherits');
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+                    var debugUtil = require('util');
+                    var debug = void 0;
+                    if (debugUtil && debugUtil.debuglog) {
+                        debug = debugUtil.debuglog('stream');
+                    } else {
+                        debug = function () {};
+                    }
+                    /*</replacement>*/
+
+                    var BufferList = require('./internal/streams/BufferList');
+                    var destroyImpl = require('./internal/streams/destroy');
+                    var StringDecoder;
+
+                    util.inherits(Readable, Stream);
+
+                    var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
+
+                    function prependListener(emitter, event, fn) {
+                        // Sadly this is not cacheable as some libraries bundle their own
+                        // event emitter implementation with them.
+                        if (typeof emitter.prependListener === 'function') return emitter.prependListener(
+                            event, fn);
+
+                        // This is a hack to make sure that our error handler is attached before any
+                        // userland ones.  NEVER DO THIS. This is here only because this code needs
+                        // to continue to work with older versions of Node.js that do not include
+                        // the prependListener() method. The goal is to eventually remove this hack.
+                        if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
+                        else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);
+                        else emitter._events[event] = [fn, emitter._events[event]];
+                    }
+
+                    function ReadableState(options, stream) {
+                        Duplex = Duplex || require('./_stream_duplex');
+
+                        options = options || {};
+
+                        // Duplex streams are both readable and writable, but share
+                        // the same options object.
+                        // However, some cases require setting options to different
+                        // values for the readable and the writable sides of the duplex stream.
+                        // These options can be provided separately as readableXXX and writableXXX.
+                        var isDuplex = stream instanceof Duplex;
+
+                        // object stream flag. Used to make read(n) ignore n and to
+                        // make all the buffer merging and length checks go away
+                        this.objectMode = !!options.objectMode;
+
+                        if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+
+                        // the point at which it stops calling _read() to fill the buffer
+                        // Note: 0 is a valid value, means "don't call _read preemptively ever"
+                        var hwm = options.highWaterMark;
+                        var readableHwm = options.readableHighWaterMark;
+                        var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+
+                        if (hwm || hwm === 0) this.highWaterMark = hwm;
+                        else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark =
+                            readableHwm;
+                        else this.highWaterMark = defaultHwm;
+
+                        // cast to ints.
+                        this.highWaterMark = Math.floor(this.highWaterMark);
+
+                        // A linked list is used to store data chunks instead of an array because the
+                        // linked list can remove elements from the beginning faster than
+                        // array.shift()
+                        this.buffer = new BufferList();
+                        this.length = 0;
+                        this.pipes = null;
+                        this.pipesCount = 0;
+                        this.flowing = null;
+                        this.ended = false;
+                        this.endEmitted = false;
+                        this.reading = false;
+
+                        // a flag to be able to tell if the event 'readable'/'data' is emitted
+                        // immediately, or on a later tick.  We set this to true at first, because
+                        // any actions that shouldn't happen until "later" should generally also
+                        // not happen before the first read call.
+                        this.sync = true;
+
+                        // whenever we return null, then we set a flag to say
+                        // that we're awaiting a 'readable' event emission.
+                        this.needReadable = false;
+                        this.emittedReadable = false;
+                        this.readableListening = false;
+                        this.resumeScheduled = false;
+
+                        // has it been destroyed
+                        this.destroyed = false;
+
+                        // Crypto is kind of old and crusty.  Historically, its default string
+                        // encoding is 'binary' so we have to make this configurable.
+                        // Everything else in the universe uses 'utf8', though.
+                        this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+                        // the number of writers that are awaiting a drain event in .pipe()s
+                        this.awaitDrain = 0;
+
+                        // if true, a maybeReadMore has been scheduled
+                        this.readingMore = false;
+
+                        this.decoder = null;
+                        this.encoding = null;
+                        if (options.encoding) {
+                            if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+                            this.decoder = new StringDecoder(options.encoding);
+                            this.encoding = options.encoding;
+                        }
+                    }
+
+                    function Readable(options) {
+                        Duplex = Duplex || require('./_stream_duplex');
+
+                        if (!(this instanceof Readable)) return new Readable(options);
+
+                        this._readableState = new ReadableState(options, this);
+
+                        // legacy
+                        this.readable = true;
+
+                        if (options) {
+                            if (typeof options.read === 'function') this._read = options.read;
+
+                            if (typeof options.destroy === 'function') this._destroy = options.destroy;
+                        }
+
+                        Stream.call(this);
+                    }
+
+                    Object.defineProperty(Readable.prototype, 'destroyed', {
+                        get: function () {
+                            if (this._readableState === undefined) {
+                                return false;
+                            }
+                            return this._readableState.destroyed;
+                        },
+                        set: function (value) {
+                            // we ignore the value if the stream
+                            // has not been initialized yet
+                            if (!this._readableState) {
+                                return;
+                            }
+
+                            // backward compatibility, the user is explicitly
+                            // managing destroyed
+                            this._readableState.destroyed = value;
+                        }
+                    });
+
+                    Readable.prototype.destroy = destroyImpl.destroy;
+                    Readable.prototype._undestroy = destroyImpl.undestroy;
+                    Readable.prototype._destroy = function (err, cb) {
+                        this.push(null);
+                        cb(err);
+                    };
+
+                    // Manually shove something into the read() buffer.
+                    // This returns true if the highWaterMark has not been hit yet,
+                    // similar to how Writable.write() returns true if you should
+                    // write() some more.
+                    Readable.prototype.push = function (chunk, encoding) {
+                        var state = this._readableState;
+                        var skipChunkCheck;
+
+                        if (!state.objectMode) {
+                            if (typeof chunk === 'string') {
+                                encoding = encoding || state.defaultEncoding;
+                                if (encoding !== state.encoding) {
+                                    chunk = Buffer.from(chunk, encoding);
+                                    encoding = '';
+                                }
+                                skipChunkCheck = true;
+                            }
+                        } else {
+                            skipChunkCheck = true;
+                        }
+
+                        return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+                    };
+
+                    // Unshift should *always* be something directly out of read()
+                    Readable.prototype.unshift = function (chunk) {
+                        return readableAddChunk(this, chunk, null, true, false);
+                    };
+
+                    function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+                        var state = stream._readableState;
+                        if (chunk === null) {
+                            state.reading = false;
+                            onEofChunk(stream, state);
+                        } else {
+                            var er;
+                            if (!skipChunkCheck) er = chunkInvalid(state, chunk);
+                            if (er) {
+                                stream.emit('error', er);
+                            } else if (state.objectMode || chunk && chunk.length > 0) {
+                                if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(
+                                        chunk) !== Buffer.prototype) {
+                                    chunk = _uint8ArrayToBuffer(chunk);
+                                }
+
+                                if (addToFront) {
+                                    if (state.endEmitted) stream.emit('error', new Error(
+                                        'stream.unshift() after end event'));
+                                    else addChunk(stream, state, chunk, true);
+                                } else if (state.ended) {
+                                    stream.emit('error', new Error('stream.push() after EOF'));
+                                } else {
+                                    state.reading = false;
+                                    if (state.decoder && !encoding) {
+                                        chunk = state.decoder.write(chunk);
+                                        if (state.objectMode || chunk.length !== 0) addChunk(stream,
+                                            state, chunk, false);
+                                        else maybeReadMore(stream, state);
+                                    } else {
+                                        addChunk(stream, state, chunk, false);
+                                    }
+                                }
+                            } else if (!addToFront) {
+                                state.reading = false;
+                            }
+                        }
+
+                        return needMoreData(state);
+                    }
+
+                    function addChunk(stream, state, chunk, addToFront) {
+                        if (state.flowing && state.length === 0 && !state.sync) {
+                            stream.emit('data', chunk);
+                            stream.read(0);
+                        } else {
+                            // update the buffer info.
+                            state.length += state.objectMode ? 1 : chunk.length;
+                            if (addToFront) state.buffer.unshift(chunk);
+                            else state.buffer.push(chunk);
+
+                            if (state.needReadable) emitReadable(stream);
+                        }
+                        maybeReadMore(stream, state);
+                    }
+
+                    function chunkInvalid(state, chunk) {
+                        var er;
+                        if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined &&
+                            !state.objectMode) {
+                            er = new TypeError('Invalid non-string/buffer chunk');
+                        }
+                        return er;
+                    }
+
+                    // if it's past the high water mark, we can push in some more.
+                    // Also, if we have no data yet, we can stand some
+                    // more bytes.  This is to work around cases where hwm=0,
+                    // such as the repl.  Also, if the push() triggered a
+                    // readable event, and the user called read(largeNumber) such that
+                    // needReadable was set, then we ought to push more, so that another
+                    // 'readable' event will be triggered.
+                    function needMoreData(state) {
+                        return !state.ended && (state.needReadable || state.length < state.highWaterMark ||
+                            state.length === 0);
+                    }
+
+                    Readable.prototype.isPaused = function () {
+                        return this._readableState.flowing === false;
+                    };
+
+                    // backwards compatibility.
+                    Readable.prototype.setEncoding = function (enc) {
+                        if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+                        this._readableState.decoder = new StringDecoder(enc);
+                        this._readableState.encoding = enc;
+                        return this;
+                    };
+
+                    // Don't raise the hwm > 8MB
+                    var MAX_HWM = 0x800000;
+
+                    function computeNewHighWaterMark(n) {
+                        if (n >= MAX_HWM) {
+                            n = MAX_HWM;
+                        } else {
+                            // Get the next highest power of 2 to prevent increasing hwm excessively in
+                            // tiny amounts
+                            n--;
+                            n |= n >>> 1;
+                            n |= n >>> 2;
+                            n |= n >>> 4;
+                            n |= n >>> 8;
+                            n |= n >>> 16;
+                            n++;
+                        }
+                        return n;
+                    }
+
+                    // This function is designed to be inlinable, so please take care when making
+                    // changes to the function body.
+                    function howMuchToRead(n, state) {
+                        if (n <= 0 || state.length === 0 && state.ended) return 0;
+                        if (state.objectMode) return 1;
+                        if (n !== n) {
+                            // Only flow one buffer at a time
+                            if (state.flowing && state.length) return state.buffer.head.data.length;
+                            else return state.length;
+                        }
+                        // If we're asking for more than the current hwm, then raise the hwm.
+                        if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+                        if (n <= state.length) return n;
+                        // Don't have enough
+                        if (!state.ended) {
+                            state.needReadable = true;
+                            return 0;
+                        }
+                        return state.length;
+                    }
+
+                    // you can override either this method, or the async _read(n) below.
+                    Readable.prototype.read = function (n) {
+                        debug('read', n);
+                        n = parseInt(n, 10);
+                        var state = this._readableState;
+                        var nOrig = n;
+
+                        if (n !== 0) state.emittedReadable = false;
+
+                        // if we're doing read(0) to trigger a readable event, but we
+                        // already have a bunch of data in the buffer, then just trigger
+                        // the 'readable' event and move on.
+                        if (n === 0 && state.needReadable && (state.length >= state.highWaterMark ||
+                                state.ended)) {
+                            debug('read: emitReadable', state.length, state.ended);
+                            if (state.length === 0 && state.ended) endReadable(this);
+                            else emitReadable(this);
+                            return null;
+                        }
+
+                        n = howMuchToRead(n, state);
+
+                        // if we've ended, and we're now clear, then finish it up.
+                        if (n === 0 && state.ended) {
+                            if (state.length === 0) endReadable(this);
+                            return null;
+                        }
+
+                        // All the actual chunk generation logic needs to be
+                        // *below* the call to _read.  The reason is that in certain
+                        // synthetic stream cases, such as passthrough streams, _read
+                        // may be a completely synchronous operation which may change
+                        // the state of the read buffer, providing enough data when
+                        // before there was *not* enough.
+                        //
+                        // So, the steps are:
+                        // 1. Figure out what the state of things will be after we do
+                        // a read from the buffer.
+                        //
+                        // 2. If that resulting state will trigger a _read, then call _read.
+                        // Note that this may be asynchronous, or synchronous.  Yes, it is
+                        // deeply ugly to write APIs this way, but that still doesn't mean
+                        // that the Readable class should behave improperly, as streams are
+                        // designed to be sync/async agnostic.
+                        // Take note if the _read call is sync or async (ie, if the read call
+                        // has returned yet), so that we know whether or not it's safe to emit
+                        // 'readable' etc.
+                        //
+                        // 3. Actually pull the requested chunks out of the buffer and return.
+
+                        // if we need a readable event, then we need to do some reading.
+                        var doRead = state.needReadable;
+                        debug('need readable', doRead);
+
+                        // if we currently have less than the highWaterMark, then also read some
+                        if (state.length === 0 || state.length - n < state.highWaterMark) {
+                            doRead = true;
+                            debug('length less than watermark', doRead);
+                        }
+
+                        // however, if we've ended, then there's no point, and if we're already
+                        // reading, then it's unnecessary.
+                        if (state.ended || state.reading) {
+                            doRead = false;
+                            debug('reading or ended', doRead);
+                        } else if (doRead) {
+                            debug('do read');
+                            state.reading = true;
+                            state.sync = true;
+                            // if the length is currently zero, then we *need* a readable event.
+                            if (state.length === 0) state.needReadable = true;
+                            // call internal read method
+                            this._read(state.highWaterMark);
+                            state.sync = false;
+                            // If _read pushed data synchronously, then `reading` will be false,
+                            // and we need to re-evaluate how much data we can return to the user.
+                            if (!state.reading) n = howMuchToRead(nOrig, state);
+                        }
+
+                        var ret;
+                        if (n > 0) ret = fromList(n, state);
+                        else ret = null;
+
+                        if (ret === null) {
+                            state.needReadable = true;
+                            n = 0;
+                        } else {
+                            state.length -= n;
+                        }
+
+                        if (state.length === 0) {
+                            // If we have nothing in the buffer, then we want to know
+                            // as soon as we *do* get something into the buffer.
+                            if (!state.ended) state.needReadable = true;
+
+                            // If we tried to read() past the EOF, then emit end on the next tick.
+                            if (nOrig !== n && state.ended) endReadable(this);
+                        }
+
+                        if (ret !== null) this.emit('data', ret);
+
+                        return ret;
+                    };
+
+                    function onEofChunk(stream, state) {
+                        if (state.ended) return;
+                        if (state.decoder) {
+                            var chunk = state.decoder.end();
+                            if (chunk && chunk.length) {
+                                state.buffer.push(chunk);
+                                state.length += state.objectMode ? 1 : chunk.length;
+                            }
+                        }
+                        state.ended = true;
+
+                        // emit 'readable' now to make sure it gets picked up.
+                        emitReadable(stream);
+                    }
+
+                    // Don't emit readable right away in sync mode, because this can trigger
+                    // another read() call => stack overflow.  This way, it might trigger
+                    // a nextTick recursion warning, but that's not so bad.
+                    function emitReadable(stream) {
+                        var state = stream._readableState;
+                        state.needReadable = false;
+                        if (!state.emittedReadable) {
+                            debug('emitReadable', state.flowing);
+                            state.emittedReadable = true;
+                            if (state.sync) pna.nextTick(emitReadable_, stream);
+                            else emitReadable_(stream);
+                        }
+                    }
+
+                    function emitReadable_(stream) {
+                        debug('emit readable');
+                        stream.emit('readable');
+                        flow(stream);
+                    }
+
+                    // at this point, the user has presumably seen the 'readable' event,
+                    // and called read() to consume some data.  that may have triggered
+                    // in turn another _read(n) call, in which case reading = true if
+                    // it's in progress.
+                    // However, if we're not ended, or reading, and the length < hwm,
+                    // then go ahead and try to read some more preemptively.
+                    function maybeReadMore(stream, state) {
+                        if (!state.readingMore) {
+                            state.readingMore = true;
+                            pna.nextTick(maybeReadMore_, stream, state);
+                        }
+                    }
+
+                    function maybeReadMore_(stream, state) {
+                        var len = state.length;
+                        while (!state.reading && !state.flowing && !state.ended && state.length < state
+                            .highWaterMark) {
+                            debug('maybeReadMore read 0');
+                            stream.read(0);
+                            if (len === state.length)
+                                // didn't get any data, stop spinning.
+                                break;
+                            else len = state.length;
+                        }
+                        state.readingMore = false;
+                    }
+
+                    // abstract method.  to be overridden in specific implementation classes.
+                    // call cb(er, data) where data is <= n in length.
+                    // for virtual (non-string, non-buffer) streams, "length" is somewhat
+                    // arbitrary, and perhaps not very meaningful.
+                    Readable.prototype._read = function (n) {
+                        this.emit('error', new Error('_read() is not implemented'));
+                    };
+
+                    Readable.prototype.pipe = function (dest, pipeOpts) {
+                        var src = this;
+                        var state = this._readableState;
+
+                        switch (state.pipesCount) {
+                            case 0:
+                                state.pipes = dest;
+                                break;
+                            case 1:
+                                state.pipes = [state.pipes, dest];
+                                break;
+                            default:
+                                state.pipes.push(dest);
+                                break;
+                        }
+                        state.pipesCount += 1;
+                        debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
+
+                        var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout &&
+                            dest !== process.stderr;
+
+                        var endFn = doEnd ? onend : unpipe;
+                        if (state.endEmitted) pna.nextTick(endFn);
+                        else src.once('end', endFn);
+
+                        dest.on('unpipe', onunpipe);
+
+                        function onunpipe(readable, unpipeInfo) {
+                            debug('onunpipe');
+                            if (readable === src) {
+                                if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+                                    unpipeInfo.hasUnpiped = true;
+                                    cleanup();
+                                }
+                            }
+                        }
+
+                        function onend() {
+                            debug('onend');
+                            dest.end();
+                        }
+
+                        // when the dest drains, it reduces the awaitDrain counter
+                        // on the source.  This would be more elegant with a .once()
+                        // handler in flow(), but adding and removing repeatedly is
+                        // too slow.
+                        var ondrain = pipeOnDrain(src);
+                        dest.on('drain', ondrain);
+
+                        var cleanedUp = false;
+
+                        function cleanup() {
+                            debug('cleanup');
+                            // cleanup event handlers once the pipe is broken
+                            dest.removeListener('close', onclose);
+                            dest.removeListener('finish', onfinish);
+                            dest.removeListener('drain', ondrain);
+                            dest.removeListener('error', onerror);
+                            dest.removeListener('unpipe', onunpipe);
+                            src.removeListener('end', onend);
+                            src.removeListener('end', unpipe);
+                            src.removeListener('data', ondata);
+
+                            cleanedUp = true;
+
+                            // if the reader is waiting for a drain event from this
+                            // specific writer, then it would cause it to never start
+                            // flowing again.
+                            // So, if this is awaiting a drain, then we just call it now.
+                            // If we don't know, then assume that we are waiting for one.
+                            if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain))
+                                ondrain();
+                        }
+
+                        // If the user pushes more data while we're writing to dest then we'll end up
+                        // in ondata again. However, we only want to increase awaitDrain once because
+                        // dest will only emit one 'drain' event for the multiple writes.
+                        // => Introduce a guard on increasing awaitDrain.
+                        var increasedAwaitDrain = false;
+                        src.on('data', ondata);
+
+                        function ondata(chunk) {
+                            debug('ondata');
+                            increasedAwaitDrain = false;
+                            var ret = dest.write(chunk);
+                            if (false === ret && !increasedAwaitDrain) {
+                                // If the user unpiped during `dest.write()`, it is possible
+                                // to get stuck in a permanently paused state if that write
+                                // also returned false.
+                                // => Check whether `dest` is still a piping destination.
+                                if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount >
+                                        1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+                                    debug('false write response, pause', src._readableState.awaitDrain);
+                                    src._readableState.awaitDrain++;
+                                    increasedAwaitDrain = true;
+                                }
+                                src.pause();
+                            }
+                        }
+
+                        // if the dest has an error, then stop piping into it.
+                        // however, don't suppress the throwing behavior for this.
+                        function onerror(er) {
+                            debug('onerror', er);
+                            unpipe();
+                            dest.removeListener('error', onerror);
+                            if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+                        }
+
+                        // Make sure our error handler is attached before userland ones.
+                        prependListener(dest, 'error', onerror);
+
+                        // Both close and finish should trigger unpipe, but only once.
+                        function onclose() {
+                            dest.removeListener('finish', onfinish);
+                            unpipe();
+                        }
+                        dest.once('close', onclose);
+
+                        function onfinish() {
+                            debug('onfinish');
+                            dest.removeListener('close', onclose);
+                            unpipe();
+                        }
+                        dest.once('finish', onfinish);
+
+                        function unpipe() {
+                            debug('unpipe');
+                            src.unpipe(dest);
+                        }
+
+                        // tell the dest that it's being piped to
+                        dest.emit('pipe', src);
+
+                        // start the flow if it hasn't been started already.
+                        if (!state.flowing) {
+                            debug('pipe resume');
+                            src.resume();
+                        }
+
+                        return dest;
+                    };
+
+                    function pipeOnDrain(src) {
+                        return function () {
+                            var state = src._readableState;
+                            debug('pipeOnDrain', state.awaitDrain);
+                            if (state.awaitDrain) state.awaitDrain--;
+                            if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
+                                state.flowing = true;
+                                flow(src);
+                            }
+                        };
+                    }
+
+                    Readable.prototype.unpipe = function (dest) {
+                        var state = this._readableState;
+                        var unpipeInfo = {
+                            hasUnpiped: false
+                        };
+
+                        // if we're not piping anywhere, then do nothing.
+                        if (state.pipesCount === 0) return this;
+
+                        // just one destination.  most common case.
+                        if (state.pipesCount === 1) {
+                            // passed in one, but it's not the right one.
+                            if (dest && dest !== state.pipes) return this;
+
+                            if (!dest) dest = state.pipes;
+
+                            // got a match.
+                            state.pipes = null;
+                            state.pipesCount = 0;
+                            state.flowing = false;
+                            if (dest) dest.emit('unpipe', this, unpipeInfo);
+                            return this;
+                        }
+
+                        // slow case. multiple pipe destinations.
+
+                        if (!dest) {
+                            // remove all.
+                            var dests = state.pipes;
+                            var len = state.pipesCount;
+                            state.pipes = null;
+                            state.pipesCount = 0;
+                            state.flowing = false;
+
+                            for (var i = 0; i < len; i++) {
+                                dests[i].emit('unpipe', this, unpipeInfo);
+                            }
+                            return this;
+                        }
+
+                        // try to find the right one.
+                        var index = indexOf(state.pipes, dest);
+                        if (index === -1) return this;
+
+                        state.pipes.splice(index, 1);
+                        state.pipesCount -= 1;
+                        if (state.pipesCount === 1) state.pipes = state.pipes[0];
+
+                        dest.emit('unpipe', this, unpipeInfo);
+
+                        return this;
+                    };
+
+                    // set up data events if they are asked for
+                    // Ensure readable listeners eventually get something
+                    Readable.prototype.on = function (ev, fn) {
+                        var res = Stream.prototype.on.call(this, ev, fn);
+
+                        if (ev === 'data') {
+                            // Start flowing on next tick if stream isn't explicitly paused
+                            if (this._readableState.flowing !== false) this.resume();
+                        } else if (ev === 'readable') {
+                            var state = this._readableState;
+                            if (!state.endEmitted && !state.readableListening) {
+                                state.readableListening = state.needReadable = true;
+                                state.emittedReadable = false;
+                                if (!state.reading) {
+                                    pna.nextTick(nReadingNextTick, this);
+                                } else if (state.length) {
+                                    emitReadable(this);
+                                }
+                            }
+                        }
+
+                        return res;
+                    };
+                    Readable.prototype.addListener = Readable.prototype.on;
+
+                    function nReadingNextTick(self) {
+                        debug('readable nexttick read 0');
+                        self.read(0);
+                    }
+
+                    // pause() and resume() are remnants of the legacy readable stream API
+                    // If the user uses them, then switch into old mode.
+                    Readable.prototype.resume = function () {
+                        var state = this._readableState;
+                        if (!state.flowing) {
+                            debug('resume');
+                            state.flowing = true;
+                            resume(this, state);
+                        }
+                        return this;
+                    };
+
+                    function resume(stream, state) {
+                        if (!state.resumeScheduled) {
+                            state.resumeScheduled = true;
+                            pna.nextTick(resume_, stream, state);
+                        }
+                    }
+
+                    function resume_(stream, state) {
+                        if (!state.reading) {
+                            debug('resume read 0');
+                            stream.read(0);
+                        }
+
+                        state.resumeScheduled = false;
+                        state.awaitDrain = 0;
+                        stream.emit('resume');
+                        flow(stream);
+                        if (state.flowing && !state.reading) stream.read(0);
+                    }
+
+                    Readable.prototype.pause = function () {
+                        debug('call pause flowing=%j', this._readableState.flowing);
+                        if (false !== this._readableState.flowing) {
+                            debug('pause');
+                            this._readableState.flowing = false;
+                            this.emit('pause');
+                        }
+                        return this;
+                    };
+
+                    function flow(stream) {
+                        var state = stream._readableState;
+                        debug('flow', state.flowing);
+                        while (state.flowing && stream.read() !== null) {}
+                    }
+
+                    // wrap an old-style stream as the async data source.
+                    // This is *not* part of the readable stream interface.
+                    // It is an ugly unfortunate mess of history.
+                    Readable.prototype.wrap = function (stream) {
+                        var _this = this;
+
+                        var state = this._readableState;
+                        var paused = false;
+
+                        stream.on('end', function () {
+                            debug('wrapped end');
+                            if (state.decoder && !state.ended) {
+                                var chunk = state.decoder.end();
+                                if (chunk && chunk.length) _this.push(chunk);
+                            }
+
+                            _this.push(null);
+                        });
+
+                        stream.on('data', function (chunk) {
+                            debug('wrapped data');
+                            if (state.decoder) chunk = state.decoder.write(chunk);
+
+                            // don't skip over falsy values in objectMode
+                            if (state.objectMode && (chunk === null || chunk === undefined))
+                                return;
+                            else if (!state.objectMode && (!chunk || !chunk.length)) return;
+
+                            var ret = _this.push(chunk);
+                            if (!ret) {
+                                paused = true;
+                                stream.pause();
+                            }
+                        });
+
+                        // proxy all the other methods.
+                        // important when wrapping filters and duplexes.
+                        for (var i in stream) {
+                            if (this[i] === undefined && typeof stream[i] === 'function') {
+                                this[i] = function (method) {
+                                    return function () {
+                                        return stream[method].apply(stream, arguments);
+                                    };
+                                }(i);
+                            }
+                        }
+
+                        // proxy certain important events.
+                        for (var n = 0; n < kProxyEvents.length; n++) {
+                            stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+                        }
+
+                        // when we try to consume some more bytes, simply unpause the
+                        // underlying stream.
+                        this._read = function (n) {
+                            debug('wrapped _read', n);
+                            if (paused) {
+                                paused = false;
+                                stream.resume();
+                            }
+                        };
+
+                        return this;
+                    };
+
+                    Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
+                        // making it explicit this property is not enumerable
+                        // because otherwise some prototype manipulation in
+                        // userland will fail
+                        enumerable: false,
+                        get: function () {
+                            return this._readableState.highWaterMark;
+                        }
+                    });
+
+                    // exposed for testing purposes only.
+                    Readable._fromList = fromList;
+
+                    // Pluck off n bytes from an array of buffers.
+                    // Length is the combined lengths of all the buffers in the list.
+                    // This function is designed to be inlinable, so please take care when making
+                    // changes to the function body.
+                    function fromList(n, state) {
+                        // nothing buffered
+                        if (state.length === 0) return null;
+
+                        var ret;
+                        if (state.objectMode) ret = state.buffer.shift();
+                        else if (!n || n >= state.length) {
+                            // read it all, truncate the list
+                            if (state.decoder) ret = state.buffer.join('');
+                            else if (state.buffer.length === 1) ret = state.buffer.head.data;
+                            else ret = state.buffer.concat(state.length);
+                            state.buffer.clear();
+                        } else {
+                            // read part of list
+                            ret = fromListPartial(n, state.buffer, state.decoder);
+                        }
+
+                        return ret;
+                    }
+
+                    // Extracts only enough buffered data to satisfy the amount requested.
+                    // This function is designed to be inlinable, so please take care when making
+                    // changes to the function body.
+                    function fromListPartial(n, list, hasStrings) {
+                        var ret;
+                        if (n < list.head.data.length) {
+                            // slice is the same for buffers and strings
+                            ret = list.head.data.slice(0, n);
+                            list.head.data = list.head.data.slice(n);
+                        } else if (n === list.head.data.length) {
+                            // first chunk is a perfect match
+                            ret = list.shift();
+                        } else {
+                            // result spans more than one buffer
+                            ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+                        }
+                        return ret;
+                    }
+
+                    // Copies a specified amount of characters from the list of buffered data
+                    // chunks.
+                    // This function is designed to be inlinable, so please take care when making
+                    // changes to the function body.
+                    function copyFromBufferString(n, list) {
+                        var p = list.head;
+                        var c = 1;
+                        var ret = p.data;
+                        n -= ret.length;
+                        while (p = p.next) {
+                            var str = p.data;
+                            var nb = n > str.length ? str.length : n;
+                            if (nb === str.length) ret += str;
+                            else ret += str.slice(0, n);
+                            n -= nb;
+                            if (n === 0) {
+                                if (nb === str.length) {
+                                    ++c;
+                                    if (p.next) list.head = p.next;
+                                    else list.head = list.tail = null;
+                                } else {
+                                    list.head = p;
+                                    p.data = str.slice(nb);
+                                }
+                                break;
+                            }
+                            ++c;
+                        }
+                        list.length -= c;
+                        return ret;
+                    }
+
+                    // Copies a specified amount of bytes from the list of buffered data chunks.
+                    // This function is designed to be inlinable, so please take care when making
+                    // changes to the function body.
+                    function copyFromBuffer(n, list) {
+                        var ret = Buffer.allocUnsafe(n);
+                        var p = list.head;
+                        var c = 1;
+                        p.data.copy(ret);
+                        n -= p.data.length;
+                        while (p = p.next) {
+                            var buf = p.data;
+                            var nb = n > buf.length ? buf.length : n;
+                            buf.copy(ret, ret.length - n, 0, nb);
+                            n -= nb;
+                            if (n === 0) {
+                                if (nb === buf.length) {
+                                    ++c;
+                                    if (p.next) list.head = p.next;
+                                    else list.head = list.tail = null;
+                                } else {
+                                    list.head = p;
+                                    p.data = buf.slice(nb);
+                                }
+                                break;
+                            }
+                            ++c;
+                        }
+                        list.length -= c;
+                        return ret;
+                    }
+
+                    function endReadable(stream) {
+                        var state = stream._readableState;
+
+                        // If we get here before consuming all the bytes, then that is a
+                        // bug in node.  Should never happen.
+                        if (state.length > 0) throw new Error(
+                            '"endReadable()" called on non-empty stream');
+
+                        if (!state.endEmitted) {
+                            state.ended = true;
+                            pna.nextTick(endReadableNT, state, stream);
+                        }
+                    }
+
+                    function endReadableNT(state, stream) {
+                        // Check that we didn't get one last unshift.
+                        if (!state.endEmitted && state.length === 0) {
+                            state.endEmitted = true;
+                            stream.readable = false;
+                            stream.emit('end');
+                        }
+                    }
+
+                    function indexOf(xs, x) {
+                        for (var i = 0, l = xs.length; i < l; i++) {
+                            if (xs[i] === x) return i;
+                        }
+                        return -1;
+                    }
+                }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !==
+                    "undefined" ? self : typeof window !== "undefined" ? window : {})
+            }, {
+                "./_stream_duplex": 135,
+                "./internal/streams/BufferList": 140,
+                "./internal/streams/destroy": 141,
+                "./internal/streams/stream": 142,
+                "_process": 125,
+                "core-util-is": 57,
+                "events": 90,
+                "inherits": 107,
+                "isarray": 109,
+                "process-nextick-args": 124,
+                "safe-buffer": 148,
+                "string_decoder/": 158,
+                "util": 26
+            }],
+            138: [function (require, module, exports) {
+                // Copyright Joyent, Inc. and other Node contributors.
+                //
+                // Permission is hereby granted, free of charge, to any person obtaining a
+                // copy of this software and associated documentation files (the
+                // "Software"), to deal in the Software without restriction, including
+                // without limitation the rights to use, copy, modify, merge, publish,
+                // distribute, sublicense, and/or sell copies of the Software, and to permit
+                // persons to whom the Software is furnished to do so, subject to the
+                // following conditions:
+                //
+                // The above copyright notice and this permission notice shall be included
+                // in all copies or substantial portions of the Software.
+                //
+                // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                // a transform stream is a readable/writable stream where you do
+                // something with the data.  Sometimes it's called a "filter",
+                // but that's not a great name for it, since that implies a thing where
+                // some bits pass through, and others are simply ignored.  (That would
+                // be a valid example of a transform, of course.)
+                //
+                // While the output is causally related to the input, it's not a
+                // necessarily symmetric or synchronous transformation.  For example,
+                // a zlib stream might take multiple plain-text writes(), and then
+                // emit a single compressed chunk some time in the future.
+                //
+                // Here's how this works:
+                //
+                // The Transform stream has all the aspects of the readable and writable
+                // stream classes.  When you write(chunk), that calls _write(chunk,cb)
+                // internally, and returns false if there's a lot of pending writes
+                // buffered up.  When you call read(), that calls _read(n) until
+                // there's enough pending readable data buffered up.
+                //
+                // In a transform stream, the written data is placed in a buffer.  When
+                // _read(n) is called, it transforms the queued up data, calling the
+                // buffered _write cb's as it consumes chunks.  If consuming a single
+                // written chunk would result in multiple output chunks, then the first
+                // outputted bit calls the readcb, and subsequent chunks just go into
+                // the read buffer, and will cause it to emit 'readable' if necessary.
+                //
+                // This way, back-pressure is actually determined by the reading side,
+                // since _read has to be called to start processing a new chunk.  However,
+                // a pathological inflate type of transform can cause excessive buffering
+                // here.  For example, imagine a stream where every byte of input is
+                // interpreted as an integer from 0-255, and then results in that many
+                // bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+                // 1kb of data being output.  In this case, you could write a very small
+                // amount of input, and end up with a very large amount of output.  In
+                // such a pathological inflating mechanism, there'd be no way to tell
+                // the system to stop doing the transform.  A single 4MB write could
+                // cause the system to run out of memory.
+                //
+                // However, even in such a pathological case, only a single written chunk
+                // would be consumed, and then the rest would wait (un-transformed) until
+                // the results of the previous transformed chunk were consumed.
+
+                'use strict';
+
+                module.exports = Transform;
+
+                var Duplex = require('./_stream_duplex');
+
+                /*<replacement>*/
+                var util = require('core-util-is');
+                util.inherits = require('inherits');
+                /*</replacement>*/
+
+                util.inherits(Transform, Duplex);
+
+                function afterTransform(er, data) {
+                    var ts = this._transformState;
+                    ts.transforming = false;
+
+                    var cb = ts.writecb;
+
+                    if (!cb) {
+                        return this.emit('error', new Error('write callback called multiple times'));
+                    }
+
+                    ts.writechunk = null;
+                    ts.writecb = null;
+
+                    if (data != null) // single equals check for both `null` and `undefined`
+                        this.push(data);
+
+                    cb(er);
+
+                    var rs = this._readableState;
+                    rs.reading = false;
+                    if (rs.needReadable || rs.length < rs.highWaterMark) {
+                        this._read(rs.highWaterMark);
+                    }
+                }
+
+                function Transform(options) {
+                    if (!(this instanceof Transform)) return new Transform(options);
+
+                    Duplex.call(this, options);
+
+                    this._transformState = {
+                        afterTransform: afterTransform.bind(this),
+                        needTransform: false,
+                        transforming: false,
+                        writecb: null,
+                        writechunk: null,
+                        writeencoding: null
+                    };
+
+                    // start out asking for a readable event once data is transformed.
+                    this._readableState.needReadable = true;
+
+                    // we have implemented the _read method, and done the other things
+                    // that Readable wants before the first _read call, so unset the
+                    // sync guard flag.
+                    this._readableState.sync = false;
+
+                    if (options) {
+                        if (typeof options.transform === 'function') this._transform = options.transform;
+
+                        if (typeof options.flush === 'function') this._flush = options.flush;
+                    }
+
+                    // When the writable side finishes, then flush out anything remaining.
+                    this.on('prefinish', prefinish);
+                }
+
+                function prefinish() {
+                    var _this = this;
+
+                    if (typeof this._flush === 'function') {
+                        this._flush(function (er, data) {
+                            done(_this, er, data);
+                        });
+                    } else {
+                        done(this, null, null);
+                    }
+                }
+
+                Transform.prototype.push = function (chunk, encoding) {
+                    this._transformState.needTransform = false;
+                    return Duplex.prototype.push.call(this, chunk, encoding);
+                };
+
+                // This is the part where you do stuff!
+                // override this function in implementation classes.
+                // 'chunk' is an input chunk.
+                //
+                // Call `push(newChunk)` to pass along transformed output
+                // to the readable side.  You may call 'push' zero or more times.
+                //
+                // Call `cb(err)` when you are done with this chunk.  If you pass
+                // an error, then that'll put the hurt on the whole operation.  If you
+                // never call cb(), then you'll never get another chunk.
+                Transform.prototype._transform = function (chunk, encoding, cb) {
+                    throw new Error('_transform() is not implemented');
+                };
+
+                Transform.prototype._write = function (chunk, encoding, cb) {
+                    var ts = this._transformState;
+                    ts.writecb = cb;
+                    ts.writechunk = chunk;
+                    ts.writeencoding = encoding;
+                    if (!ts.transforming) {
+                        var rs = this._readableState;
+                        if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(
+                            rs.highWaterMark);
+                    }
+                };
+
+                // Doesn't matter what the args are here.
+                // _transform does all the work.
+                // That we got here means that the readable side wants more data.
+                Transform.prototype._read = function (n) {
+                    var ts = this._transformState;
+
+                    if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+                        ts.transforming = true;
+                        this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+                    } else {
+                        // mark that we need a transform, so that any data that comes in
+                        // will get processed, now that we've asked for it.
+                        ts.needTransform = true;
+                    }
+                };
+
+                Transform.prototype._destroy = function (err, cb) {
+                    var _this2 = this;
+
+                    Duplex.prototype._destroy.call(this, err, function (err2) {
+                        cb(err2);
+                        _this2.emit('close');
+                    });
+                };
+
+                function done(stream, er, data) {
+                    if (er) return stream.emit('error', er);
+
+                    if (data != null) // single equals check for both `null` and `undefined`
+                        stream.push(data);
+
+                    // if there's nothing in the write buffer, then that means
+                    // that nothing more will ever be provided
+                    if (stream._writableState.length) throw new Error(
+                        'Calling transform done when ws.length != 0');
+
+                    if (stream._transformState.transforming) throw new Error(
+                        'Calling transform done when still transforming');
+
+                    return stream.push(null);
+                }
+            }, {
+                "./_stream_duplex": 135,
+                "core-util-is": 57,
+                "inherits": 107
+            }],
+            139: [function (require, module, exports) {
+                (function (process, global, setImmediate) {
+                    // Copyright Joyent, Inc. and other Node contributors.
+                    //
+                    // Permission is hereby granted, free of charge, to any person obtaining a
+                    // copy of this software and associated documentation files (the
+                    // "Software"), to deal in the Software without restriction, including
+                    // without limitation the rights to use, copy, modify, merge, publish,
+                    // distribute, sublicense, and/or sell copies of the Software, and to permit
+                    // persons to whom the Software is furnished to do so, subject to the
+                    // following conditions:
+                    //
+                    // The above copyright notice and this permission notice shall be included
+                    // in all copies or substantial portions of the Software.
+                    //
+                    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                    // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                    // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                    // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                    // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                    // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                    // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                    // A bit simpler than readable streams.
+                    // Implement an async ._write(chunk, encoding, cb), and it'll handle all
+                    // the drain event emission and buffering.
+
+                    'use strict';
+
+                    /*<replacement>*/
+
+                    var pna = require('process-nextick-args');
+                    /*</replacement>*/
+
+                    module.exports = Writable;
+
+                    /* <replacement> */
+                    function WriteReq(chunk, encoding, cb) {
+                        this.chunk = chunk;
+                        this.encoding = encoding;
+                        this.callback = cb;
+                        this.next = null;
+                    }
+
+                    // It seems a linked list but it is not
+                    // there will be only 2 of these for each stream
+                    function CorkedRequest(state) {
+                        var _this = this;
+
+                        this.next = null;
+                        this.entry = null;
+                        this.finish = function () {
+                            onCorkedFinish(_this, state);
+                        };
+                    }
+                    /* </replacement> */
+
+                    /*<replacement>*/
+                    var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(
+                        0, 5)) > -1 ? setImmediate : pna.nextTick;
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+                    var Duplex;
+                    /*</replacement>*/
+
+                    Writable.WritableState = WritableState;
+
+                    /*<replacement>*/
+                    var util = require('core-util-is');
+                    util.inherits = require('inherits');
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+                    var internalUtil = {
+                        deprecate: require('util-deprecate')
+                    };
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+                    var Stream = require('./internal/streams/stream');
+                    /*</replacement>*/
+
+                    /*<replacement>*/
+
+                    var Buffer = require('safe-buffer').Buffer;
+                    var OurUint8Array = global.Uint8Array || function () {};
+
+                    function _uint8ArrayToBuffer(chunk) {
+                        return Buffer.from(chunk);
+                    }
+
+                    function _isUint8Array(obj) {
+                        return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+                    }
+
+                    /*</replacement>*/
+
+                    var destroyImpl = require('./internal/streams/destroy');
+
+                    util.inherits(Writable, Stream);
+
+                    function nop() {}
+
+                    function WritableState(options, stream) {
+                        Duplex = Duplex || require('./_stream_duplex');
+
+                        options = options || {};
+
+                        // Duplex streams are both readable and writable, but share
+                        // the same options object.
+                        // However, some cases require setting options to different
+                        // values for the readable and the writable sides of the duplex stream.
+                        // These options can be provided separately as readableXXX and writableXXX.
+                        var isDuplex = stream instanceof Duplex;
+
+                        // object stream flag to indicate whether or not this stream
+                        // contains buffers or objects.
+                        this.objectMode = !!options.objectMode;
 
-  return this;
-};
-
-Node.prototype.optional = function optional() {
-  var state = this._baseState;
-
-  state.optional = true;
-
-  return this;
-};
-
-Node.prototype.def = function def(val) {
-  var state = this._baseState;
-
-  assert(state['default'] === null);
-  state['default'] = val;
-  state.optional = true;
-
-  return this;
-};
-
-Node.prototype.explicit = function explicit(num) {
-  var state = this._baseState;
-
-  assert(state.explicit === null && state.implicit === null);
-  state.explicit = num;
-
-  return this;
-};
-
-Node.prototype.implicit = function implicit(num) {
-  var state = this._baseState;
-
-  assert(state.explicit === null && state.implicit === null);
-  state.implicit = num;
-
-  return this;
-};
-
-Node.prototype.obj = function obj() {
-  var state = this._baseState;
-  var args = Array.prototype.slice.call(arguments);
-
-  state.obj = true;
-
-  if (args.length !== 0)
-    this._useArgs(args);
-
-  return this;
-};
-
-Node.prototype.key = function key(newKey) {
-  var state = this._baseState;
-
-  assert(state.key === null);
-  state.key = newKey;
-
-  return this;
-};
-
-Node.prototype.any = function any() {
-  var state = this._baseState;
-
-  state.any = true;
-
-  return this;
-};
-
-Node.prototype.choice = function choice(obj) {
-  var state = this._baseState;
-
-  assert(state.choice === null);
-  state.choice = obj;
-  this._useArgs(Object.keys(obj).map(function(key) {
-    return obj[key];
-  }));
-
-  return this;
-};
-
-Node.prototype.contains = function contains(item) {
-  var state = this._baseState;
-
-  assert(state.use === null);
-  state.contains = item;
-
-  return this;
-};
-
-//
-// Decoding
-//
-
-Node.prototype._decode = function decode(input, options) {
-  var state = this._baseState;
-
-  // Decode root node
-  if (state.parent === null)
-    return input.wrapResult(state.children[0]._decode(input, options));
-
-  var result = state['default'];
-  var present = true;
-
-  var prevKey = null;
-  if (state.key !== null)
-    prevKey = input.enterKey(state.key);
-
-  // Check if tag is there
-  if (state.optional) {
-    var tag = null;
-    if (state.explicit !== null)
-      tag = state.explicit;
-    else if (state.implicit !== null)
-      tag = state.implicit;
-    else if (state.tag !== null)
-      tag = state.tag;
-
-    if (tag === null && !state.any) {
-      // Trial and Error
-      var save = input.save();
-      try {
-        if (state.choice === null)
-          this._decodeGeneric(state.tag, input, options);
-        else
-          this._decodeChoice(input, options);
-        present = true;
-      } catch (e) {
-        present = false;
-      }
-      input.restore(save);
-    } else {
-      present = this._peekTag(input, tag, state.any);
-
-      if (input.isError(present))
-        return present;
-    }
-  }
-
-  // Push object on stack
-  var prevObj;
-  if (state.obj && present)
-    prevObj = input.enterObject();
-
-  if (present) {
-    // Unwrap explicit values
-    if (state.explicit !== null) {
-      var explicit = this._decodeTag(input, state.explicit);
-      if (input.isError(explicit))
-        return explicit;
-      input = explicit;
-    }
-
-    var start = input.offset;
-
-    // Unwrap implicit and normal values
-    if (state.use === null && state.choice === null) {
-      if (state.any)
-        var save = input.save();
-      var body = this._decodeTag(
-        input,
-        state.implicit !== null ? state.implicit : state.tag,
-        state.any
-      );
-      if (input.isError(body))
-        return body;
-
-      if (state.any)
-        result = input.raw(save);
-      else
-        input = body;
-    }
-
-    if (options && options.track && state.tag !== null)
-      options.track(input.path(), start, input.length, 'tagged');
-
-    if (options && options.track && state.tag !== null)
-      options.track(input.path(), input.offset, input.length, 'content');
-
-    // Select proper method for tag
-    if (state.any)
-      result = result;
-    else if (state.choice === null)
-      result = this._decodeGeneric(state.tag, input, options);
-    else
-      result = this._decodeChoice(input, options);
-
-    if (input.isError(result))
-      return result;
-
-    // Decode children
-    if (!state.any && state.choice === null && state.children !== null) {
-      state.children.forEach(function decodeChildren(child) {
-        // NOTE: We are ignoring errors here, to let parser continue with other
-        // parts of encoded data
-        child._decode(input, options);
-      });
-    }
-
-    // Decode contained/encoded by schema, only in bit or octet strings
-    if (state.contains && (state.tag === 'octstr' || state.tag === 'bitstr')) {
-      var data = new DecoderBuffer(result);
-      result = this._getUse(state.contains, input._reporterState.obj)
-          ._decode(data, options);
-    }
-  }
-
-  // Pop object
-  if (state.obj && present)
-    result = input.leaveObject(prevObj);
-
-  // Set key
-  if (state.key !== null && (result !== null || present === true))
-    input.leaveKey(prevKey, state.key, result);
-  else if (prevKey !== null)
-    input.exitKey(prevKey);
-
-  return result;
-};
-
-Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
-  var state = this._baseState;
-
-  if (tag === 'seq' || tag === 'set')
-    return null;
-  if (tag === 'seqof' || tag === 'setof')
-    return this._decodeList(input, tag, state.args[0], options);
-  else if (/str$/.test(tag))
-    return this._decodeStr(input, tag, options);
-  else if (tag === 'objid' && state.args)
-    return this._decodeObjid(input, state.args[0], state.args[1], options);
-  else if (tag === 'objid')
-    return this._decodeObjid(input, null, null, options);
-  else if (tag === 'gentime' || tag === 'utctime')
-    return this._decodeTime(input, tag, options);
-  else if (tag === 'null_')
-    return this._decodeNull(input, options);
-  else if (tag === 'bool')
-    return this._decodeBool(input, options);
-  else if (tag === 'objDesc')
-    return this._decodeStr(input, tag, options);
-  else if (tag === 'int' || tag === 'enum')
-    return this._decodeInt(input, state.args && state.args[0], options);
-
-  if (state.use !== null) {
-    return this._getUse(state.use, input._reporterState.obj)
-        ._decode(input, options);
-  } else {
-    return input.error('unknown tag: ' + tag);
-  }
-};
-
-Node.prototype._getUse = function _getUse(entity, obj) {
-
-  var state = this._baseState;
-  // Create altered use decoder if implicit is set
-  state.useDecoder = this._use(entity, obj);
-  assert(state.useDecoder._baseState.parent === null);
-  state.useDecoder = state.useDecoder._baseState.children[0];
-  if (state.implicit !== state.useDecoder._baseState.implicit) {
-    state.useDecoder = state.useDecoder.clone();
-    state.useDecoder._baseState.implicit = state.implicit;
-  }
-  return state.useDecoder;
-};
-
-Node.prototype._decodeChoice = function decodeChoice(input, options) {
-  var state = this._baseState;
-  var result = null;
-  var match = false;
-
-  Object.keys(state.choice).some(function(key) {
-    var save = input.save();
-    var node = state.choice[key];
-    try {
-      var value = node._decode(input, options);
-      if (input.isError(value))
-        return false;
-
-      result = { type: key, value: value };
-      match = true;
-    } catch (e) {
-      input.restore(save);
-      return false;
-    }
-    return true;
-  }, this);
-
-  if (!match)
-    return input.error('Choice not matched');
-
-  return result;
-};
-
-//
-// Encoding
-//
-
-Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
-  return new EncoderBuffer(data, this.reporter);
-};
-
-Node.prototype._encode = function encode(data, reporter, parent) {
-  var state = this._baseState;
-  if (state['default'] !== null && state['default'] === data)
-    return;
-
-  var result = this._encodeValue(data, reporter, parent);
-  if (result === undefined)
-    return;
-
-  if (this._skipDefault(result, reporter, parent))
-    return;
-
-  return result;
-};
-
-Node.prototype._encodeValue = function encode(data, reporter, parent) {
-  var state = this._baseState;
-
-  // Decode root node
-  if (state.parent === null)
-    return state.children[0]._encode(data, reporter || new Reporter());
-
-  var result = null;
-
-  // Set reporter to share it with a child class
-  this.reporter = reporter;
-
-  // Check if data is there
-  if (state.optional && data === undefined) {
-    if (state['default'] !== null)
-      data = state['default']
-    else
-      return;
-  }
-
-  // Encode children first
-  var content = null;
-  var primitive = false;
-  if (state.any) {
-    // Anything that was given is translated to buffer
-    result = this._createEncoderBuffer(data);
-  } else if (state.choice) {
-    result = this._encodeChoice(data, reporter);
-  } else if (state.contains) {
-    content = this._getUse(state.contains, parent)._encode(data, reporter);
-    primitive = true;
-  } else if (state.children) {
-    content = state.children.map(function(child) {
-      if (child._baseState.tag === 'null_')
-        return child._encode(null, reporter, data);
-
-      if (child._baseState.key === null)
-        return reporter.error('Child should have a key');
-      var prevKey = reporter.enterKey(child._baseState.key);
-
-      if (typeof data !== 'object')
-        return reporter.error('Child expected, but input is not object');
-
-      var res = child._encode(data[child._baseState.key], reporter, data);
-      reporter.leaveKey(prevKey);
-
-      return res;
-    }, this).filter(function(child) {
-      return child;
-    });
-    content = this._createEncoderBuffer(content);
-  } else {
-    if (state.tag === 'seqof' || state.tag === 'setof') {
-      // TODO(indutny): this should be thrown on DSL level
-      if (!(state.args && state.args.length === 1))
-        return reporter.error('Too many args for : ' + state.tag);
-
-      if (!Array.isArray(data))
-        return reporter.error('seqof/setof, but data is not Array');
-
-      var child = this.clone();
-      child._baseState.implicit = null;
-      content = this._createEncoderBuffer(data.map(function(item) {
-        var state = this._baseState;
-
-        return this._getUse(state.args[0], data)._encode(item, reporter);
-      }, child));
-    } else if (state.use !== null) {
-      result = this._getUse(state.use, parent)._encode(data, reporter);
-    } else {
-      content = this._encodePrimitive(state.tag, data);
-      primitive = true;
-    }
-  }
-
-  // Encode data itself
-  var result;
-  if (!state.any && state.choice === null) {
-    var tag = state.implicit !== null ? state.implicit : state.tag;
-    var cls = state.implicit === null ? 'universal' : 'context';
-
-    if (tag === null) {
-      if (state.use === null)
-        reporter.error('Tag could be omitted only for .use()');
-    } else {
-      if (state.use === null)
-        result = this._encodeComposite(tag, primitive, cls, content);
-    }
-  }
-
-  // Wrap in explicit
-  if (state.explicit !== null)
-    result = this._encodeComposite(state.explicit, false, 'context', result);
-
-  return result;
-};
-
-Node.prototype._encodeChoice = function encodeChoice(data, reporter) {
-  var state = this._baseState;
-
-  var node = state.choice[data.type];
-  if (!node) {
-    assert(
-        false,
-        data.type + ' not found in ' +
-            JSON.stringify(Object.keys(state.choice)));
-  }
-  return node._encode(data.value, reporter);
-};
-
-Node.prototype._encodePrimitive = function encodePrimitive(tag, data) {
-  var state = this._baseState;
-
-  if (/str$/.test(tag))
-    return this._encodeStr(data, tag);
-  else if (tag === 'objid' && state.args)
-    return this._encodeObjid(data, state.reverseArgs[0], state.args[1]);
-  else if (tag === 'objid')
-    return this._encodeObjid(data, null, null);
-  else if (tag === 'gentime' || tag === 'utctime')
-    return this._encodeTime(data, tag);
-  else if (tag === 'null_')
-    return this._encodeNull();
-  else if (tag === 'int' || tag === 'enum')
-    return this._encodeInt(data, state.args && state.reverseArgs[0]);
-  else if (tag === 'bool')
-    return this._encodeBool(data);
-  else if (tag === 'objDesc')
-    return this._encodeStr(data, tag);
-  else
-    throw new Error('Unsupported tag: ' + tag);
-};
-
-Node.prototype._isNumstr = function isNumstr(str) {
-  return /^[0-9 ]*$/.test(str);
-};
-
-Node.prototype._isPrintstr = function isPrintstr(str) {
-  return /^[A-Za-z0-9 '\(\)\+,\-\.\/:=\?]*$/.test(str);
-};
-
-},{"../base":12,"minimalistic-assert":112}],14:[function(require,module,exports){
-var inherits = require('inherits');
-
-function Reporter(options) {
-  this._reporterState = {
-    obj: null,
-    path: [],
-    options: options || {},
-    errors: []
-  };
-}
-exports.Reporter = Reporter;
-
-Reporter.prototype.isError = function isError(obj) {
-  return obj instanceof ReporterError;
-};
-
-Reporter.prototype.save = function save() {
-  var state = this._reporterState;
-
-  return { obj: state.obj, pathLen: state.path.length };
-};
-
-Reporter.prototype.restore = function restore(data) {
-  var state = this._reporterState;
-
-  state.obj = data.obj;
-  state.path = state.path.slice(0, data.pathLen);
-};
-
-Reporter.prototype.enterKey = function enterKey(key) {
-  return this._reporterState.path.push(key);
-};
-
-Reporter.prototype.exitKey = function exitKey(index) {
-  var state = this._reporterState;
-
-  state.path = state.path.slice(0, index - 1);
-};
-
-Reporter.prototype.leaveKey = function leaveKey(index, key, value) {
-  var state = this._reporterState;
-
-  this.exitKey(index);
-  if (state.obj !== null)
-    state.obj[key] = value;
-};
-
-Reporter.prototype.path = function path() {
-  return this._reporterState.path.join('/');
-};
-
-Reporter.prototype.enterObject = function enterObject() {
-  var state = this._reporterState;
-
-  var prev = state.obj;
-  state.obj = {};
-  return prev;
-};
-
-Reporter.prototype.leaveObject = function leaveObject(prev) {
-  var state = this._reporterState;
-
-  var now = state.obj;
-  state.obj = prev;
-  return now;
-};
-
-Reporter.prototype.error = function error(msg) {
-  var err;
-  var state = this._reporterState;
-
-  var inherited = msg instanceof ReporterError;
-  if (inherited) {
-    err = msg;
-  } else {
-    err = new ReporterError(state.path.map(function(elem) {
-      return '[' + JSON.stringify(elem) + ']';
-    }).join(''), msg.message || msg, msg.stack);
-  }
-
-  if (!state.options.partial)
-    throw err;
-
-  if (!inherited)
-    state.errors.push(err);
-
-  return err;
-};
-
-Reporter.prototype.wrapResult = function wrapResult(result) {
-  var state = this._reporterState;
-  if (!state.options.partial)
-    return result;
-
-  return {
-    result: this.isError(result) ? null : result,
-    errors: state.errors
-  };
-};
-
-function ReporterError(path, msg) {
-  this.path = path;
-  this.rethrow(msg);
-};
-inherits(ReporterError, Error);
-
-ReporterError.prototype.rethrow = function rethrow(msg) {
-  this.message = msg + ' at: ' + (this.path || '(shallow)');
-  if (Error.captureStackTrace)
-    Error.captureStackTrace(this, ReporterError);
-
-  if (!this.stack) {
-    try {
-      // IE only adds stack when thrown
-      throw new Error(this.message);
-    } catch (e) {
-      this.stack = e.stack;
-    }
-  }
-  return this;
-};
-
-},{"inherits":107}],15:[function(require,module,exports){
-var constants = require('../constants');
-
-exports.tagClass = {
-  0: 'universal',
-  1: 'application',
-  2: 'context',
-  3: 'private'
-};
-exports.tagClassByName = constants._reverse(exports.tagClass);
-
-exports.tag = {
-  0x00: 'end',
-  0x01: 'bool',
-  0x02: 'int',
-  0x03: 'bitstr',
-  0x04: 'octstr',
-  0x05: 'null_',
-  0x06: 'objid',
-  0x07: 'objDesc',
-  0x08: 'external',
-  0x09: 'real',
-  0x0a: 'enum',
-  0x0b: 'embed',
-  0x0c: 'utf8str',
-  0x0d: 'relativeOid',
-  0x10: 'seq',
-  0x11: 'set',
-  0x12: 'numstr',
-  0x13: 'printstr',
-  0x14: 't61str',
-  0x15: 'videostr',
-  0x16: 'ia5str',
-  0x17: 'utctime',
-  0x18: 'gentime',
-  0x19: 'graphstr',
-  0x1a: 'iso646str',
-  0x1b: 'genstr',
-  0x1c: 'unistr',
-  0x1d: 'charstr',
-  0x1e: 'bmpstr'
-};
-exports.tagByName = constants._reverse(exports.tag);
-
-},{"../constants":16}],16:[function(require,module,exports){
-var constants = exports;
-
-// Helper
-constants._reverse = function reverse(map) {
-  var res = {};
-
-  Object.keys(map).forEach(function(key) {
-    // Convert key to integer if it is stringified
-    if ((key | 0) == key)
-      key = key | 0;
-
-    var value = map[key];
-    res[value] = key;
-  });
-
-  return res;
-};
-
-constants.der = require('./der');
-
-},{"./der":15}],17:[function(require,module,exports){
-var inherits = require('inherits');
-
-var asn1 = require('../../asn1');
-var base = asn1.base;
-var bignum = asn1.bignum;
-
-// Import DER constants
-var der = asn1.constants.der;
-
-function DERDecoder(entity) {
-  this.enc = 'der';
-  this.name = entity.name;
-  this.entity = entity;
-
-  // Construct base tree
-  this.tree = new DERNode();
-  this.tree._init(entity.body);
-};
-module.exports = DERDecoder;
-
-DERDecoder.prototype.decode = function decode(data, options) {
-  if (!(data instanceof base.DecoderBuffer))
-    data = new base.DecoderBuffer(data, options);
-
-  return this.tree._decode(data, options);
-};
-
-// Tree methods
-
-function DERNode(parent) {
-  base.Node.call(this, 'der', parent);
-}
-inherits(DERNode, base.Node);
-
-DERNode.prototype._peekTag = function peekTag(buffer, tag, any) {
-  if (buffer.isEmpty())
-    return false;
-
-  var state = buffer.save();
-  var decodedTag = derDecodeTag(buffer, 'Failed to peek tag: "' + tag + '"');
-  if (buffer.isError(decodedTag))
-    return decodedTag;
-
-  buffer.restore(state);
-
-  return decodedTag.tag === tag || decodedTag.tagStr === tag ||
-    (decodedTag.tagStr + 'of') === tag || any;
-};
-
-DERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {
-  var decodedTag = derDecodeTag(buffer,
-                                'Failed to decode tag of "' + tag + '"');
-  if (buffer.isError(decodedTag))
-    return decodedTag;
-
-  var len = derDecodeLen(buffer,
-                         decodedTag.primitive,
-                         'Failed to get length of "' + tag + '"');
-
-  // Failure
-  if (buffer.isError(len))
-    return len;
-
-  if (!any &&
-      decodedTag.tag !== tag &&
-      decodedTag.tagStr !== tag &&
-      decodedTag.tagStr + 'of' !== tag) {
-    return buffer.error('Failed to match tag: "' + tag + '"');
-  }
-
-  if (decodedTag.primitive || len !== null)
-    return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
-
-  // Indefinite length... find END tag
-  var state = buffer.save();
-  var res = this._skipUntilEnd(
-      buffer,
-      'Failed to skip indefinite length body: "' + this.tag + '"');
-  if (buffer.isError(res))
-    return res;
-
-  len = buffer.offset - state.offset;
-  buffer.restore(state);
-  return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
-};
-
-DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {
-  while (true) {
-    var tag = derDecodeTag(buffer, fail);
-    if (buffer.isError(tag))
-      return tag;
-    var len = derDecodeLen(buffer, tag.primitive, fail);
-    if (buffer.isError(len))
-      return len;
-
-    var res;
-    if (tag.primitive || len !== null)
-      res = buffer.skip(len)
-    else
-      res = this._skipUntilEnd(buffer, fail);
-
-    // Failure
-    if (buffer.isError(res))
-      return res;
-
-    if (tag.tagStr === 'end')
-      break;
-  }
-};
-
-DERNode.prototype._decodeList = function decodeList(buffer, tag, decoder,
-                                                    options) {
-  var result = [];
-  while (!buffer.isEmpty()) {
-    var possibleEnd = this._peekTag(buffer, 'end');
-    if (buffer.isError(possibleEnd))
-      return possibleEnd;
-
-    var res = decoder.decode(buffer, 'der', options);
-    if (buffer.isError(res) && possibleEnd)
-      break;
-    result.push(res);
-  }
-  return result;
-};
-
-DERNode.prototype._decodeStr = function decodeStr(buffer, tag) {
-  if (tag === 'bitstr') {
-    var unused = buffer.readUInt8();
-    if (buffer.isError(unused))
-      return unused;
-    return { unused: unused, data: buffer.raw() };
-  } else if (tag === 'bmpstr') {
-    var raw = buffer.raw();
-    if (raw.length % 2 === 1)
-      return buffer.error('Decoding of string type: bmpstr length mismatch');
-
-    var str = '';
-    for (var i = 0; i < raw.length / 2; i++) {
-      str += String.fromCharCode(raw.readUInt16BE(i * 2));
-    }
-    return str;
-  } else if (tag === 'numstr') {
-    var numstr = buffer.raw().toString('ascii');
-    if (!this._isNumstr(numstr)) {
-      return buffer.error('Decoding of string type: ' +
-                          'numstr unsupported characters');
-    }
-    return numstr;
-  } else if (tag === 'octstr') {
-    return buffer.raw();
-  } else if (tag === 'objDesc') {
-    return buffer.raw();
-  } else if (tag === 'printstr') {
-    var printstr = buffer.raw().toString('ascii');
-    if (!this._isPrintstr(printstr)) {
-      return buffer.error('Decoding of string type: ' +
-                          'printstr unsupported characters');
-    }
-    return printstr;
-  } else if (/str$/.test(tag)) {
-    return buffer.raw().toString();
-  } else {
-    return buffer.error('Decoding of string type: ' + tag + ' unsupported');
-  }
-};
-
-DERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {
-  var result;
-  var identifiers = [];
-  var ident = 0;
-  while (!buffer.isEmpty()) {
-    var subident = buffer.readUInt8();
-    ident <<= 7;
-    ident |= subident & 0x7f;
-    if ((subident & 0x80) === 0) {
-      identifiers.push(ident);
-      ident = 0;
-    }
-  }
-  if (subident & 0x80)
-    identifiers.push(ident);
-
-  var first = (identifiers[0] / 40) | 0;
-  var second = identifiers[0] % 40;
-
-  if (relative)
-    result = identifiers;
-  else
-    result = [first, second].concat(identifiers.slice(1));
-
-  if (values) {
-    var tmp = values[result.join(' ')];
-    if (tmp === undefined)
-      tmp = values[result.join('.')];
-    if (tmp !== undefined)
-      result = tmp;
-  }
-
-  return result;
-};
-
-DERNode.prototype._decodeTime = function decodeTime(buffer, tag) {
-  var str = buffer.raw().toString();
-  if (tag === 'gentime') {
-    var year = str.slice(0, 4) | 0;
-    var mon = str.slice(4, 6) | 0;
-    var day = str.slice(6, 8) | 0;
-    var hour = str.slice(8, 10) | 0;
-    var min = str.slice(10, 12) | 0;
-    var sec = str.slice(12, 14) | 0;
-  } else if (tag === 'utctime') {
-    var year = str.slice(0, 2) | 0;
-    var mon = str.slice(2, 4) | 0;
-    var day = str.slice(4, 6) | 0;
-    var hour = str.slice(6, 8) | 0;
-    var min = str.slice(8, 10) | 0;
-    var sec = str.slice(10, 12) | 0;
-    if (year < 70)
-      year = 2000 + year;
-    else
-      year = 1900 + year;
-  } else {
-    return buffer.error('Decoding ' + tag + ' time is not supported yet');
-  }
-
-  return Date.UTC(year, mon - 1, day, hour, min, sec, 0);
-};
-
-DERNode.prototype._decodeNull = function decodeNull(buffer) {
-  return null;
-};
-
-DERNode.prototype._decodeBool = function decodeBool(buffer) {
-  var res = buffer.readUInt8();
-  if (buffer.isError(res))
-    return res;
-  else
-    return res !== 0;
-};
-
-DERNode.prototype._decodeInt = function decodeInt(buffer, values) {
-  // Bigint, return as it is (assume big endian)
-  var raw = buffer.raw();
-  var res = new bignum(raw);
-
-  if (values)
-    res = values[res.toString(10)] || res;
-
-  return res;
-};
-
-DERNode.prototype._use = function use(entity, obj) {
-  if (typeof entity === 'function')
-    entity = entity(obj);
-  return entity._getDecoder('der').tree;
-};
-
-// Utility methods
-
-function derDecodeTag(buf, fail) {
-  var tag = buf.readUInt8(fail);
-  if (buf.isError(tag))
-    return tag;
-
-  var cls = der.tagClass[tag >> 6];
-  var primitive = (tag & 0x20) === 0;
-
-  // Multi-octet tag - load
-  if ((tag & 0x1f) === 0x1f) {
-    var oct = tag;
-    tag = 0;
-    while ((oct & 0x80) === 0x80) {
-      oct = buf.readUInt8(fail);
-      if (buf.isError(oct))
-        return oct;
-
-      tag <<= 7;
-      tag |= oct & 0x7f;
-    }
-  } else {
-    tag &= 0x1f;
-  }
-  var tagStr = der.tag[tag];
-
-  return {
-    cls: cls,
-    primitive: primitive,
-    tag: tag,
-    tagStr: tagStr
-  };
-}
-
-function derDecodeLen(buf, primitive, fail) {
-  var len = buf.readUInt8(fail);
-  if (buf.isError(len))
-    return len;
-
-  // Indefinite form
-  if (!primitive && len === 0x80)
-    return null;
-
-  // Definite form
-  if ((len & 0x80) === 0) {
-    // Short form
-    return len;
-  }
-
-  // Long form
-  var num = len & 0x7f;
-  if (num > 4)
-    return buf.error('length octect is too long');
-
-  len = 0;
-  for (var i = 0; i < num; i++) {
-    len <<= 8;
-    var j = buf.readUInt8(fail);
-    if (buf.isError(j))
-      return j;
-    len |= j;
-  }
-
-  return len;
-}
-
-},{"../../asn1":9,"inherits":107}],18:[function(require,module,exports){
-var decoders = exports;
-
-decoders.der = require('./der');
-decoders.pem = require('./pem');
-
-},{"./der":17,"./pem":19}],19:[function(require,module,exports){
-var inherits = require('inherits');
-var Buffer = require('buffer').Buffer;
-
-var DERDecoder = require('./der');
-
-function PEMDecoder(entity) {
-  DERDecoder.call(this, entity);
-  this.enc = 'pem';
-};
-inherits(PEMDecoder, DERDecoder);
-module.exports = PEMDecoder;
-
-PEMDecoder.prototype.decode = function decode(data, options) {
-  var lines = data.toString().split(/[\r\n]+/g);
-
-  var label = options.label.toUpperCase();
-
-  var re = /^-----(BEGIN|END) ([^-]+)-----$/;
-  var start = -1;
-  var end = -1;
-  for (var i = 0; i < lines.length; i++) {
-    var match = lines[i].match(re);
-    if (match === null)
-      continue;
-
-    if (match[2] !== label)
-      continue;
-
-    if (start === -1) {
-      if (match[1] !== 'BEGIN')
-        break;
-      start = i;
-    } else {
-      if (match[1] !== 'END')
-        break;
-      end = i;
-      break;
-    }
-  }
-  if (start === -1 || end === -1)
-    throw new Error('PEM section not found for: ' + label);
-
-  var base64 = lines.slice(start + 1, end).join('');
-  // Remove excessive symbols
-  base64.replace(/[^a-z0-9\+\/=]+/gi, '');
-
-  var input = new Buffer(base64, 'base64');
-  return DERDecoder.prototype.decode.call(this, input, options);
-};
-
-},{"./der":17,"buffer":55,"inherits":107}],20:[function(require,module,exports){
-var inherits = require('inherits');
-var Buffer = require('buffer').Buffer;
-
-var asn1 = require('../../asn1');
-var base = asn1.base;
-
-// Import DER constants
-var der = asn1.constants.der;
-
-function DEREncoder(entity) {
-  this.enc = 'der';
-  this.name = entity.name;
-  this.entity = entity;
-
-  // Construct base tree
-  this.tree = new DERNode();
-  this.tree._init(entity.body);
-};
-module.exports = DEREncoder;
-
-DEREncoder.prototype.encode = function encode(data, reporter) {
-  return this.tree._encode(data, reporter).join();
-};
-
-// Tree methods
-
-function DERNode(parent) {
-  base.Node.call(this, 'der', parent);
-}
-inherits(DERNode, base.Node);
-
-DERNode.prototype._encodeComposite = function encodeComposite(tag,
-                                                              primitive,
-                                                              cls,
-                                                              content) {
-  var encodedTag = encodeTag(tag, primitive, cls, this.reporter);
-
-  // Short form
-  if (content.length < 0x80) {
-    var header = new Buffer(2);
-    header[0] = encodedTag;
-    header[1] = content.length;
-    return this._createEncoderBuffer([ header, content ]);
-  }
-
-  // Long form
-  // Count octets required to store length
-  var lenOctets = 1;
-  for (var i = content.length; i >= 0x100; i >>= 8)
-    lenOctets++;
-
-  var header = new Buffer(1 + 1 + lenOctets);
-  header[0] = encodedTag;
-  header[1] = 0x80 | lenOctets;
-
-  for (var i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8)
-    header[i] = j & 0xff;
-
-  return this._createEncoderBuffer([ header, content ]);
-};
-
-DERNode.prototype._encodeStr = function encodeStr(str, tag) {
-  if (tag === 'bitstr') {
-    return this._createEncoderBuffer([ str.unused | 0, str.data ]);
-  } else if (tag === 'bmpstr') {
-    var buf = new Buffer(str.length * 2);
-    for (var i = 0; i < str.length; i++) {
-      buf.writeUInt16BE(str.charCodeAt(i), i * 2);
-    }
-    return this._createEncoderBuffer(buf);
-  } else if (tag === 'numstr') {
-    if (!this._isNumstr(str)) {
-      return this.reporter.error('Encoding of string type: numstr supports ' +
-                                 'only digits and space');
-    }
-    return this._createEncoderBuffer(str);
-  } else if (tag === 'printstr') {
-    if (!this._isPrintstr(str)) {
-      return this.reporter.error('Encoding of string type: printstr supports ' +
-                                 'only latin upper and lower case letters, ' +
-                                 'digits, space, apostrophe, left and rigth ' +
-                                 'parenthesis, plus sign, comma, hyphen, ' +
-                                 'dot, slash, colon, equal sign, ' +
-                                 'question mark');
-    }
-    return this._createEncoderBuffer(str);
-  } else if (/str$/.test(tag)) {
-    return this._createEncoderBuffer(str);
-  } else if (tag === 'objDesc') {
-    return this._createEncoderBuffer(str);
-  } else {
-    return this.reporter.error('Encoding of string type: ' + tag +
-                               ' unsupported');
-  }
-};
-
-DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {
-  if (typeof id === 'string') {
-    if (!values)
-      return this.reporter.error('string objid given, but no values map found');
-    if (!values.hasOwnProperty(id))
-      return this.reporter.error('objid not found in values map');
-    id = values[id].split(/[\s\.]+/g);
-    for (var i = 0; i < id.length; i++)
-      id[i] |= 0;
-  } else if (Array.isArray(id)) {
-    id = id.slice();
-    for (var i = 0; i < id.length; i++)
-      id[i] |= 0;
-  }
-
-  if (!Array.isArray(id)) {
-    return this.reporter.error('objid() should be either array or string, ' +
-                               'got: ' + JSON.stringify(id));
-  }
-
-  if (!relative) {
-    if (id[1] >= 40)
-      return this.reporter.error('Second objid identifier OOB');
-    id.splice(0, 2, id[0] * 40 + id[1]);
-  }
-
-  // Count number of octets
-  var size = 0;
-  for (var i = 0; i < id.length; i++) {
-    var ident = id[i];
-    for (size++; ident >= 0x80; ident >>= 7)
-      size++;
-  }
-
-  var objid = new Buffer(size);
-  var offset = objid.length - 1;
-  for (var i = id.length - 1; i >= 0; i--) {
-    var ident = id[i];
-    objid[offset--] = ident & 0x7f;
-    while ((ident >>= 7) > 0)
-      objid[offset--] = 0x80 | (ident & 0x7f);
-  }
-
-  return this._createEncoderBuffer(objid);
-};
-
-function two(num) {
-  if (num < 10)
-    return '0' + num;
-  else
-    return num;
-}
-
-DERNode.prototype._encodeTime = function encodeTime(time, tag) {
-  var str;
-  var date = new Date(time);
-
-  if (tag === 'gentime') {
-    str = [
-      two(date.getFullYear()),
-      two(date.getUTCMonth() + 1),
-      two(date.getUTCDate()),
-      two(date.getUTCHours()),
-      two(date.getUTCMinutes()),
-      two(date.getUTCSeconds()),
-      'Z'
-    ].join('');
-  } else if (tag === 'utctime') {
-    str = [
-      two(date.getFullYear() % 100),
-      two(date.getUTCMonth() + 1),
-      two(date.getUTCDate()),
-      two(date.getUTCHours()),
-      two(date.getUTCMinutes()),
-      two(date.getUTCSeconds()),
-      'Z'
-    ].join('');
-  } else {
-    this.reporter.error('Encoding ' + tag + ' time is not supported yet');
-  }
-
-  return this._encodeStr(str, 'octstr');
-};
-
-DERNode.prototype._encodeNull = function encodeNull() {
-  return this._createEncoderBuffer('');
-};
-
-DERNode.prototype._encodeInt = function encodeInt(num, values) {
-  if (typeof num === 'string') {
-    if (!values)
-      return this.reporter.error('String int or enum given, but no values map');
-    if (!values.hasOwnProperty(num)) {
-      return this.reporter.error('Values map doesn\'t contain: ' +
-                                 JSON.stringify(num));
-    }
-    num = values[num];
-  }
-
-  // Bignum, assume big endian
-  if (typeof num !== 'number' && !Buffer.isBuffer(num)) {
-    var numArray = num.toArray();
-    if (!num.sign && numArray[0] & 0x80) {
-      numArray.unshift(0);
-    }
-    num = new Buffer(numArray);
-  }
-
-  if (Buffer.isBuffer(num)) {
-    var size = num.length;
-    if (num.length === 0)
-      size++;
-
-    var out = new Buffer(size);
-    num.copy(out);
-    if (num.length === 0)
-      out[0] = 0
-    return this._createEncoderBuffer(out);
-  }
-
-  if (num < 0x80)
-    return this._createEncoderBuffer(num);
-
-  if (num < 0x100)
-    return this._createEncoderBuffer([0, num]);
-
-  var size = 1;
-  for (var i = num; i >= 0x100; i >>= 8)
-    size++;
-
-  var out = new Array(size);
-  for (var i = out.length - 1; i >= 0; i--) {
-    out[i] = num & 0xff;
-    num >>= 8;
-  }
-  if(out[0] & 0x80) {
-    out.unshift(0);
-  }
-
-  return this._createEncoderBuffer(new Buffer(out));
-};
-
-DERNode.prototype._encodeBool = function encodeBool(value) {
-  return this._createEncoderBuffer(value ? 0xff : 0);
-};
-
-DERNode.prototype._use = function use(entity, obj) {
-  if (typeof entity === 'function')
-    entity = entity(obj);
-  return entity._getEncoder('der').tree;
-};
-
-DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) {
-  var state = this._baseState;
-  var i;
-  if (state['default'] === null)
-    return false;
-
-  var data = dataBuffer.join();
-  if (state.defaultBuffer === undefined)
-    state.defaultBuffer = this._encodeValue(state['default'], reporter, parent).join();
-
-  if (data.length !== state.defaultBuffer.length)
-    return false;
-
-  for (i=0; i < data.length; i++)
-    if (data[i] !== state.defaultBuffer[i])
-      return false;
-
-  return true;
-};
-
-// Utility methods
-
-function encodeTag(tag, primitive, cls, reporter) {
-  var res;
-
-  if (tag === 'seqof')
-    tag = 'seq';
-  else if (tag === 'setof')
-    tag = 'set';
-
-  if (der.tagByName.hasOwnProperty(tag))
-    res = der.tagByName[tag];
-  else if (typeof tag === 'number' && (tag | 0) === tag)
-    res = tag;
-  else
-    return reporter.error('Unknown tag: ' + tag);
-
-  if (res >= 0x1f)
-    return reporter.error('Multi-octet tag encoding unsupported');
-
-  if (!primitive)
-    res |= 0x20;
-
-  res |= (der.tagClassByName[cls || 'universal'] << 6);
-
-  return res;
-}
-
-},{"../../asn1":9,"buffer":55,"inherits":107}],21:[function(require,module,exports){
-var encoders = exports;
-
-encoders.der = require('./der');
-encoders.pem = require('./pem');
-
-},{"./der":20,"./pem":22}],22:[function(require,module,exports){
-var inherits = require('inherits');
-
-var DEREncoder = require('./der');
-
-function PEMEncoder(entity) {
-  DEREncoder.call(this, entity);
-  this.enc = 'pem';
-};
-inherits(PEMEncoder, DEREncoder);
-module.exports = PEMEncoder;
-
-PEMEncoder.prototype.encode = function encode(data, options) {
-  var buf = DEREncoder.prototype.encode.call(this, data);
-
-  var p = buf.toString('base64');
-  var out = [ '-----BEGIN ' + options.label + '-----' ];
-  for (var i = 0; i < p.length; i += 64)
-    out.push(p.slice(i, i + 64));
-  out.push('-----END ' + options.label + '-----');
-  return out.join('\n');
-};
-
-},{"./der":20,"inherits":107}],23:[function(require,module,exports){
-'use strict'
-
-exports.byteLength = byteLength
-exports.toByteArray = toByteArray
-exports.fromByteArray = fromByteArray
-
-var lookup = []
-var revLookup = []
-var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
-
-var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-for (var i = 0, len = code.length; i < len; ++i) {
-  lookup[i] = code[i]
-  revLookup[code.charCodeAt(i)] = i
-}
-
-// Support decoding URL-safe base64 strings, as Node.js does.
-// See: https://en.wikipedia.org/wiki/Base64#URL_applications
-revLookup['-'.charCodeAt(0)] = 62
-revLookup['_'.charCodeAt(0)] = 63
-
-function getLens (b64) {
-  var len = b64.length
-
-  if (len % 4 > 0) {
-    throw new Error('Invalid string. Length must be a multiple of 4')
-  }
-
-  // Trim off extra bytes after placeholder bytes are found
-  // See: https://github.com/beatgammit/base64-js/issues/42
-  var validLen = b64.indexOf('=')
-  if (validLen === -1) validLen = len
-
-  var placeHoldersLen = validLen === len
-    ? 0
-    : 4 - (validLen % 4)
-
-  return [validLen, placeHoldersLen]
-}
-
-// base64 is 4/3 + up to two characters of the original data
-function byteLength (b64) {
-  var lens = getLens(b64)
-  var validLen = lens[0]
-  var placeHoldersLen = lens[1]
-  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
-}
-
-function _byteLength (b64, validLen, placeHoldersLen) {
-  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
-}
-
-function toByteArray (b64) {
-  var tmp
-  var lens = getLens(b64)
-  var validLen = lens[0]
-  var placeHoldersLen = lens[1]
-
-  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
-
-  var curByte = 0
-
-  // if there are placeholders, only get up to the last complete 4 chars
-  var len = placeHoldersLen > 0
-    ? validLen - 4
-    : validLen
-
-  for (var i = 0; i < len; i += 4) {
-    tmp =
-      (revLookup[b64.charCodeAt(i)] << 18) |
-      (revLookup[b64.charCodeAt(i + 1)] << 12) |
-      (revLookup[b64.charCodeAt(i + 2)] << 6) |
-      revLookup[b64.charCodeAt(i + 3)]
-    arr[curByte++] = (tmp >> 16) & 0xFF
-    arr[curByte++] = (tmp >> 8) & 0xFF
-    arr[curByte++] = tmp & 0xFF
-  }
-
-  if (placeHoldersLen === 2) {
-    tmp =
-      (revLookup[b64.charCodeAt(i)] << 2) |
-      (revLookup[b64.charCodeAt(i + 1)] >> 4)
-    arr[curByte++] = tmp & 0xFF
-  }
-
-  if (placeHoldersLen === 1) {
-    tmp =
-      (revLookup[b64.charCodeAt(i)] << 10) |
-      (revLookup[b64.charCodeAt(i + 1)] << 4) |
-      (revLookup[b64.charCodeAt(i + 2)] >> 2)
-    arr[curByte++] = (tmp >> 8) & 0xFF
-    arr[curByte++] = 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) & 0xFF0000) +
-      ((uint8[i + 1] << 8) & 0xFF00) +
-      (uint8[i + 2] & 0xFF)
-    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 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]
-    parts.push(
-      lookup[tmp >> 2] +
-      lookup[(tmp << 4) & 0x3F] +
-      '=='
-    )
-  } else if (extraBytes === 2) {
-    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
-    parts.push(
-      lookup[tmp >> 10] +
-      lookup[(tmp >> 4) & 0x3F] +
-      lookup[(tmp << 2) & 0x3F] +
-      '='
-    )
-  }
-
-  return parts.join('')
-}
-
-},{}],24:[function(require,module,exports){
-(function (module, exports) {
-  'use strict';
-
-  // Utils
-  function assert (val, msg) {
-    if (!val) throw new Error(msg || 'Assertion failed');
-  }
-
-  // Could use `inherits` module, but don't want to move from single file
-  // architecture yet.
-  function inherits (ctor, superCtor) {
-    ctor.super_ = superCtor;
-    var TempCtor = function () {};
-    TempCtor.prototype = superCtor.prototype;
-    ctor.prototype = new TempCtor();
-    ctor.prototype.constructor = ctor;
-  }
-
-  // BN
-
-  function BN (number, base, endian) {
-    if (BN.isBN(number)) {
-      return number;
-    }
-
-    this.negative = 0;
-    this.words = null;
-    this.length = 0;
-
-    // Reduction context
-    this.red = null;
-
-    if (number !== null) {
-      if (base === 'le' || base === 'be') {
-        endian = base;
-        base = 10;
-      }
-
-      this._init(number || 0, base || 10, endian || 'be');
-    }
-  }
-  if (typeof module === 'object') {
-    module.exports = BN;
-  } else {
-    exports.BN = BN;
-  }
-
-  BN.BN = BN;
-  BN.wordSize = 26;
-
-  var Buffer;
-  try {
-    Buffer = require('buffer').Buffer;
-  } catch (e) {
-  }
-
-  BN.isBN = function isBN (num) {
-    if (num instanceof BN) {
-      return true;
-    }
-
-    return num !== null && typeof num === 'object' &&
-      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
-  };
-
-  BN.max = function max (left, right) {
-    if (left.cmp(right) > 0) return left;
-    return right;
-  };
-
-  BN.min = function min (left, right) {
-    if (left.cmp(right) < 0) return left;
-    return right;
-  };
-
-  BN.prototype._init = function init (number, base, endian) {
-    if (typeof number === 'number') {
-      return this._initNumber(number, base, endian);
-    }
-
-    if (typeof number === 'object') {
-      return this._initArray(number, base, endian);
-    }
-
-    if (base === 'hex') {
-      base = 16;
-    }
-    assert(base === (base | 0) && base >= 2 && base <= 36);
-
-    number = number.toString().replace(/\s+/g, '');
-    var start = 0;
-    if (number[0] === '-') {
-      start++;
-    }
-
-    if (base === 16) {
-      this._parseHex(number, start);
-    } else {
-      this._parseBase(number, base, start);
-    }
-
-    if (number[0] === '-') {
-      this.negative = 1;
-    }
-
-    this.strip();
-
-    if (endian !== 'le') return;
-
-    this._initArray(this.toArray(), base, endian);
-  };
-
-  BN.prototype._initNumber = function _initNumber (number, base, endian) {
-    if (number < 0) {
-      this.negative = 1;
-      number = -number;
-    }
-    if (number < 0x4000000) {
-      this.words = [ number & 0x3ffffff ];
-      this.length = 1;
-    } else if (number < 0x10000000000000) {
-      this.words = [
-        number & 0x3ffffff,
-        (number / 0x4000000) & 0x3ffffff
-      ];
-      this.length = 2;
-    } else {
-      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
-      this.words = [
-        number & 0x3ffffff,
-        (number / 0x4000000) & 0x3ffffff,
-        1
-      ];
-      this.length = 3;
-    }
-
-    if (endian !== 'le') return;
-
-    // Reverse the bytes
-    this._initArray(this.toArray(), base, endian);
-  };
-
-  BN.prototype._initArray = function _initArray (number, base, endian) {
-    // Perhaps a Uint8Array
-    assert(typeof number.length === 'number');
-    if (number.length <= 0) {
-      this.words = [ 0 ];
-      this.length = 1;
-      return this;
-    }
-
-    this.length = Math.ceil(number.length / 3);
-    this.words = new Array(this.length);
-    for (var i = 0; i < this.length; i++) {
-      this.words[i] = 0;
-    }
-
-    var j, w;
-    var off = 0;
-    if (endian === 'be') {
-      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
-        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
-        this.words[j] |= (w << off) & 0x3ffffff;
-        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
-        off += 24;
-        if (off >= 26) {
-          off -= 26;
-          j++;
-        }
-      }
-    } else if (endian === 'le') {
-      for (i = 0, j = 0; i < number.length; i += 3) {
-        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
-        this.words[j] |= (w << off) & 0x3ffffff;
-        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
-        off += 24;
-        if (off >= 26) {
-          off -= 26;
-          j++;
-        }
-      }
-    }
-    return this.strip();
-  };
-
-  function parseHex (str, start, end) {
-    var r = 0;
-    var len = Math.min(str.length, end);
-    for (var i = start; i < len; i++) {
-      var c = str.charCodeAt(i) - 48;
-
-      r <<= 4;
-
-      // 'a' - 'f'
-      if (c >= 49 && c <= 54) {
-        r |= c - 49 + 0xa;
-
-      // 'A' - 'F'
-      } else if (c >= 17 && c <= 22) {
-        r |= c - 17 + 0xa;
-
-      // '0' - '9'
-      } else {
-        r |= c & 0xf;
-      }
-    }
-    return r;
-  }
-
-  BN.prototype._parseHex = function _parseHex (number, start) {
-    // Create possibly bigger array to ensure that it fits the number
-    this.length = Math.ceil((number.length - start) / 6);
-    this.words = new Array(this.length);
-    for (var i = 0; i < this.length; i++) {
-      this.words[i] = 0;
-    }
-
-    var j, w;
-    // Scan 24-bit chunks and add them to the number
-    var off = 0;
-    for (i = number.length - 6, j = 0; i >= start; i -= 6) {
-      w = parseHex(number, i, i + 6);
-      this.words[j] |= (w << off) & 0x3ffffff;
-      // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb
-      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
-      off += 24;
-      if (off >= 26) {
-        off -= 26;
-        j++;
-      }
-    }
-    if (i + 6 !== start) {
-      w = parseHex(number, start, i + 6);
-      this.words[j] |= (w << off) & 0x3ffffff;
-      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
-    }
-    this.strip();
-  };
-
-  function parseBase (str, start, end, mul) {
-    var r = 0;
-    var len = Math.min(str.length, end);
-    for (var i = start; i < len; i++) {
-      var c = str.charCodeAt(i) - 48;
-
-      r *= mul;
-
-      // 'a'
-      if (c >= 49) {
-        r += c - 49 + 0xa;
-
-      // 'A'
-      } else if (c >= 17) {
-        r += c - 17 + 0xa;
-
-      // '0' - '9'
-      } else {
-        r += c;
-      }
-    }
-    return r;
-  }
-
-  BN.prototype._parseBase = function _parseBase (number, base, start) {
-    // Initialize as zero
-    this.words = [ 0 ];
-    this.length = 1;
-
-    // Find length of limb in base
-    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
-      limbLen++;
-    }
-    limbLen--;
-    limbPow = (limbPow / base) | 0;
-
-    var total = number.length - start;
-    var mod = total % limbLen;
-    var end = Math.min(total, total - mod) + start;
-
-    var word = 0;
-    for (var i = start; i < end; i += limbLen) {
-      word = parseBase(number, i, i + limbLen, base);
-
-      this.imuln(limbPow);
-      if (this.words[0] + word < 0x4000000) {
-        this.words[0] += word;
-      } else {
-        this._iaddn(word);
-      }
-    }
-
-    if (mod !== 0) {
-      var pow = 1;
-      word = parseBase(number, i, number.length, base);
-
-      for (i = 0; i < mod; i++) {
-        pow *= base;
-      }
-
-      this.imuln(pow);
-      if (this.words[0] + word < 0x4000000) {
-        this.words[0] += word;
-      } else {
-        this._iaddn(word);
-      }
-    }
-  };
-
-  BN.prototype.copy = function copy (dest) {
-    dest.words = new Array(this.length);
-    for (var i = 0; i < this.length; i++) {
-      dest.words[i] = this.words[i];
-    }
-    dest.length = this.length;
-    dest.negative = this.negative;
-    dest.red = this.red;
-  };
-
-  BN.prototype.clone = function clone () {
-    var r = new BN(null);
-    this.copy(r);
-    return r;
-  };
-
-  BN.prototype._expand = function _expand (size) {
-    while (this.length < size) {
-      this.words[this.length++] = 0;
-    }
-    return this;
-  };
-
-  // Remove leading `0` from `this`
-  BN.prototype.strip = function strip () {
-    while (this.length > 1 && this.words[this.length - 1] === 0) {
-      this.length--;
-    }
-    return this._normSign();
-  };
-
-  BN.prototype._normSign = function _normSign () {
-    // -0 = 0
-    if (this.length === 1 && this.words[0] === 0) {
-      this.negative = 0;
-    }
-    return this;
-  };
-
-  BN.prototype.inspect = function inspect () {
-    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
-  };
-
-  /*
-
-  var zeros = [];
-  var groupSizes = [];
-  var groupBases = [];
-
-  var s = '';
-  var i = -1;
-  while (++i < BN.wordSize) {
-    zeros[i] = s;
-    s += '0';
-  }
-  groupSizes[0] = 0;
-  groupSizes[1] = 0;
-  groupBases[0] = 0;
-  groupBases[1] = 0;
-  var base = 2 - 1;
-  while (++base < 36 + 1) {
-    var groupSize = 0;
-    var groupBase = 1;
-    while (groupBase < (1 << BN.wordSize) / base) {
-      groupBase *= base;
-      groupSize += 1;
-    }
-    groupSizes[base] = groupSize;
-    groupBases[base] = groupBase;
-  }
-
-  */
-
-  var zeros = [
-    '',
-    '0',
-    '00',
-    '000',
-    '0000',
-    '00000',
-    '000000',
-    '0000000',
-    '00000000',
-    '000000000',
-    '0000000000',
-    '00000000000',
-    '000000000000',
-    '0000000000000',
-    '00000000000000',
-    '000000000000000',
-    '0000000000000000',
-    '00000000000000000',
-    '000000000000000000',
-    '0000000000000000000',
-    '00000000000000000000',
-    '000000000000000000000',
-    '0000000000000000000000',
-    '00000000000000000000000',
-    '000000000000000000000000',
-    '0000000000000000000000000'
-  ];
-
-  var groupSizes = [
-    0, 0,
-    25, 16, 12, 11, 10, 9, 8,
-    8, 7, 7, 7, 7, 6, 6,
-    6, 6, 6, 6, 6, 5, 5,
-    5, 5, 5, 5, 5, 5, 5,
-    5, 5, 5, 5, 5, 5, 5
-  ];
-
-  var groupBases = [
-    0, 0,
-    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
-    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
-    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
-    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
-    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
-  ];
-
-  BN.prototype.toString = function toString (base, padding) {
-    base = base || 10;
-    padding = padding | 0 || 1;
-
-    var out;
-    if (base === 16 || base === 'hex') {
-      out = '';
-      var off = 0;
-      var carry = 0;
-      for (var i = 0; i < this.length; i++) {
-        var w = this.words[i];
-        var word = (((w << off) | carry) & 0xffffff).toString(16);
-        carry = (w >>> (24 - off)) & 0xffffff;
-        if (carry !== 0 || i !== this.length - 1) {
-          out = zeros[6 - word.length] + word + out;
-        } else {
-          out = word + out;
-        }
-        off += 2;
-        if (off >= 26) {
-          off -= 26;
-          i--;
-        }
-      }
-      if (carry !== 0) {
-        out = carry.toString(16) + out;
-      }
-      while (out.length % padding !== 0) {
-        out = '0' + out;
-      }
-      if (this.negative !== 0) {
-        out = '-' + out;
-      }
-      return out;
-    }
-
-    if (base === (base | 0) && base >= 2 && base <= 36) {
-      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
-      var groupSize = groupSizes[base];
-      // var groupBase = Math.pow(base, groupSize);
-      var groupBase = groupBases[base];
-      out = '';
-      var c = this.clone();
-      c.negative = 0;
-      while (!c.isZero()) {
-        var r = c.modn(groupBase).toString(base);
-        c = c.idivn(groupBase);
-
-        if (!c.isZero()) {
-          out = zeros[groupSize - r.length] + r + out;
-        } else {
-          out = r + out;
-        }
-      }
-      if (this.isZero()) {
-        out = '0' + out;
-      }
-      while (out.length % padding !== 0) {
-        out = '0' + out;
-      }
-      if (this.negative !== 0) {
-        out = '-' + out;
-      }
-      return out;
-    }
-
-    assert(false, 'Base should be between 2 and 36');
-  };
-
-  BN.prototype.toNumber = function toNumber () {
-    var ret = this.words[0];
-    if (this.length === 2) {
-      ret += this.words[1] * 0x4000000;
-    } else if (this.length === 3 && this.words[2] === 0x01) {
-      // NOTE: at this stage it is known that the top bit is set
-      ret += 0x10000000000000 + (this.words[1] * 0x4000000);
-    } else if (this.length > 2) {
-      assert(false, 'Number can only safely store up to 53 bits');
-    }
-    return (this.negative !== 0) ? -ret : ret;
-  };
-
-  BN.prototype.toJSON = function toJSON () {
-    return this.toString(16);
-  };
-
-  BN.prototype.toBuffer = function toBuffer (endian, length) {
-    assert(typeof Buffer !== 'undefined');
-    return this.toArrayLike(Buffer, endian, length);
-  };
-
-  BN.prototype.toArray = function toArray (endian, length) {
-    return this.toArrayLike(Array, endian, length);
-  };
-
-  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
-    var byteLength = this.byteLength();
-    var reqLength = length || Math.max(1, byteLength);
-    assert(byteLength <= reqLength, 'byte array longer than desired length');
-    assert(reqLength > 0, 'Requested array length <= 0');
-
-    this.strip();
-    var littleEndian = endian === 'le';
-    var res = new ArrayType(reqLength);
-
-    var b, i;
-    var q = this.clone();
-    if (!littleEndian) {
-      // Assume big-endian
-      for (i = 0; i < reqLength - byteLength; i++) {
-        res[i] = 0;
-      }
-
-      for (i = 0; !q.isZero(); i++) {
-        b = q.andln(0xff);
-        q.iushrn(8);
-
-        res[reqLength - i - 1] = b;
-      }
-    } else {
-      for (i = 0; !q.isZero(); i++) {
-        b = q.andln(0xff);
-        q.iushrn(8);
-
-        res[i] = b;
-      }
-
-      for (; i < reqLength; i++) {
-        res[i] = 0;
-      }
-    }
-
-    return res;
-  };
-
-  if (Math.clz32) {
-    BN.prototype._countBits = function _countBits (w) {
-      return 32 - Math.clz32(w);
-    };
-  } else {
-    BN.prototype._countBits = function _countBits (w) {
-      var t = w;
-      var r = 0;
-      if (t >= 0x1000) {
-        r += 13;
-        t >>>= 13;
-      }
-      if (t >= 0x40) {
-        r += 7;
-        t >>>= 7;
-      }
-      if (t >= 0x8) {
-        r += 4;
-        t >>>= 4;
-      }
-      if (t >= 0x02) {
-        r += 2;
-        t >>>= 2;
-      }
-      return r + t;
-    };
-  }
-
-  BN.prototype._zeroBits = function _zeroBits (w) {
-    // Short-cut
-    if (w === 0) return 26;
-
-    var t = w;
-    var r = 0;
-    if ((t & 0x1fff) === 0) {
-      r += 13;
-      t >>>= 13;
-    }
-    if ((t & 0x7f) === 0) {
-      r += 7;
-      t >>>= 7;
-    }
-    if ((t & 0xf) === 0) {
-      r += 4;
-      t >>>= 4;
-    }
-    if ((t & 0x3) === 0) {
-      r += 2;
-      t >>>= 2;
-    }
-    if ((t & 0x1) === 0) {
-      r++;
-    }
-    return r;
-  };
-
-  // Return number of used bits in a BN
-  BN.prototype.bitLength = function bitLength () {
-    var w = this.words[this.length - 1];
-    var hi = this._countBits(w);
-    return (this.length - 1) * 26 + hi;
-  };
-
-  function toBitArray (num) {
-    var w = new Array(num.bitLength());
-
-    for (var bit = 0; bit < w.length; bit++) {
-      var off = (bit / 26) | 0;
-      var wbit = bit % 26;
-
-      w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;
-    }
-
-    return w;
-  }
-
-  // Number of trailing zero bits
-  BN.prototype.zeroBits = function zeroBits () {
-    if (this.isZero()) return 0;
-
-    var r = 0;
-    for (var i = 0; i < this.length; i++) {
-      var b = this._zeroBits(this.words[i]);
-      r += b;
-      if (b !== 26) break;
-    }
-    return r;
-  };
-
-  BN.prototype.byteLength = function byteLength () {
-    return Math.ceil(this.bitLength() / 8);
-  };
-
-  BN.prototype.toTwos = function toTwos (width) {
-    if (this.negative !== 0) {
-      return this.abs().inotn(width).iaddn(1);
-    }
-    return this.clone();
-  };
-
-  BN.prototype.fromTwos = function fromTwos (width) {
-    if (this.testn(width - 1)) {
-      return this.notn(width).iaddn(1).ineg();
-    }
-    return this.clone();
-  };
-
-  BN.prototype.isNeg = function isNeg () {
-    return this.negative !== 0;
-  };
-
-  // Return negative clone of `this`
-  BN.prototype.neg = function neg () {
-    return this.clone().ineg();
-  };
-
-  BN.prototype.ineg = function ineg () {
-    if (!this.isZero()) {
-      this.negative ^= 1;
-    }
-
-    return this;
-  };
-
-  // Or `num` with `this` in-place
-  BN.prototype.iuor = function iuor (num) {
-    while (this.length < num.length) {
-      this.words[this.length++] = 0;
-    }
-
-    for (var i = 0; i < num.length; i++) {
-      this.words[i] = this.words[i] | num.words[i];
-    }
-
-    return this.strip();
-  };
-
-  BN.prototype.ior = function ior (num) {
-    assert((this.negative | num.negative) === 0);
-    return this.iuor(num);
-  };
-
-  // Or `num` with `this`
-  BN.prototype.or = function or (num) {
-    if (this.length > num.length) return this.clone().ior(num);
-    return num.clone().ior(this);
-  };
-
-  BN.prototype.uor = function uor (num) {
-    if (this.length > num.length) return this.clone().iuor(num);
-    return num.clone().iuor(this);
-  };
-
-  // And `num` with `this` in-place
-  BN.prototype.iuand = function iuand (num) {
-    // b = min-length(num, this)
-    var b;
-    if (this.length > num.length) {
-      b = num;
-    } else {
-      b = this;
-    }
-
-    for (var i = 0; i < b.length; i++) {
-      this.words[i] = this.words[i] & num.words[i];
-    }
-
-    this.length = b.length;
-
-    return this.strip();
-  };
-
-  BN.prototype.iand = function iand (num) {
-    assert((this.negative | num.negative) === 0);
-    return this.iuand(num);
-  };
-
-  // And `num` with `this`
-  BN.prototype.and = function and (num) {
-    if (this.length > num.length) return this.clone().iand(num);
-    return num.clone().iand(this);
-  };
-
-  BN.prototype.uand = function uand (num) {
-    if (this.length > num.length) return this.clone().iuand(num);
-    return num.clone().iuand(this);
-  };
-
-  // Xor `num` with `this` in-place
-  BN.prototype.iuxor = function iuxor (num) {
-    // a.length > b.length
-    var a;
-    var b;
-    if (this.length > num.length) {
-      a = this;
-      b = num;
-    } else {
-      a = num;
-      b = this;
-    }
-
-    for (var i = 0; i < b.length; i++) {
-      this.words[i] = a.words[i] ^ b.words[i];
-    }
-
-    if (this !== a) {
-      for (; i < a.length; i++) {
-        this.words[i] = a.words[i];
-      }
-    }
-
-    this.length = a.length;
-
-    return this.strip();
-  };
-
-  BN.prototype.ixor = function ixor (num) {
-    assert((this.negative | num.negative) === 0);
-    return this.iuxor(num);
-  };
-
-  // Xor `num` with `this`
-  BN.prototype.xor = function xor (num) {
-    if (this.length > num.length) return this.clone().ixor(num);
-    return num.clone().ixor(this);
-  };
-
-  BN.prototype.uxor = function uxor (num) {
-    if (this.length > num.length) return this.clone().iuxor(num);
-    return num.clone().iuxor(this);
-  };
-
-  // Not ``this`` with ``width`` bitwidth
-  BN.prototype.inotn = function inotn (width) {
-    assert(typeof width === 'number' && width >= 0);
-
-    var bytesNeeded = Math.ceil(width / 26) | 0;
-    var bitsLeft = width % 26;
-
-    // Extend the buffer with leading zeroes
-    this._expand(bytesNeeded);
-
-    if (bitsLeft > 0) {
-      bytesNeeded--;
-    }
-
-    // Handle complete words
-    for (var i = 0; i < bytesNeeded; i++) {
-      this.words[i] = ~this.words[i] & 0x3ffffff;
-    }
-
-    // Handle the residue
-    if (bitsLeft > 0) {
-      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
-    }
-
-    // And remove leading zeroes
-    return this.strip();
-  };
-
-  BN.prototype.notn = function notn (width) {
-    return this.clone().inotn(width);
-  };
-
-  // Set `bit` of `this`
-  BN.prototype.setn = function setn (bit, val) {
-    assert(typeof bit === 'number' && bit >= 0);
-
-    var off = (bit / 26) | 0;
-    var wbit = bit % 26;
-
-    this._expand(off + 1);
-
-    if (val) {
-      this.words[off] = this.words[off] | (1 << wbit);
-    } else {
-      this.words[off] = this.words[off] & ~(1 << wbit);
-    }
-
-    return this.strip();
-  };
-
-  // Add `num` to `this` in-place
-  BN.prototype.iadd = function iadd (num) {
-    var r;
-
-    // negative + positive
-    if (this.negative !== 0 && num.negative === 0) {
-      this.negative = 0;
-      r = this.isub(num);
-      this.negative ^= 1;
-      return this._normSign();
-
-    // positive + negative
-    } else if (this.negative === 0 && num.negative !== 0) {
-      num.negative = 0;
-      r = this.isub(num);
-      num.negative = 1;
-      return r._normSign();
-    }
-
-    // a.length > b.length
-    var a, b;
-    if (this.length > num.length) {
-      a = this;
-      b = num;
-    } else {
-      a = num;
-      b = this;
-    }
-
-    var carry = 0;
-    for (var i = 0; i < b.length; i++) {
-      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
-      this.words[i] = r & 0x3ffffff;
-      carry = r >>> 26;
-    }
-    for (; carry !== 0 && i < a.length; i++) {
-      r = (a.words[i] | 0) + carry;
-      this.words[i] = r & 0x3ffffff;
-      carry = r >>> 26;
-    }
-
-    this.length = a.length;
-    if (carry !== 0) {
-      this.words[this.length] = carry;
-      this.length++;
-    // Copy the rest of the words
-    } else if (a !== this) {
-      for (; i < a.length; i++) {
-        this.words[i] = a.words[i];
-      }
-    }
-
-    return this;
-  };
-
-  // Add `num` to `this`
-  BN.prototype.add = function add (num) {
-    var res;
-    if (num.negative !== 0 && this.negative === 0) {
-      num.negative = 0;
-      res = this.sub(num);
-      num.negative ^= 1;
-      return res;
-    } else if (num.negative === 0 && this.negative !== 0) {
-      this.negative = 0;
-      res = num.sub(this);
-      this.negative = 1;
-      return res;
-    }
-
-    if (this.length > num.length) return this.clone().iadd(num);
-
-    return num.clone().iadd(this);
-  };
-
-  // Subtract `num` from `this` in-place
-  BN.prototype.isub = function isub (num) {
-    // this - (-num) = this + num
-    if (num.negative !== 0) {
-      num.negative = 0;
-      var r = this.iadd(num);
-      num.negative = 1;
-      return r._normSign();
-
-    // -this - num = -(this + num)
-    } else if (this.negative !== 0) {
-      this.negative = 0;
-      this.iadd(num);
-      this.negative = 1;
-      return this._normSign();
-    }
-
-    // At this point both numbers are positive
-    var cmp = this.cmp(num);
-
-    // Optimization - zeroify
-    if (cmp === 0) {
-      this.negative = 0;
-      this.length = 1;
-      this.words[0] = 0;
-      return this;
-    }
-
-    // a > b
-    var a, b;
-    if (cmp > 0) {
-      a = this;
-      b = num;
-    } else {
-      a = num;
-      b = this;
-    }
-
-    var carry = 0;
-    for (var i = 0; i < b.length; i++) {
-      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
-      carry = r >> 26;
-      this.words[i] = r & 0x3ffffff;
-    }
-    for (; carry !== 0 && i < a.length; i++) {
-      r = (a.words[i] | 0) + carry;
-      carry = r >> 26;
-      this.words[i] = r & 0x3ffffff;
-    }
-
-    // Copy rest of the words
-    if (carry === 0 && i < a.length && a !== this) {
-      for (; i < a.length; i++) {
-        this.words[i] = a.words[i];
-      }
-    }
-
-    this.length = Math.max(this.length, i);
-
-    if (a !== this) {
-      this.negative = 1;
-    }
-
-    return this.strip();
-  };
-
-  // Subtract `num` from `this`
-  BN.prototype.sub = function sub (num) {
-    return this.clone().isub(num);
-  };
-
-  function smallMulTo (self, num, out) {
-    out.negative = num.negative ^ self.negative;
-    var len = (self.length + num.length) | 0;
-    out.length = len;
-    len = (len - 1) | 0;
-
-    // Peel one iteration (compiler can't do it, because of code complexity)
-    var a = self.words[0] | 0;
-    var b = num.words[0] | 0;
-    var r = a * b;
-
-    var lo = r & 0x3ffffff;
-    var carry = (r / 0x4000000) | 0;
-    out.words[0] = lo;
-
-    for (var k = 1; k < len; k++) {
-      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
-      // note that ncarry could be >= 0x3ffffff
-      var ncarry = carry >>> 26;
-      var rword = carry & 0x3ffffff;
-      var maxJ = Math.min(k, num.length - 1);
-      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
-        var i = (k - j) | 0;
-        a = self.words[i] | 0;
-        b = num.words[j] | 0;
-        r = a * b + rword;
-        ncarry += (r / 0x4000000) | 0;
-        rword = r & 0x3ffffff;
-      }
-      out.words[k] = rword | 0;
-      carry = ncarry | 0;
-    }
-    if (carry !== 0) {
-      out.words[k] = carry | 0;
-    } else {
-      out.length--;
-    }
-
-    return out.strip();
-  }
-
-  // TODO(indutny): it may be reasonable to omit it for users who don't need
-  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
-  // multiplication (like elliptic secp256k1).
-  var comb10MulTo = function comb10MulTo (self, num, out) {
-    var a = self.words;
-    var b = num.words;
-    var o = out.words;
-    var c = 0;
-    var lo;
-    var mid;
-    var hi;
-    var a0 = a[0] | 0;
-    var al0 = a0 & 0x1fff;
-    var ah0 = a0 >>> 13;
-    var a1 = a[1] | 0;
-    var al1 = a1 & 0x1fff;
-    var ah1 = a1 >>> 13;
-    var a2 = a[2] | 0;
-    var al2 = a2 & 0x1fff;
-    var ah2 = a2 >>> 13;
-    var a3 = a[3] | 0;
-    var al3 = a3 & 0x1fff;
-    var ah3 = a3 >>> 13;
-    var a4 = a[4] | 0;
-    var al4 = a4 & 0x1fff;
-    var ah4 = a4 >>> 13;
-    var a5 = a[5] | 0;
-    var al5 = a5 & 0x1fff;
-    var ah5 = a5 >>> 13;
-    var a6 = a[6] | 0;
-    var al6 = a6 & 0x1fff;
-    var ah6 = a6 >>> 13;
-    var a7 = a[7] | 0;
-    var al7 = a7 & 0x1fff;
-    var ah7 = a7 >>> 13;
-    var a8 = a[8] | 0;
-    var al8 = a8 & 0x1fff;
-    var ah8 = a8 >>> 13;
-    var a9 = a[9] | 0;
-    var al9 = a9 & 0x1fff;
-    var ah9 = a9 >>> 13;
-    var b0 = b[0] | 0;
-    var bl0 = b0 & 0x1fff;
-    var bh0 = b0 >>> 13;
-    var b1 = b[1] | 0;
-    var bl1 = b1 & 0x1fff;
-    var bh1 = b1 >>> 13;
-    var b2 = b[2] | 0;
-    var bl2 = b2 & 0x1fff;
-    var bh2 = b2 >>> 13;
-    var b3 = b[3] | 0;
-    var bl3 = b3 & 0x1fff;
-    var bh3 = b3 >>> 13;
-    var b4 = b[4] | 0;
-    var bl4 = b4 & 0x1fff;
-    var bh4 = b4 >>> 13;
-    var b5 = b[5] | 0;
-    var bl5 = b5 & 0x1fff;
-    var bh5 = b5 >>> 13;
-    var b6 = b[6] | 0;
-    var bl6 = b6 & 0x1fff;
-    var bh6 = b6 >>> 13;
-    var b7 = b[7] | 0;
-    var bl7 = b7 & 0x1fff;
-    var bh7 = b7 >>> 13;
-    var b8 = b[8] | 0;
-    var bl8 = b8 & 0x1fff;
-    var bh8 = b8 >>> 13;
-    var b9 = b[9] | 0;
-    var bl9 = b9 & 0x1fff;
-    var bh9 = b9 >>> 13;
-
-    out.negative = self.negative ^ num.negative;
-    out.length = 19;
-    /* k = 0 */
-    lo = Math.imul(al0, bl0);
-    mid = Math.imul(al0, bh0);
-    mid = (mid + Math.imul(ah0, bl0)) | 0;
-    hi = Math.imul(ah0, bh0);
-    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;
-    w0 &= 0x3ffffff;
-    /* k = 1 */
-    lo = Math.imul(al1, bl0);
-    mid = Math.imul(al1, bh0);
-    mid = (mid + Math.imul(ah1, bl0)) | 0;
-    hi = Math.imul(ah1, bh0);
-    lo = (lo + Math.imul(al0, bl1)) | 0;
-    mid = (mid + Math.imul(al0, bh1)) | 0;
-    mid = (mid + Math.imul(ah0, bl1)) | 0;
-    hi = (hi + Math.imul(ah0, bh1)) | 0;
-    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;
-    w1 &= 0x3ffffff;
-    /* k = 2 */
-    lo = Math.imul(al2, bl0);
-    mid = Math.imul(al2, bh0);
-    mid = (mid + Math.imul(ah2, bl0)) | 0;
-    hi = Math.imul(ah2, bh0);
-    lo = (lo + Math.imul(al1, bl1)) | 0;
-    mid = (mid + Math.imul(al1, bh1)) | 0;
-    mid = (mid + Math.imul(ah1, bl1)) | 0;
-    hi = (hi + Math.imul(ah1, bh1)) | 0;
-    lo = (lo + Math.imul(al0, bl2)) | 0;
-    mid = (mid + Math.imul(al0, bh2)) | 0;
-    mid = (mid + Math.imul(ah0, bl2)) | 0;
-    hi = (hi + Math.imul(ah0, bh2)) | 0;
-    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;
-    w2 &= 0x3ffffff;
-    /* k = 3 */
-    lo = Math.imul(al3, bl0);
-    mid = Math.imul(al3, bh0);
-    mid = (mid + Math.imul(ah3, bl0)) | 0;
-    hi = Math.imul(ah3, bh0);
-    lo = (lo + Math.imul(al2, bl1)) | 0;
-    mid = (mid + Math.imul(al2, bh1)) | 0;
-    mid = (mid + Math.imul(ah2, bl1)) | 0;
-    hi = (hi + Math.imul(ah2, bh1)) | 0;
-    lo = (lo + Math.imul(al1, bl2)) | 0;
-    mid = (mid + Math.imul(al1, bh2)) | 0;
-    mid = (mid + Math.imul(ah1, bl2)) | 0;
-    hi = (hi + Math.imul(ah1, bh2)) | 0;
-    lo = (lo + Math.imul(al0, bl3)) | 0;
-    mid = (mid + Math.imul(al0, bh3)) | 0;
-    mid = (mid + Math.imul(ah0, bl3)) | 0;
-    hi = (hi + Math.imul(ah0, bh3)) | 0;
-    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;
-    w3 &= 0x3ffffff;
-    /* k = 4 */
-    lo = Math.imul(al4, bl0);
-    mid = Math.imul(al4, bh0);
-    mid = (mid + Math.imul(ah4, bl0)) | 0;
-    hi = Math.imul(ah4, bh0);
-    lo = (lo + Math.imul(al3, bl1)) | 0;
-    mid = (mid + Math.imul(al3, bh1)) | 0;
-    mid = (mid + Math.imul(ah3, bl1)) | 0;
-    hi = (hi + Math.imul(ah3, bh1)) | 0;
-    lo = (lo + Math.imul(al2, bl2)) | 0;
-    mid = (mid + Math.imul(al2, bh2)) | 0;
-    mid = (mid + Math.imul(ah2, bl2)) | 0;
-    hi = (hi + Math.imul(ah2, bh2)) | 0;
-    lo = (lo + Math.imul(al1, bl3)) | 0;
-    mid = (mid + Math.imul(al1, bh3)) | 0;
-    mid = (mid + Math.imul(ah1, bl3)) | 0;
-    hi = (hi + Math.imul(ah1, bh3)) | 0;
-    lo = (lo + Math.imul(al0, bl4)) | 0;
-    mid = (mid + Math.imul(al0, bh4)) | 0;
-    mid = (mid + Math.imul(ah0, bl4)) | 0;
-    hi = (hi + Math.imul(ah0, bh4)) | 0;
-    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;
-    w4 &= 0x3ffffff;
-    /* k = 5 */
-    lo = Math.imul(al5, bl0);
-    mid = Math.imul(al5, bh0);
-    mid = (mid + Math.imul(ah5, bl0)) | 0;
-    hi = Math.imul(ah5, bh0);
-    lo = (lo + Math.imul(al4, bl1)) | 0;
-    mid = (mid + Math.imul(al4, bh1)) | 0;
-    mid = (mid + Math.imul(ah4, bl1)) | 0;
-    hi = (hi + Math.imul(ah4, bh1)) | 0;
-    lo = (lo + Math.imul(al3, bl2)) | 0;
-    mid = (mid + Math.imul(al3, bh2)) | 0;
-    mid = (mid + Math.imul(ah3, bl2)) | 0;
-    hi = (hi + Math.imul(ah3, bh2)) | 0;
-    lo = (lo + Math.imul(al2, bl3)) | 0;
-    mid = (mid + Math.imul(al2, bh3)) | 0;
-    mid = (mid + Math.imul(ah2, bl3)) | 0;
-    hi = (hi + Math.imul(ah2, bh3)) | 0;
-    lo = (lo + Math.imul(al1, bl4)) | 0;
-    mid = (mid + Math.imul(al1, bh4)) | 0;
-    mid = (mid + Math.imul(ah1, bl4)) | 0;
-    hi = (hi + Math.imul(ah1, bh4)) | 0;
-    lo = (lo + Math.imul(al0, bl5)) | 0;
-    mid = (mid + Math.imul(al0, bh5)) | 0;
-    mid = (mid + Math.imul(ah0, bl5)) | 0;
-    hi = (hi + Math.imul(ah0, bh5)) | 0;
-    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;
-    w5 &= 0x3ffffff;
-    /* k = 6 */
-    lo = Math.imul(al6, bl0);
-    mid = Math.imul(al6, bh0);
-    mid = (mid + Math.imul(ah6, bl0)) | 0;
-    hi = Math.imul(ah6, bh0);
-    lo = (lo + Math.imul(al5, bl1)) | 0;
-    mid = (mid + Math.imul(al5, bh1)) | 0;
-    mid = (mid + Math.imul(ah5, bl1)) | 0;
-    hi = (hi + Math.imul(ah5, bh1)) | 0;
-    lo = (lo + Math.imul(al4, bl2)) | 0;
-    mid = (mid + Math.imul(al4, bh2)) | 0;
-    mid = (mid + Math.imul(ah4, bl2)) | 0;
-    hi = (hi + Math.imul(ah4, bh2)) | 0;
-    lo = (lo + Math.imul(al3, bl3)) | 0;
-    mid = (mid + Math.imul(al3, bh3)) | 0;
-    mid = (mid + Math.imul(ah3, bl3)) | 0;
-    hi = (hi + Math.imul(ah3, bh3)) | 0;
-    lo = (lo + Math.imul(al2, bl4)) | 0;
-    mid = (mid + Math.imul(al2, bh4)) | 0;
-    mid = (mid + Math.imul(ah2, bl4)) | 0;
-    hi = (hi + Math.imul(ah2, bh4)) | 0;
-    lo = (lo + Math.imul(al1, bl5)) | 0;
-    mid = (mid + Math.imul(al1, bh5)) | 0;
-    mid = (mid + Math.imul(ah1, bl5)) | 0;
-    hi = (hi + Math.imul(ah1, bh5)) | 0;
-    lo = (lo + Math.imul(al0, bl6)) | 0;
-    mid = (mid + Math.imul(al0, bh6)) | 0;
-    mid = (mid + Math.imul(ah0, bl6)) | 0;
-    hi = (hi + Math.imul(ah0, bh6)) | 0;
-    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;
-    w6 &= 0x3ffffff;
-    /* k = 7 */
-    lo = Math.imul(al7, bl0);
-    mid = Math.imul(al7, bh0);
-    mid = (mid + Math.imul(ah7, bl0)) | 0;
-    hi = Math.imul(ah7, bh0);
-    lo = (lo + Math.imul(al6, bl1)) | 0;
-    mid = (mid + Math.imul(al6, bh1)) | 0;
-    mid = (mid + Math.imul(ah6, bl1)) | 0;
-    hi = (hi + Math.imul(ah6, bh1)) | 0;
-    lo = (lo + Math.imul(al5, bl2)) | 0;
-    mid = (mid + Math.imul(al5, bh2)) | 0;
-    mid = (mid + Math.imul(ah5, bl2)) | 0;
-    hi = (hi + Math.imul(ah5, bh2)) | 0;
-    lo = (lo + Math.imul(al4, bl3)) | 0;
-    mid = (mid + Math.imul(al4, bh3)) | 0;
-    mid = (mid + Math.imul(ah4, bl3)) | 0;
-    hi = (hi + Math.imul(ah4, bh3)) | 0;
-    lo = (lo + Math.imul(al3, bl4)) | 0;
-    mid = (mid + Math.imul(al3, bh4)) | 0;
-    mid = (mid + Math.imul(ah3, bl4)) | 0;
-    hi = (hi + Math.imul(ah3, bh4)) | 0;
-    lo = (lo + Math.imul(al2, bl5)) | 0;
-    mid = (mid + Math.imul(al2, bh5)) | 0;
-    mid = (mid + Math.imul(ah2, bl5)) | 0;
-    hi = (hi + Math.imul(ah2, bh5)) | 0;
-    lo = (lo + Math.imul(al1, bl6)) | 0;
-    mid = (mid + Math.imul(al1, bh6)) | 0;
-    mid = (mid + Math.imul(ah1, bl6)) | 0;
-    hi = (hi + Math.imul(ah1, bh6)) | 0;
-    lo = (lo + Math.imul(al0, bl7)) | 0;
-    mid = (mid + Math.imul(al0, bh7)) | 0;
-    mid = (mid + Math.imul(ah0, bl7)) | 0;
-    hi = (hi + Math.imul(ah0, bh7)) | 0;
-    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;
-    w7 &= 0x3ffffff;
-    /* k = 8 */
-    lo = Math.imul(al8, bl0);
-    mid = Math.imul(al8, bh0);
-    mid = (mid + Math.imul(ah8, bl0)) | 0;
-    hi = Math.imul(ah8, bh0);
-    lo = (lo + Math.imul(al7, bl1)) | 0;
-    mid = (mid + Math.imul(al7, bh1)) | 0;
-    mid = (mid + Math.imul(ah7, bl1)) | 0;
-    hi = (hi + Math.imul(ah7, bh1)) | 0;
-    lo = (lo + Math.imul(al6, bl2)) | 0;
-    mid = (mid + Math.imul(al6, bh2)) | 0;
-    mid = (mid + Math.imul(ah6, bl2)) | 0;
-    hi = (hi + Math.imul(ah6, bh2)) | 0;
-    lo = (lo + Math.imul(al5, bl3)) | 0;
-    mid = (mid + Math.imul(al5, bh3)) | 0;
-    mid = (mid + Math.imul(ah5, bl3)) | 0;
-    hi = (hi + Math.imul(ah5, bh3)) | 0;
-    lo = (lo + Math.imul(al4, bl4)) | 0;
-    mid = (mid + Math.imul(al4, bh4)) | 0;
-    mid = (mid + Math.imul(ah4, bl4)) | 0;
-    hi = (hi + Math.imul(ah4, bh4)) | 0;
-    lo = (lo + Math.imul(al3, bl5)) | 0;
-    mid = (mid + Math.imul(al3, bh5)) | 0;
-    mid = (mid + Math.imul(ah3, bl5)) | 0;
-    hi = (hi + Math.imul(ah3, bh5)) | 0;
-    lo = (lo + Math.imul(al2, bl6)) | 0;
-    mid = (mid + Math.imul(al2, bh6)) | 0;
-    mid = (mid + Math.imul(ah2, bl6)) | 0;
-    hi = (hi + Math.imul(ah2, bh6)) | 0;
-    lo = (lo + Math.imul(al1, bl7)) | 0;
-    mid = (mid + Math.imul(al1, bh7)) | 0;
-    mid = (mid + Math.imul(ah1, bl7)) | 0;
-    hi = (hi + Math.imul(ah1, bh7)) | 0;
-    lo = (lo + Math.imul(al0, bl8)) | 0;
-    mid = (mid + Math.imul(al0, bh8)) | 0;
-    mid = (mid + Math.imul(ah0, bl8)) | 0;
-    hi = (hi + Math.imul(ah0, bh8)) | 0;
-    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;
-    w8 &= 0x3ffffff;
-    /* k = 9 */
-    lo = Math.imul(al9, bl0);
-    mid = Math.imul(al9, bh0);
-    mid = (mid + Math.imul(ah9, bl0)) | 0;
-    hi = Math.imul(ah9, bh0);
-    lo = (lo + Math.imul(al8, bl1)) | 0;
-    mid = (mid + Math.imul(al8, bh1)) | 0;
-    mid = (mid + Math.imul(ah8, bl1)) | 0;
-    hi = (hi + Math.imul(ah8, bh1)) | 0;
-    lo = (lo + Math.imul(al7, bl2)) | 0;
-    mid = (mid + Math.imul(al7, bh2)) | 0;
-    mid = (mid + Math.imul(ah7, bl2)) | 0;
-    hi = (hi + Math.imul(ah7, bh2)) | 0;
-    lo = (lo + Math.imul(al6, bl3)) | 0;
-    mid = (mid + Math.imul(al6, bh3)) | 0;
-    mid = (mid + Math.imul(ah6, bl3)) | 0;
-    hi = (hi + Math.imul(ah6, bh3)) | 0;
-    lo = (lo + Math.imul(al5, bl4)) | 0;
-    mid = (mid + Math.imul(al5, bh4)) | 0;
-    mid = (mid + Math.imul(ah5, bl4)) | 0;
-    hi = (hi + Math.imul(ah5, bh4)) | 0;
-    lo = (lo + Math.imul(al4, bl5)) | 0;
-    mid = (mid + Math.imul(al4, bh5)) | 0;
-    mid = (mid + Math.imul(ah4, bl5)) | 0;
-    hi = (hi + Math.imul(ah4, bh5)) | 0;
-    lo = (lo + Math.imul(al3, bl6)) | 0;
-    mid = (mid + Math.imul(al3, bh6)) | 0;
-    mid = (mid + Math.imul(ah3, bl6)) | 0;
-    hi = (hi + Math.imul(ah3, bh6)) | 0;
-    lo = (lo + Math.imul(al2, bl7)) | 0;
-    mid = (mid + Math.imul(al2, bh7)) | 0;
-    mid = (mid + Math.imul(ah2, bl7)) | 0;
-    hi = (hi + Math.imul(ah2, bh7)) | 0;
-    lo = (lo + Math.imul(al1, bl8)) | 0;
-    mid = (mid + Math.imul(al1, bh8)) | 0;
-    mid = (mid + Math.imul(ah1, bl8)) | 0;
-    hi = (hi + Math.imul(ah1, bh8)) | 0;
-    lo = (lo + Math.imul(al0, bl9)) | 0;
-    mid = (mid + Math.imul(al0, bh9)) | 0;
-    mid = (mid + Math.imul(ah0, bl9)) | 0;
-    hi = (hi + Math.imul(ah0, bh9)) | 0;
-    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;
-    w9 &= 0x3ffffff;
-    /* k = 10 */
-    lo = Math.imul(al9, bl1);
-    mid = Math.imul(al9, bh1);
-    mid = (mid + Math.imul(ah9, bl1)) | 0;
-    hi = Math.imul(ah9, bh1);
-    lo = (lo + Math.imul(al8, bl2)) | 0;
-    mid = (mid + Math.imul(al8, bh2)) | 0;
-    mid = (mid + Math.imul(ah8, bl2)) | 0;
-    hi = (hi + Math.imul(ah8, bh2)) | 0;
-    lo = (lo + Math.imul(al7, bl3)) | 0;
-    mid = (mid + Math.imul(al7, bh3)) | 0;
-    mid = (mid + Math.imul(ah7, bl3)) | 0;
-    hi = (hi + Math.imul(ah7, bh3)) | 0;
-    lo = (lo + Math.imul(al6, bl4)) | 0;
-    mid = (mid + Math.imul(al6, bh4)) | 0;
-    mid = (mid + Math.imul(ah6, bl4)) | 0;
-    hi = (hi + Math.imul(ah6, bh4)) | 0;
-    lo = (lo + Math.imul(al5, bl5)) | 0;
-    mid = (mid + Math.imul(al5, bh5)) | 0;
-    mid = (mid + Math.imul(ah5, bl5)) | 0;
-    hi = (hi + Math.imul(ah5, bh5)) | 0;
-    lo = (lo + Math.imul(al4, bl6)) | 0;
-    mid = (mid + Math.imul(al4, bh6)) | 0;
-    mid = (mid + Math.imul(ah4, bl6)) | 0;
-    hi = (hi + Math.imul(ah4, bh6)) | 0;
-    lo = (lo + Math.imul(al3, bl7)) | 0;
-    mid = (mid + Math.imul(al3, bh7)) | 0;
-    mid = (mid + Math.imul(ah3, bl7)) | 0;
-    hi = (hi + Math.imul(ah3, bh7)) | 0;
-    lo = (lo + Math.imul(al2, bl8)) | 0;
-    mid = (mid + Math.imul(al2, bh8)) | 0;
-    mid = (mid + Math.imul(ah2, bl8)) | 0;
-    hi = (hi + Math.imul(ah2, bh8)) | 0;
-    lo = (lo + Math.imul(al1, bl9)) | 0;
-    mid = (mid + Math.imul(al1, bh9)) | 0;
-    mid = (mid + Math.imul(ah1, bl9)) | 0;
-    hi = (hi + Math.imul(ah1, bh9)) | 0;
-    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;
-    w10 &= 0x3ffffff;
-    /* k = 11 */
-    lo = Math.imul(al9, bl2);
-    mid = Math.imul(al9, bh2);
-    mid = (mid + Math.imul(ah9, bl2)) | 0;
-    hi = Math.imul(ah9, bh2);
-    lo = (lo + Math.imul(al8, bl3)) | 0;
-    mid = (mid + Math.imul(al8, bh3)) | 0;
-    mid = (mid + Math.imul(ah8, bl3)) | 0;
-    hi = (hi + Math.imul(ah8, bh3)) | 0;
-    lo = (lo + Math.imul(al7, bl4)) | 0;
-    mid = (mid + Math.imul(al7, bh4)) | 0;
-    mid = (mid + Math.imul(ah7, bl4)) | 0;
-    hi = (hi + Math.imul(ah7, bh4)) | 0;
-    lo = (lo + Math.imul(al6, bl5)) | 0;
-    mid = (mid + Math.imul(al6, bh5)) | 0;
-    mid = (mid + Math.imul(ah6, bl5)) | 0;
-    hi = (hi + Math.imul(ah6, bh5)) | 0;
-    lo = (lo + Math.imul(al5, bl6)) | 0;
-    mid = (mid + Math.imul(al5, bh6)) | 0;
-    mid = (mid + Math.imul(ah5, bl6)) | 0;
-    hi = (hi + Math.imul(ah5, bh6)) | 0;
-    lo = (lo + Math.imul(al4, bl7)) | 0;
-    mid = (mid + Math.imul(al4, bh7)) | 0;
-    mid = (mid + Math.imul(ah4, bl7)) | 0;
-    hi = (hi + Math.imul(ah4, bh7)) | 0;
-    lo = (lo + Math.imul(al3, bl8)) | 0;
-    mid = (mid + Math.imul(al3, bh8)) | 0;
-    mid = (mid + Math.imul(ah3, bl8)) | 0;
-    hi = (hi + Math.imul(ah3, bh8)) | 0;
-    lo = (lo + Math.imul(al2, bl9)) | 0;
-    mid = (mid + Math.imul(al2, bh9)) | 0;
-    mid = (mid + Math.imul(ah2, bl9)) | 0;
-    hi = (hi + Math.imul(ah2, bh9)) | 0;
-    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;
-    w11 &= 0x3ffffff;
-    /* k = 12 */
-    lo = Math.imul(al9, bl3);
-    mid = Math.imul(al9, bh3);
-    mid = (mid + Math.imul(ah9, bl3)) | 0;
-    hi = Math.imul(ah9, bh3);
-    lo = (lo + Math.imul(al8, bl4)) | 0;
-    mid = (mid + Math.imul(al8, bh4)) | 0;
-    mid = (mid + Math.imul(ah8, bl4)) | 0;
-    hi = (hi + Math.imul(ah8, bh4)) | 0;
-    lo = (lo + Math.imul(al7, bl5)) | 0;
-    mid = (mid + Math.imul(al7, bh5)) | 0;
-    mid = (mid + Math.imul(ah7, bl5)) | 0;
-    hi = (hi + Math.imul(ah7, bh5)) | 0;
-    lo = (lo + Math.imul(al6, bl6)) | 0;
-    mid = (mid + Math.imul(al6, bh6)) | 0;
-    mid = (mid + Math.imul(ah6, bl6)) | 0;
-    hi = (hi + Math.imul(ah6, bh6)) | 0;
-    lo = (lo + Math.imul(al5, bl7)) | 0;
-    mid = (mid + Math.imul(al5, bh7)) | 0;
-    mid = (mid + Math.imul(ah5, bl7)) | 0;
-    hi = (hi + Math.imul(ah5, bh7)) | 0;
-    lo = (lo + Math.imul(al4, bl8)) | 0;
-    mid = (mid + Math.imul(al4, bh8)) | 0;
-    mid = (mid + Math.imul(ah4, bl8)) | 0;
-    hi = (hi + Math.imul(ah4, bh8)) | 0;
-    lo = (lo + Math.imul(al3, bl9)) | 0;
-    mid = (mid + Math.imul(al3, bh9)) | 0;
-    mid = (mid + Math.imul(ah3, bl9)) | 0;
-    hi = (hi + Math.imul(ah3, bh9)) | 0;
-    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;
-    w12 &= 0x3ffffff;
-    /* k = 13 */
-    lo = Math.imul(al9, bl4);
-    mid = Math.imul(al9, bh4);
-    mid = (mid + Math.imul(ah9, bl4)) | 0;
-    hi = Math.imul(ah9, bh4);
-    lo = (lo + Math.imul(al8, bl5)) | 0;
-    mid = (mid + Math.imul(al8, bh5)) | 0;
-    mid = (mid + Math.imul(ah8, bl5)) | 0;
-    hi = (hi + Math.imul(ah8, bh5)) | 0;
-    lo = (lo + Math.imul(al7, bl6)) | 0;
-    mid = (mid + Math.imul(al7, bh6)) | 0;
-    mid = (mid + Math.imul(ah7, bl6)) | 0;
-    hi = (hi + Math.imul(ah7, bh6)) | 0;
-    lo = (lo + Math.imul(al6, bl7)) | 0;
-    mid = (mid + Math.imul(al6, bh7)) | 0;
-    mid = (mid + Math.imul(ah6, bl7)) | 0;
-    hi = (hi + Math.imul(ah6, bh7)) | 0;
-    lo = (lo + Math.imul(al5, bl8)) | 0;
-    mid = (mid + Math.imul(al5, bh8)) | 0;
-    mid = (mid + Math.imul(ah5, bl8)) | 0;
-    hi = (hi + Math.imul(ah5, bh8)) | 0;
-    lo = (lo + Math.imul(al4, bl9)) | 0;
-    mid = (mid + Math.imul(al4, bh9)) | 0;
-    mid = (mid + Math.imul(ah4, bl9)) | 0;
-    hi = (hi + Math.imul(ah4, bh9)) | 0;
-    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;
-    w13 &= 0x3ffffff;
-    /* k = 14 */
-    lo = Math.imul(al9, bl5);
-    mid = Math.imul(al9, bh5);
-    mid = (mid + Math.imul(ah9, bl5)) | 0;
-    hi = Math.imul(ah9, bh5);
-    lo = (lo + Math.imul(al8, bl6)) | 0;
-    mid = (mid + Math.imul(al8, bh6)) | 0;
-    mid = (mid + Math.imul(ah8, bl6)) | 0;
-    hi = (hi + Math.imul(ah8, bh6)) | 0;
-    lo = (lo + Math.imul(al7, bl7)) | 0;
-    mid = (mid + Math.imul(al7, bh7)) | 0;
-    mid = (mid + Math.imul(ah7, bl7)) | 0;
-    hi = (hi + Math.imul(ah7, bh7)) | 0;
-    lo = (lo + Math.imul(al6, bl8)) | 0;
-    mid = (mid + Math.imul(al6, bh8)) | 0;
-    mid = (mid + Math.imul(ah6, bl8)) | 0;
-    hi = (hi + Math.imul(ah6, bh8)) | 0;
-    lo = (lo + Math.imul(al5, bl9)) | 0;
-    mid = (mid + Math.imul(al5, bh9)) | 0;
-    mid = (mid + Math.imul(ah5, bl9)) | 0;
-    hi = (hi + Math.imul(ah5, bh9)) | 0;
-    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;
-    w14 &= 0x3ffffff;
-    /* k = 15 */
-    lo = Math.imul(al9, bl6);
-    mid = Math.imul(al9, bh6);
-    mid = (mid + Math.imul(ah9, bl6)) | 0;
-    hi = Math.imul(ah9, bh6);
-    lo = (lo + Math.imul(al8, bl7)) | 0;
-    mid = (mid + Math.imul(al8, bh7)) | 0;
-    mid = (mid + Math.imul(ah8, bl7)) | 0;
-    hi = (hi + Math.imul(ah8, bh7)) | 0;
-    lo = (lo + Math.imul(al7, bl8)) | 0;
-    mid = (mid + Math.imul(al7, bh8)) | 0;
-    mid = (mid + Math.imul(ah7, bl8)) | 0;
-    hi = (hi + Math.imul(ah7, bh8)) | 0;
-    lo = (lo + Math.imul(al6, bl9)) | 0;
-    mid = (mid + Math.imul(al6, bh9)) | 0;
-    mid = (mid + Math.imul(ah6, bl9)) | 0;
-    hi = (hi + Math.imul(ah6, bh9)) | 0;
-    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;
-    w15 &= 0x3ffffff;
-    /* k = 16 */
-    lo = Math.imul(al9, bl7);
-    mid = Math.imul(al9, bh7);
-    mid = (mid + Math.imul(ah9, bl7)) | 0;
-    hi = Math.imul(ah9, bh7);
-    lo = (lo + Math.imul(al8, bl8)) | 0;
-    mid = (mid + Math.imul(al8, bh8)) | 0;
-    mid = (mid + Math.imul(ah8, bl8)) | 0;
-    hi = (hi + Math.imul(ah8, bh8)) | 0;
-    lo = (lo + Math.imul(al7, bl9)) | 0;
-    mid = (mid + Math.imul(al7, bh9)) | 0;
-    mid = (mid + Math.imul(ah7, bl9)) | 0;
-    hi = (hi + Math.imul(ah7, bh9)) | 0;
-    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;
-    w16 &= 0x3ffffff;
-    /* k = 17 */
-    lo = Math.imul(al9, bl8);
-    mid = Math.imul(al9, bh8);
-    mid = (mid + Math.imul(ah9, bl8)) | 0;
-    hi = Math.imul(ah9, bh8);
-    lo = (lo + Math.imul(al8, bl9)) | 0;
-    mid = (mid + Math.imul(al8, bh9)) | 0;
-    mid = (mid + Math.imul(ah8, bl9)) | 0;
-    hi = (hi + Math.imul(ah8, bh9)) | 0;
-    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;
-    w17 &= 0x3ffffff;
-    /* k = 18 */
-    lo = Math.imul(al9, bl9);
-    mid = Math.imul(al9, bh9);
-    mid = (mid + Math.imul(ah9, bl9)) | 0;
-    hi = Math.imul(ah9, bh9);
-    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
-    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;
-    w18 &= 0x3ffffff;
-    o[0] = w0;
-    o[1] = w1;
-    o[2] = w2;
-    o[3] = w3;
-    o[4] = w4;
-    o[5] = w5;
-    o[6] = w6;
-    o[7] = w7;
-    o[8] = w8;
-    o[9] = w9;
-    o[10] = w10;
-    o[11] = w11;
-    o[12] = w12;
-    o[13] = w13;
-    o[14] = w14;
-    o[15] = w15;
-    o[16] = w16;
-    o[17] = w17;
-    o[18] = w18;
-    if (c !== 0) {
-      o[19] = c;
-      out.length++;
-    }
-    return out;
-  };
-
-  // Polyfill comb
-  if (!Math.imul) {
-    comb10MulTo = smallMulTo;
-  }
-
-  function bigMulTo (self, num, out) {
-    out.negative = num.negative ^ self.negative;
-    out.length = self.length + num.length;
-
-    var carry = 0;
-    var hncarry = 0;
-    for (var k = 0; k < out.length - 1; k++) {
-      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
-      // note that ncarry could be >= 0x3ffffff
-      var ncarry = hncarry;
-      hncarry = 0;
-      var rword = carry & 0x3ffffff;
-      var maxJ = Math.min(k, num.length - 1);
-      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
-        var i = k - j;
-        var a = self.words[i] | 0;
-        var b = num.words[j] | 0;
-        var r = a * b;
-
-        var lo = r & 0x3ffffff;
-        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
-        lo = (lo + rword) | 0;
-        rword = lo & 0x3ffffff;
-        ncarry = (ncarry + (lo >>> 26)) | 0;
-
-        hncarry += ncarry >>> 26;
-        ncarry &= 0x3ffffff;
-      }
-      out.words[k] = rword;
-      carry = ncarry;
-      ncarry = hncarry;
-    }
-    if (carry !== 0) {
-      out.words[k] = carry;
-    } else {
-      out.length--;
-    }
-
-    return out.strip();
-  }
-
-  function jumboMulTo (self, num, out) {
-    var fftm = new FFTM();
-    return fftm.mulp(self, num, out);
-  }
-
-  BN.prototype.mulTo = function mulTo (num, out) {
-    var res;
-    var len = this.length + num.length;
-    if (this.length === 10 && num.length === 10) {
-      res = comb10MulTo(this, num, out);
-    } else if (len < 63) {
-      res = smallMulTo(this, num, out);
-    } else if (len < 1024) {
-      res = bigMulTo(this, num, out);
-    } else {
-      res = jumboMulTo(this, num, out);
-    }
-
-    return res;
-  };
-
-  // Cooley-Tukey algorithm for FFT
-  // slightly revisited to rely on looping instead of recursion
-
-  function FFTM (x, y) {
-    this.x = x;
-    this.y = y;
-  }
-
-  FFTM.prototype.makeRBT = function makeRBT (N) {
-    var t = new Array(N);
-    var l = BN.prototype._countBits(N) - 1;
-    for (var i = 0; i < N; i++) {
-      t[i] = this.revBin(i, l, N);
-    }
-
-    return t;
-  };
-
-  // Returns binary-reversed representation of `x`
-  FFTM.prototype.revBin = function revBin (x, l, N) {
-    if (x === 0 || x === N - 1) return x;
-
-    var rb = 0;
-    for (var i = 0; i < l; i++) {
-      rb |= (x & 1) << (l - i - 1);
-      x >>= 1;
-    }
-
-    return rb;
-  };
-
-  // Performs "tweedling" phase, therefore 'emulating'
-  // behaviour of the recursive algorithm
-  FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {
-    for (var i = 0; i < N; i++) {
-      rtws[i] = rws[rbt[i]];
-      itws[i] = iws[rbt[i]];
-    }
-  };
-
-  FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {
-    this.permute(rbt, rws, iws, rtws, itws, N);
-
-    for (var s = 1; s < N; s <<= 1) {
-      var l = s << 1;
-
-      var rtwdf = Math.cos(2 * Math.PI / l);
-      var itwdf = Math.sin(2 * Math.PI / l);
-
-      for (var p = 0; p < N; p += l) {
-        var rtwdf_ = rtwdf;
-        var itwdf_ = itwdf;
-
-        for (var j = 0; j < s; j++) {
-          var re = rtws[p + j];
-          var ie = itws[p + j];
-
-          var ro = rtws[p + j + s];
-          var io = itws[p + j + s];
-
-          var rx = rtwdf_ * ro - itwdf_ * io;
-
-          io = rtwdf_ * io + itwdf_ * ro;
-          ro = rx;
-
-          rtws[p + j] = re + ro;
-          itws[p + j] = ie + io;
-
-          rtws[p + j + s] = re - ro;
-          itws[p + j + s] = ie - io;
-
-          /* jshint maxdepth : false */
-          if (j !== l) {
-            rx = rtwdf * rtwdf_ - itwdf * itwdf_;
-
-            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
-            rtwdf_ = rx;
-          }
-        }
-      }
-    }
-  };
-
-  FFTM.prototype.guessLen13b = function guessLen13b (n, m) {
-    var N = Math.max(m, n) | 1;
-    var odd = N & 1;
-    var i = 0;
-    for (N = N / 2 | 0; N; N = N >>> 1) {
-      i++;
-    }
-
-    return 1 << i + 1 + odd;
-  };
-
-  FFTM.prototype.conjugate = function conjugate (rws, iws, N) {
-    if (N <= 1) return;
-
-    for (var i = 0; i < N / 2; i++) {
-      var t = rws[i];
-
-      rws[i] = rws[N - i - 1];
-      rws[N - i - 1] = t;
-
-      t = iws[i];
-
-      iws[i] = -iws[N - i - 1];
-      iws[N - i - 1] = -t;
-    }
-  };
-
-  FFTM.prototype.normalize13b = function normalize13b (ws, N) {
-    var carry = 0;
-    for (var i = 0; i < N / 2; i++) {
-      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
-        Math.round(ws[2 * i] / N) +
-        carry;
-
-      ws[i] = w & 0x3ffffff;
-
-      if (w < 0x4000000) {
-        carry = 0;
-      } else {
-        carry = w / 0x4000000 | 0;
-      }
-    }
-
-    return ws;
-  };
-
-  FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {
-    var carry = 0;
-    for (var i = 0; i < len; i++) {
-      carry = carry + (ws[i] | 0);
-
-      rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;
-      rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;
-    }
-
-    // Pad with zeroes
-    for (i = 2 * len; i < N; ++i) {
-      rws[i] = 0;
-    }
-
-    assert(carry === 0);
-    assert((carry & ~0x1fff) === 0);
-  };
-
-  FFTM.prototype.stub = function stub (N) {
-    var ph = new Array(N);
-    for (var i = 0; i < N; i++) {
-      ph[i] = 0;
-    }
-
-    return ph;
-  };
-
-  FFTM.prototype.mulp = function mulp (x, y, out) {
-    var N = 2 * this.guessLen13b(x.length, y.length);
-
-    var rbt = this.makeRBT(N);
-
-    var _ = this.stub(N);
-
-    var rws = new Array(N);
-    var rwst = new Array(N);
-    var iwst = new Array(N);
-
-    var nrws = new Array(N);
-    var nrwst = new Array(N);
-    var niwst = new Array(N);
-
-    var rmws = out.words;
-    rmws.length = N;
-
-    this.convert13b(x.words, x.length, rws, N);
-    this.convert13b(y.words, y.length, nrws, N);
-
-    this.transform(rws, _, rwst, iwst, N, rbt);
-    this.transform(nrws, _, nrwst, niwst, N, rbt);
-
-    for (var i = 0; i < N; i++) {
-      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
-      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
-      rwst[i] = rx;
-    }
-
-    this.conjugate(rwst, iwst, N);
-    this.transform(rwst, iwst, rmws, _, N, rbt);
-    this.conjugate(rmws, _, N);
-    this.normalize13b(rmws, N);
-
-    out.negative = x.negative ^ y.negative;
-    out.length = x.length + y.length;
-    return out.strip();
-  };
-
-  // Multiply `this` by `num`
-  BN.prototype.mul = function mul (num) {
-    var out = new BN(null);
-    out.words = new Array(this.length + num.length);
-    return this.mulTo(num, out);
-  };
-
-  // Multiply employing FFT
-  BN.prototype.mulf = function mulf (num) {
-    var out = new BN(null);
-    out.words = new Array(this.length + num.length);
-    return jumboMulTo(this, num, out);
-  };
-
-  // In-place Multiplication
-  BN.prototype.imul = function imul (num) {
-    return this.clone().mulTo(num, this);
-  };
-
-  BN.prototype.imuln = function imuln (num) {
-    assert(typeof num === 'number');
-    assert(num < 0x4000000);
-
-    // Carry
-    var carry = 0;
-    for (var i = 0; i < this.length; i++) {
-      var w = (this.words[i] | 0) * num;
-      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
-      carry >>= 26;
-      carry += (w / 0x4000000) | 0;
-      // NOTE: lo is 27bit maximum
-      carry += lo >>> 26;
-      this.words[i] = lo & 0x3ffffff;
-    }
-
-    if (carry !== 0) {
-      this.words[i] = carry;
-      this.length++;
-    }
-
-    return this;
-  };
-
-  BN.prototype.muln = function muln (num) {
-    return this.clone().imuln(num);
-  };
-
-  // `this` * `this`
-  BN.prototype.sqr = function sqr () {
-    return this.mul(this);
-  };
-
-  // `this` * `this` in-place
-  BN.prototype.isqr = function isqr () {
-    return this.imul(this.clone());
-  };
-
-  // Math.pow(`this`, `num`)
-  BN.prototype.pow = function pow (num) {
-    var w = toBitArray(num);
-    if (w.length === 0) return new BN(1);
-
-    // Skip leading zeroes
-    var res = this;
-    for (var i = 0; i < w.length; i++, res = res.sqr()) {
-      if (w[i] !== 0) break;
-    }
-
-    if (++i < w.length) {
-      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
-        if (w[i] === 0) continue;
-
-        res = res.mul(q);
-      }
-    }
-
-    return res;
-  };
-
-  // Shift-left in-place
-  BN.prototype.iushln = function iushln (bits) {
-    assert(typeof bits === 'number' && bits >= 0);
-    var r = bits % 26;
-    var s = (bits - r) / 26;
-    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
-    var i;
-
-    if (r !== 0) {
-      var carry = 0;
-
-      for (i = 0; i < this.length; i++) {
-        var newCarry = this.words[i] & carryMask;
-        var c = ((this.words[i] | 0) - newCarry) << r;
-        this.words[i] = c | carry;
-        carry = newCarry >>> (26 - r);
-      }
-
-      if (carry) {
-        this.words[i] = carry;
-        this.length++;
-      }
-    }
-
-    if (s !== 0) {
-      for (i = this.length - 1; i >= 0; i--) {
-        this.words[i + s] = this.words[i];
-      }
-
-      for (i = 0; i < s; i++) {
-        this.words[i] = 0;
-      }
-
-      this.length += s;
-    }
-
-    return this.strip();
-  };
-
-  BN.prototype.ishln = function ishln (bits) {
-    // TODO(indutny): implement me
-    assert(this.negative === 0);
-    return this.iushln(bits);
-  };
-
-  // Shift-right in-place
-  // NOTE: `hint` is a lowest bit before trailing zeroes
-  // NOTE: if `extended` is present - it will be filled with destroyed bits
-  BN.prototype.iushrn = function iushrn (bits, hint, extended) {
-    assert(typeof bits === 'number' && bits >= 0);
-    var h;
-    if (hint) {
-      h = (hint - (hint % 26)) / 26;
-    } else {
-      h = 0;
-    }
-
-    var r = bits % 26;
-    var s = Math.min((bits - r) / 26, this.length);
-    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
-    var maskedWords = extended;
-
-    h -= s;
-    h = Math.max(0, h);
-
-    // Extended mode, copy masked part
-    if (maskedWords) {
-      for (var i = 0; i < s; i++) {
-        maskedWords.words[i] = this.words[i];
-      }
-      maskedWords.length = s;
-    }
-
-    if (s === 0) {
-      // No-op, we should not move anything at all
-    } else if (this.length > s) {
-      this.length -= s;
-      for (i = 0; i < this.length; i++) {
-        this.words[i] = this.words[i + s];
-      }
-    } else {
-      this.words[0] = 0;
-      this.length = 1;
-    }
-
-    var carry = 0;
-    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
-      var word = this.words[i] | 0;
-      this.words[i] = (carry << (26 - r)) | (word >>> r);
-      carry = word & mask;
-    }
-
-    // Push carried bits as a mask
-    if (maskedWords && carry !== 0) {
-      maskedWords.words[maskedWords.length++] = carry;
-    }
-
-    if (this.length === 0) {
-      this.words[0] = 0;
-      this.length = 1;
-    }
-
-    return this.strip();
-  };
-
-  BN.prototype.ishrn = function ishrn (bits, hint, extended) {
-    // TODO(indutny): implement me
-    assert(this.negative === 0);
-    return this.iushrn(bits, hint, extended);
-  };
-
-  // Shift-left
-  BN.prototype.shln = function shln (bits) {
-    return this.clone().ishln(bits);
-  };
-
-  BN.prototype.ushln = function ushln (bits) {
-    return this.clone().iushln(bits);
-  };
-
-  // Shift-right
-  BN.prototype.shrn = function shrn (bits) {
-    return this.clone().ishrn(bits);
-  };
-
-  BN.prototype.ushrn = function ushrn (bits) {
-    return this.clone().iushrn(bits);
-  };
-
-  // Test if n bit is set
-  BN.prototype.testn = function testn (bit) {
-    assert(typeof bit === 'number' && bit >= 0);
-    var r = bit % 26;
-    var s = (bit - r) / 26;
-    var q = 1 << r;
-
-    // Fast case: bit is much higher than all existing words
-    if (this.length <= s) return false;
-
-    // Check bit and return
-    var w = this.words[s];
-
-    return !!(w & q);
-  };
-
-  // Return only lowers bits of number (in-place)
-  BN.prototype.imaskn = function imaskn (bits) {
-    assert(typeof bits === 'number' && bits >= 0);
-    var r = bits % 26;
-    var s = (bits - r) / 26;
-
-    assert(this.negative === 0, 'imaskn works only with positive numbers');
-
-    if (this.length <= s) {
-      return this;
-    }
-
-    if (r !== 0) {
-      s++;
-    }
-    this.length = Math.min(s, this.length);
-
-    if (r !== 0) {
-      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
-      this.words[this.length - 1] &= mask;
-    }
-
-    return this.strip();
-  };
-
-  // Return only lowers bits of number
-  BN.prototype.maskn = function maskn (bits) {
-    return this.clone().imaskn(bits);
-  };
-
-  // Add plain number `num` to `this`
-  BN.prototype.iaddn = function iaddn (num) {
-    assert(typeof num === 'number');
-    assert(num < 0x4000000);
-    if (num < 0) return this.isubn(-num);
-
-    // Possible sign change
-    if (this.negative !== 0) {
-      if (this.length === 1 && (this.words[0] | 0) < num) {
-        this.words[0] = num - (this.words[0] | 0);
-        this.negative = 0;
-        return this;
-      }
-
-      this.negative = 0;
-      this.isubn(num);
-      this.negative = 1;
-      return this;
-    }
-
-    // Add without checks
-    return this._iaddn(num);
-  };
-
-  BN.prototype._iaddn = function _iaddn (num) {
-    this.words[0] += num;
-
-    // Carry
-    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
-      this.words[i] -= 0x4000000;
-      if (i === this.length - 1) {
-        this.words[i + 1] = 1;
-      } else {
-        this.words[i + 1]++;
-      }
-    }
-    this.length = Math.max(this.length, i + 1);
-
-    return this;
-  };
-
-  // Subtract plain number `num` from `this`
-  BN.prototype.isubn = function isubn (num) {
-    assert(typeof num === 'number');
-    assert(num < 0x4000000);
-    if (num < 0) return this.iaddn(-num);
-
-    if (this.negative !== 0) {
-      this.negative = 0;
-      this.iaddn(num);
-      this.negative = 1;
-      return this;
-    }
-
-    this.words[0] -= num;
-
-    if (this.length === 1 && this.words[0] < 0) {
-      this.words[0] = -this.words[0];
-      this.negative = 1;
-    } else {
-      // Carry
-      for (var i = 0; i < this.length && this.words[i] < 0; i++) {
-        this.words[i] += 0x4000000;
-        this.words[i + 1] -= 1;
-      }
-    }
-
-    return this.strip();
-  };
-
-  BN.prototype.addn = function addn (num) {
-    return this.clone().iaddn(num);
-  };
-
-  BN.prototype.subn = function subn (num) {
-    return this.clone().isubn(num);
-  };
-
-  BN.prototype.iabs = function iabs () {
-    this.negative = 0;
-
-    return this;
-  };
-
-  BN.prototype.abs = function abs () {
-    return this.clone().iabs();
-  };
-
-  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {
-    var len = num.length + shift;
-    var i;
-
-    this._expand(len);
-
-    var w;
-    var carry = 0;
-    for (i = 0; i < num.length; i++) {
-      w = (this.words[i + shift] | 0) + carry;
-      var right = (num.words[i] | 0) * mul;
-      w -= right & 0x3ffffff;
-      carry = (w >> 26) - ((right / 0x4000000) | 0);
-      this.words[i + shift] = w & 0x3ffffff;
-    }
-    for (; i < this.length - shift; i++) {
-      w = (this.words[i + shift] | 0) + carry;
-      carry = w >> 26;
-      this.words[i + shift] = w & 0x3ffffff;
-    }
-
-    if (carry === 0) return this.strip();
-
-    // Subtraction overflow
-    assert(carry === -1);
-    carry = 0;
-    for (i = 0; i < this.length; i++) {
-      w = -(this.words[i] | 0) + carry;
-      carry = w >> 26;
-      this.words[i] = w & 0x3ffffff;
-    }
-    this.negative = 1;
-
-    return this.strip();
-  };
-
-  BN.prototype._wordDiv = function _wordDiv (num, mode) {
-    var shift = this.length - num.length;
-
-    var a = this.clone();
-    var b = num;
-
-    // Normalize
-    var bhi = b.words[b.length - 1] | 0;
-    var bhiBits = this._countBits(bhi);
-    shift = 26 - bhiBits;
-    if (shift !== 0) {
-      b = b.ushln(shift);
-      a.iushln(shift);
-      bhi = b.words[b.length - 1] | 0;
-    }
-
-    // Initialize quotient
-    var m = a.length - b.length;
-    var q;
-
-    if (mode !== 'mod') {
-      q = new BN(null);
-      q.length = m + 1;
-      q.words = new Array(q.length);
-      for (var i = 0; i < q.length; i++) {
-        q.words[i] = 0;
-      }
-    }
-
-    var diff = a.clone()._ishlnsubmul(b, 1, m);
-    if (diff.negative === 0) {
-      a = diff;
-      if (q) {
-        q.words[m] = 1;
-      }
-    }
-
-    for (var j = m - 1; j >= 0; j--) {
-      var qj = (a.words[b.length + j] | 0) * 0x4000000 +
-        (a.words[b.length + j - 1] | 0);
-
-      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
-      // (0x7ffffff)
-      qj = Math.min((qj / bhi) | 0, 0x3ffffff);
-
-      a._ishlnsubmul(b, qj, j);
-      while (a.negative !== 0) {
-        qj--;
-        a.negative = 0;
-        a._ishlnsubmul(b, 1, j);
-        if (!a.isZero()) {
-          a.negative ^= 1;
-        }
-      }
-      if (q) {
-        q.words[j] = qj;
-      }
-    }
-    if (q) {
-      q.strip();
-    }
-    a.strip();
-
-    // Denormalize
-    if (mode !== 'div' && shift !== 0) {
-      a.iushrn(shift);
-    }
-
-    return {
-      div: q || null,
-      mod: a
-    };
-  };
-
-  // NOTE: 1) `mode` can be set to `mod` to request mod only,
-  //       to `div` to request div only, or be absent to
-  //       request both div & mod
-  //       2) `positive` is true if unsigned mod is requested
-  BN.prototype.divmod = function divmod (num, mode, positive) {
-    assert(!num.isZero());
-
-    if (this.isZero()) {
-      return {
-        div: new BN(0),
-        mod: new BN(0)
-      };
-    }
-
-    var div, mod, res;
-    if (this.negative !== 0 && num.negative === 0) {
-      res = this.neg().divmod(num, mode);
-
-      if (mode !== 'mod') {
-        div = res.div.neg();
-      }
-
-      if (mode !== 'div') {
-        mod = res.mod.neg();
-        if (positive && mod.negative !== 0) {
-          mod.iadd(num);
-        }
-      }
-
-      return {
-        div: div,
-        mod: mod
-      };
-    }
-
-    if (this.negative === 0 && num.negative !== 0) {
-      res = this.divmod(num.neg(), mode);
-
-      if (mode !== 'mod') {
-        div = res.div.neg();
-      }
-
-      return {
-        div: div,
-        mod: res.mod
-      };
-    }
-
-    if ((this.negative & num.negative) !== 0) {
-      res = this.neg().divmod(num.neg(), mode);
-
-      if (mode !== 'div') {
-        mod = res.mod.neg();
-        if (positive && mod.negative !== 0) {
-          mod.isub(num);
-        }
-      }
-
-      return {
-        div: res.div,
-        mod: mod
-      };
-    }
-
-    // Both numbers are positive at this point
-
-    // Strip both numbers to approximate shift value
-    if (num.length > this.length || this.cmp(num) < 0) {
-      return {
-        div: new BN(0),
-        mod: this
-      };
-    }
-
-    // Very short reduction
-    if (num.length === 1) {
-      if (mode === 'div') {
-        return {
-          div: this.divn(num.words[0]),
-          mod: null
-        };
-      }
-
-      if (mode === 'mod') {
-        return {
-          div: null,
-          mod: new BN(this.modn(num.words[0]))
-        };
-      }
-
-      return {
-        div: this.divn(num.words[0]),
-        mod: new BN(this.modn(num.words[0]))
-      };
-    }
-
-    return this._wordDiv(num, mode);
-  };
-
-  // Find `this` / `num`
-  BN.prototype.div = function div (num) {
-    return this.divmod(num, 'div', false).div;
-  };
-
-  // Find `this` % `num`
-  BN.prototype.mod = function mod (num) {
-    return this.divmod(num, 'mod', false).mod;
-  };
-
-  BN.prototype.umod = function umod (num) {
-    return this.divmod(num, 'mod', true).mod;
-  };
-
-  // Find Round(`this` / `num`)
-  BN.prototype.divRound = function divRound (num) {
-    var dm = this.divmod(num);
-
-    // Fast case - exact division
-    if (dm.mod.isZero()) return dm.div;
-
-    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
-
-    var half = num.ushrn(1);
-    var r2 = num.andln(1);
-    var cmp = mod.cmp(half);
-
-    // Round down
-    if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
-
-    // Round up
-    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
-  };
-
-  BN.prototype.modn = function modn (num) {
-    assert(num <= 0x3ffffff);
-    var p = (1 << 26) % num;
-
-    var acc = 0;
-    for (var i = this.length - 1; i >= 0; i--) {
-      acc = (p * acc + (this.words[i] | 0)) % num;
-    }
-
-    return acc;
-  };
-
-  // In-place division by number
-  BN.prototype.idivn = function idivn (num) {
-    assert(num <= 0x3ffffff);
-
-    var carry = 0;
-    for (var i = this.length - 1; i >= 0; i--) {
-      var w = (this.words[i] | 0) + carry * 0x4000000;
-      this.words[i] = (w / num) | 0;
-      carry = w % num;
-    }
-
-    return this.strip();
-  };
-
-  BN.prototype.divn = function divn (num) {
-    return this.clone().idivn(num);
-  };
-
-  BN.prototype.egcd = function egcd (p) {
-    assert(p.negative === 0);
-    assert(!p.isZero());
-
-    var x = this;
-    var y = p.clone();
-
-    if (x.negative !== 0) {
-      x = x.umod(p);
-    } else {
-      x = x.clone();
-    }
-
-    // A * x + B * y = x
-    var A = new BN(1);
-    var B = new BN(0);
-
-    // C * x + D * y = y
-    var C = new BN(0);
-    var D = new BN(1);
-
-    var g = 0;
-
-    while (x.isEven() && y.isEven()) {
-      x.iushrn(1);
-      y.iushrn(1);
-      ++g;
-    }
-
-    var yp = y.clone();
-    var xp = x.clone();
-
-    while (!x.isZero()) {
-      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
-      if (i > 0) {
-        x.iushrn(i);
-        while (i-- > 0) {
-          if (A.isOdd() || B.isOdd()) {
-            A.iadd(yp);
-            B.isub(xp);
-          }
-
-          A.iushrn(1);
-          B.iushrn(1);
-        }
-      }
-
-      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
-      if (j > 0) {
-        y.iushrn(j);
-        while (j-- > 0) {
-          if (C.isOdd() || D.isOdd()) {
-            C.iadd(yp);
-            D.isub(xp);
-          }
-
-          C.iushrn(1);
-          D.iushrn(1);
-        }
-      }
-
-      if (x.cmp(y) >= 0) {
-        x.isub(y);
-        A.isub(C);
-        B.isub(D);
-      } else {
-        y.isub(x);
-        C.isub(A);
-        D.isub(B);
-      }
-    }
-
-    return {
-      a: C,
-      b: D,
-      gcd: y.iushln(g)
-    };
-  };
-
-  // This is reduced incarnation of the binary EEA
-  // above, designated to invert members of the
-  // _prime_ fields F(p) at a maximal speed
-  BN.prototype._invmp = function _invmp (p) {
-    assert(p.negative === 0);
-    assert(!p.isZero());
-
-    var a = this;
-    var b = p.clone();
-
-    if (a.negative !== 0) {
-      a = a.umod(p);
-    } else {
-      a = a.clone();
-    }
-
-    var x1 = new BN(1);
-    var x2 = new BN(0);
-
-    var delta = b.clone();
-
-    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
-      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
-      if (i > 0) {
-        a.iushrn(i);
-        while (i-- > 0) {
-          if (x1.isOdd()) {
-            x1.iadd(delta);
-          }
-
-          x1.iushrn(1);
-        }
-      }
-
-      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
-      if (j > 0) {
-        b.iushrn(j);
-        while (j-- > 0) {
-          if (x2.isOdd()) {
-            x2.iadd(delta);
-          }
-
-          x2.iushrn(1);
-        }
-      }
-
-      if (a.cmp(b) >= 0) {
-        a.isub(b);
-        x1.isub(x2);
-      } else {
-        b.isub(a);
-        x2.isub(x1);
-      }
-    }
-
-    var res;
-    if (a.cmpn(1) === 0) {
-      res = x1;
-    } else {
-      res = x2;
-    }
-
-    if (res.cmpn(0) < 0) {
-      res.iadd(p);
-    }
-
-    return res;
-  };
-
-  BN.prototype.gcd = function gcd (num) {
-    if (this.isZero()) return num.abs();
-    if (num.isZero()) return this.abs();
-
-    var a = this.clone();
-    var b = num.clone();
-    a.negative = 0;
-    b.negative = 0;
-
-    // Remove common factor of two
-    for (var shift = 0; a.isEven() && b.isEven(); shift++) {
-      a.iushrn(1);
-      b.iushrn(1);
-    }
-
-    do {
-      while (a.isEven()) {
-        a.iushrn(1);
-      }
-      while (b.isEven()) {
-        b.iushrn(1);
-      }
-
-      var r = a.cmp(b);
-      if (r < 0) {
-        // Swap `a` and `b` to make `a` always bigger than `b`
-        var t = a;
-        a = b;
-        b = t;
-      } else if (r === 0 || b.cmpn(1) === 0) {
-        break;
-      }
-
-      a.isub(b);
-    } while (true);
-
-    return b.iushln(shift);
-  };
-
-  // Invert number in the field F(num)
-  BN.prototype.invm = function invm (num) {
-    return this.egcd(num).a.umod(num);
-  };
-
-  BN.prototype.isEven = function isEven () {
-    return (this.words[0] & 1) === 0;
-  };
-
-  BN.prototype.isOdd = function isOdd () {
-    return (this.words[0] & 1) === 1;
-  };
-
-  // And first word and num
-  BN.prototype.andln = function andln (num) {
-    return this.words[0] & num;
-  };
-
-  // Increment at the bit position in-line
-  BN.prototype.bincn = function bincn (bit) {
-    assert(typeof bit === 'number');
-    var r = bit % 26;
-    var s = (bit - r) / 26;
-    var q = 1 << r;
-
-    // Fast case: bit is much higher than all existing words
-    if (this.length <= s) {
-      this._expand(s + 1);
-      this.words[s] |= q;
-      return this;
-    }
-
-    // Add bit and propagate, if needed
-    var carry = q;
-    for (var i = s; carry !== 0 && i < this.length; i++) {
-      var w = this.words[i] | 0;
-      w += carry;
-      carry = w >>> 26;
-      w &= 0x3ffffff;
-      this.words[i] = w;
-    }
-    if (carry !== 0) {
-      this.words[i] = carry;
-      this.length++;
-    }
-    return this;
-  };
-
-  BN.prototype.isZero = function isZero () {
-    return this.length === 1 && this.words[0] === 0;
-  };
-
-  BN.prototype.cmpn = function cmpn (num) {
-    var negative = num < 0;
-
-    if (this.negative !== 0 && !negative) return -1;
-    if (this.negative === 0 && negative) return 1;
-
-    this.strip();
-
-    var res;
-    if (this.length > 1) {
-      res = 1;
-    } else {
-      if (negative) {
-        num = -num;
-      }
-
-      assert(num <= 0x3ffffff, 'Number is too big');
-
-      var w = this.words[0] | 0;
-      res = w === num ? 0 : w < num ? -1 : 1;
-    }
-    if (this.negative !== 0) return -res | 0;
-    return res;
-  };
-
-  // Compare two numbers and return:
-  // 1 - if `this` > `num`
-  // 0 - if `this` == `num`
-  // -1 - if `this` < `num`
-  BN.prototype.cmp = function cmp (num) {
-    if (this.negative !== 0 && num.negative === 0) return -1;
-    if (this.negative === 0 && num.negative !== 0) return 1;
-
-    var res = this.ucmp(num);
-    if (this.negative !== 0) return -res | 0;
-    return res;
-  };
-
-  // Unsigned comparison
-  BN.prototype.ucmp = function ucmp (num) {
-    // At this point both numbers have the same sign
-    if (this.length > num.length) return 1;
-    if (this.length < num.length) return -1;
-
-    var res = 0;
-    for (var i = this.length - 1; i >= 0; i--) {
-      var a = this.words[i] | 0;
-      var b = num.words[i] | 0;
-
-      if (a === b) continue;
-      if (a < b) {
-        res = -1;
-      } else if (a > b) {
-        res = 1;
-      }
-      break;
-    }
-    return res;
-  };
-
-  BN.prototype.gtn = function gtn (num) {
-    return this.cmpn(num) === 1;
-  };
-
-  BN.prototype.gt = function gt (num) {
-    return this.cmp(num) === 1;
-  };
-
-  BN.prototype.gten = function gten (num) {
-    return this.cmpn(num) >= 0;
-  };
-
-  BN.prototype.gte = function gte (num) {
-    return this.cmp(num) >= 0;
-  };
-
-  BN.prototype.ltn = function ltn (num) {
-    return this.cmpn(num) === -1;
-  };
-
-  BN.prototype.lt = function lt (num) {
-    return this.cmp(num) === -1;
-  };
-
-  BN.prototype.lten = function lten (num) {
-    return this.cmpn(num) <= 0;
-  };
-
-  BN.prototype.lte = function lte (num) {
-    return this.cmp(num) <= 0;
-  };
-
-  BN.prototype.eqn = function eqn (num) {
-    return this.cmpn(num) === 0;
-  };
-
-  BN.prototype.eq = function eq (num) {
-    return this.cmp(num) === 0;
-  };
-
-  //
-  // A reduce context, could be using montgomery or something better, depending
-  // on the `m` itself.
-  //
-  BN.red = function red (num) {
-    return new Red(num);
-  };
-
-  BN.prototype.toRed = function toRed (ctx) {
-    assert(!this.red, 'Already a number in reduction context');
-    assert(this.negative === 0, 'red works only with positives');
-    return ctx.convertTo(this)._forceRed(ctx);
-  };
-
-  BN.prototype.fromRed = function fromRed () {
-    assert(this.red, 'fromRed works only with numbers in reduction context');
-    return this.red.convertFrom(this);
-  };
-
-  BN.prototype._forceRed = function _forceRed (ctx) {
-    this.red = ctx;
-    return this;
-  };
-
-  BN.prototype.forceRed = function forceRed (ctx) {
-    assert(!this.red, 'Already a number in reduction context');
-    return this._forceRed(ctx);
-  };
-
-  BN.prototype.redAdd = function redAdd (num) {
-    assert(this.red, 'redAdd works only with red numbers');
-    return this.red.add(this, num);
-  };
-
-  BN.prototype.redIAdd = function redIAdd (num) {
-    assert(this.red, 'redIAdd works only with red numbers');
-    return this.red.iadd(this, num);
-  };
-
-  BN.prototype.redSub = function redSub (num) {
-    assert(this.red, 'redSub works only with red numbers');
-    return this.red.sub(this, num);
-  };
-
-  BN.prototype.redISub = function redISub (num) {
-    assert(this.red, 'redISub works only with red numbers');
-    return this.red.isub(this, num);
-  };
-
-  BN.prototype.redShl = function redShl (num) {
-    assert(this.red, 'redShl works only with red numbers');
-    return this.red.shl(this, num);
-  };
-
-  BN.prototype.redMul = function redMul (num) {
-    assert(this.red, 'redMul works only with red numbers');
-    this.red._verify2(this, num);
-    return this.red.mul(this, num);
-  };
-
-  BN.prototype.redIMul = function redIMul (num) {
-    assert(this.red, 'redMul works only with red numbers');
-    this.red._verify2(this, num);
-    return this.red.imul(this, num);
-  };
-
-  BN.prototype.redSqr = function redSqr () {
-    assert(this.red, 'redSqr works only with red numbers');
-    this.red._verify1(this);
-    return this.red.sqr(this);
-  };
-
-  BN.prototype.redISqr = function redISqr () {
-    assert(this.red, 'redISqr works only with red numbers');
-    this.red._verify1(this);
-    return this.red.isqr(this);
-  };
-
-  // Square root over p
-  BN.prototype.redSqrt = function redSqrt () {
-    assert(this.red, 'redSqrt works only with red numbers');
-    this.red._verify1(this);
-    return this.red.sqrt(this);
-  };
-
-  BN.prototype.redInvm = function redInvm () {
-    assert(this.red, 'redInvm works only with red numbers');
-    this.red._verify1(this);
-    return this.red.invm(this);
-  };
-
-  // Return negative clone of `this` % `red modulo`
-  BN.prototype.redNeg = function redNeg () {
-    assert(this.red, 'redNeg works only with red numbers');
-    this.red._verify1(this);
-    return this.red.neg(this);
-  };
-
-  BN.prototype.redPow = function redPow (num) {
-    assert(this.red && !num.red, 'redPow(normalNum)');
-    this.red._verify1(this);
-    return this.red.pow(this, num);
-  };
-
-  // Prime numbers with efficient reduction
-  var primes = {
-    k256: null,
-    p224: null,
-    p192: null,
-    p25519: null
-  };
-
-  // Pseudo-Mersenne prime
-  function MPrime (name, p) {
-    // P = 2 ^ N - K
-    this.name = name;
-    this.p = new BN(p, 16);
-    this.n = this.p.bitLength();
-    this.k = new BN(1).iushln(this.n).isub(this.p);
-
-    this.tmp = this._tmp();
-  }
-
-  MPrime.prototype._tmp = function _tmp () {
-    var tmp = new BN(null);
-    tmp.words = new Array(Math.ceil(this.n / 13));
-    return tmp;
-  };
-
-  MPrime.prototype.ireduce = function ireduce (num) {
-    // Assumes that `num` is less than `P^2`
-    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
-    var r = num;
-    var rlen;
-
-    do {
-      this.split(r, this.tmp);
-      r = this.imulK(r);
-      r = r.iadd(this.tmp);
-      rlen = r.bitLength();
-    } while (rlen > this.n);
-
-    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
-    if (cmp === 0) {
-      r.words[0] = 0;
-      r.length = 1;
-    } else if (cmp > 0) {
-      r.isub(this.p);
-    } else {
-      r.strip();
-    }
-
-    return r;
-  };
-
-  MPrime.prototype.split = function split (input, out) {
-    input.iushrn(this.n, 0, out);
-  };
-
-  MPrime.prototype.imulK = function imulK (num) {
-    return num.imul(this.k);
-  };
-
-  function K256 () {
-    MPrime.call(
-      this,
-      'k256',
-      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
-  }
-  inherits(K256, MPrime);
-
-  K256.prototype.split = function split (input, output) {
-    // 256 = 9 * 26 + 22
-    var mask = 0x3fffff;
-
-    var outLen = Math.min(input.length, 9);
-    for (var i = 0; i < outLen; i++) {
-      output.words[i] = input.words[i];
-    }
-    output.length = outLen;
-
-    if (input.length <= 9) {
-      input.words[0] = 0;
-      input.length = 1;
-      return;
-    }
-
-    // Shift by 9 limbs
-    var prev = input.words[9];
-    output.words[output.length++] = prev & mask;
-
-    for (i = 10; i < input.length; i++) {
-      var next = input.words[i] | 0;
-      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);
-      prev = next;
-    }
-    prev >>>= 22;
-    input.words[i - 10] = prev;
-    if (prev === 0 && input.length > 10) {
-      input.length -= 10;
-    } else {
-      input.length -= 9;
-    }
-  };
-
-  K256.prototype.imulK = function imulK (num) {
-    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]
-    num.words[num.length] = 0;
-    num.words[num.length + 1] = 0;
-    num.length += 2;
-
-    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
-    var lo = 0;
-    for (var i = 0; i < num.length; i++) {
-      var w = num.words[i] | 0;
-      lo += w * 0x3d1;
-      num.words[i] = lo & 0x3ffffff;
-      lo = w * 0x40 + ((lo / 0x4000000) | 0);
-    }
-
-    // Fast length reduction
-    if (num.words[num.length - 1] === 0) {
-      num.length--;
-      if (num.words[num.length - 1] === 0) {
-        num.length--;
-      }
-    }
-    return num;
-  };
-
-  function P224 () {
-    MPrime.call(
-      this,
-      'p224',
-      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
-  }
-  inherits(P224, MPrime);
-
-  function P192 () {
-    MPrime.call(
-      this,
-      'p192',
-      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
-  }
-  inherits(P192, MPrime);
-
-  function P25519 () {
-    // 2 ^ 255 - 19
-    MPrime.call(
-      this,
-      '25519',
-      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
-  }
-  inherits(P25519, MPrime);
-
-  P25519.prototype.imulK = function imulK (num) {
-    // K = 0x13
-    var carry = 0;
-    for (var i = 0; i < num.length; i++) {
-      var hi = (num.words[i] | 0) * 0x13 + carry;
-      var lo = hi & 0x3ffffff;
-      hi >>>= 26;
-
-      num.words[i] = lo;
-      carry = hi;
-    }
-    if (carry !== 0) {
-      num.words[num.length++] = carry;
-    }
-    return num;
-  };
-
-  // Exported mostly for testing purposes, use plain name instead
-  BN._prime = function prime (name) {
-    // Cached version of prime
-    if (primes[name]) return primes[name];
-
-    var prime;
-    if (name === 'k256') {
-      prime = new K256();
-    } else if (name === 'p224') {
-      prime = new P224();
-    } else if (name === 'p192') {
-      prime = new P192();
-    } else if (name === 'p25519') {
-      prime = new P25519();
-    } else {
-      throw new Error('Unknown prime ' + name);
-    }
-    primes[name] = prime;
-
-    return prime;
-  };
-
-  //
-  // Base reduction engine
-  //
-  function Red (m) {
-    if (typeof m === 'string') {
-      var prime = BN._prime(m);
-      this.m = prime.p;
-      this.prime = prime;
-    } else {
-      assert(m.gtn(1), 'modulus must be greater than 1');
-      this.m = m;
-      this.prime = null;
-    }
-  }
-
-  Red.prototype._verify1 = function _verify1 (a) {
-    assert(a.negative === 0, 'red works only with positives');
-    assert(a.red, 'red works only with red numbers');
-  };
-
-  Red.prototype._verify2 = function _verify2 (a, b) {
-    assert((a.negative | b.negative) === 0, 'red works only with positives');
-    assert(a.red && a.red === b.red,
-      'red works only with red numbers');
-  };
-
-  Red.prototype.imod = function imod (a) {
-    if (this.prime) return this.prime.ireduce(a)._forceRed(this);
-    return a.umod(this.m)._forceRed(this);
-  };
-
-  Red.prototype.neg = function neg (a) {
-    if (a.isZero()) {
-      return a.clone();
-    }
-
-    return this.m.sub(a)._forceRed(this);
-  };
-
-  Red.prototype.add = function add (a, b) {
-    this._verify2(a, b);
-
-    var res = a.add(b);
-    if (res.cmp(this.m) >= 0) {
-      res.isub(this.m);
-    }
-    return res._forceRed(this);
-  };
-
-  Red.prototype.iadd = function iadd (a, b) {
-    this._verify2(a, b);
-
-    var res = a.iadd(b);
-    if (res.cmp(this.m) >= 0) {
-      res.isub(this.m);
-    }
-    return res;
-  };
-
-  Red.prototype.sub = function sub (a, b) {
-    this._verify2(a, b);
-
-    var res = a.sub(b);
-    if (res.cmpn(0) < 0) {
-      res.iadd(this.m);
-    }
-    return res._forceRed(this);
-  };
-
-  Red.prototype.isub = function isub (a, b) {
-    this._verify2(a, b);
-
-    var res = a.isub(b);
-    if (res.cmpn(0) < 0) {
-      res.iadd(this.m);
-    }
-    return res;
-  };
-
-  Red.prototype.shl = function shl (a, num) {
-    this._verify1(a);
-    return this.imod(a.ushln(num));
-  };
-
-  Red.prototype.imul = function imul (a, b) {
-    this._verify2(a, b);
-    return this.imod(a.imul(b));
-  };
-
-  Red.prototype.mul = function mul (a, b) {
-    this._verify2(a, b);
-    return this.imod(a.mul(b));
-  };
-
-  Red.prototype.isqr = function isqr (a) {
-    return this.imul(a, a.clone());
-  };
-
-  Red.prototype.sqr = function sqr (a) {
-    return this.mul(a, a);
-  };
-
-  Red.prototype.sqrt = function sqrt (a) {
-    if (a.isZero()) return a.clone();
-
-    var mod3 = this.m.andln(3);
-    assert(mod3 % 2 === 1);
-
-    // Fast case
-    if (mod3 === 3) {
-      var pow = this.m.add(new BN(1)).iushrn(2);
-      return this.pow(a, pow);
-    }
-
-    // Tonelli-Shanks algorithm (Totally unoptimized and slow)
-    //
-    // Find Q and S, that Q * 2 ^ S = (P - 1)
-    var q = this.m.subn(1);
-    var s = 0;
-    while (!q.isZero() && q.andln(1) === 0) {
-      s++;
-      q.iushrn(1);
-    }
-    assert(!q.isZero());
-
-    var one = new BN(1).toRed(this);
-    var nOne = one.redNeg();
-
-    // Find quadratic non-residue
-    // NOTE: Max is such because of generalized Riemann hypothesis.
-    var lpow = this.m.subn(1).iushrn(1);
-    var z = this.m.bitLength();
-    z = new BN(2 * z * z).toRed(this);
-
-    while (this.pow(z, lpow).cmp(nOne) !== 0) {
-      z.redIAdd(nOne);
-    }
-
-    var c = this.pow(z, q);
-    var r = this.pow(a, q.addn(1).iushrn(1));
-    var t = this.pow(a, q);
-    var m = s;
-    while (t.cmp(one) !== 0) {
-      var tmp = t;
-      for (var i = 0; tmp.cmp(one) !== 0; i++) {
-        tmp = tmp.redSqr();
-      }
-      assert(i < m);
-      var b = this.pow(c, new BN(1).iushln(m - i - 1));
-
-      r = r.redMul(b);
-      c = b.redSqr();
-      t = t.redMul(c);
-      m = i;
-    }
-
-    return r;
-  };
-
-  Red.prototype.invm = function invm (a) {
-    var inv = a._invmp(this.m);
-    if (inv.negative !== 0) {
-      inv.negative = 0;
-      return this.imod(inv).redNeg();
-    } else {
-      return this.imod(inv);
-    }
-  };
-
-  Red.prototype.pow = function pow (a, num) {
-    if (num.isZero()) return new BN(1).toRed(this);
-    if (num.cmpn(1) === 0) return a.clone();
-
-    var windowSize = 4;
-    var wnd = new Array(1 << windowSize);
-    wnd[0] = new BN(1).toRed(this);
-    wnd[1] = a;
-    for (var i = 2; i < wnd.length; i++) {
-      wnd[i] = this.mul(wnd[i - 1], a);
-    }
-
-    var res = wnd[0];
-    var current = 0;
-    var currentLen = 0;
-    var start = num.bitLength() % 26;
-    if (start === 0) {
-      start = 26;
-    }
-
-    for (i = num.length - 1; i >= 0; i--) {
-      var word = num.words[i];
-      for (var j = start - 1; j >= 0; j--) {
-        var bit = (word >> j) & 1;
-        if (res !== wnd[0]) {
-          res = this.sqr(res);
-        }
-
-        if (bit === 0 && current === 0) {
-          currentLen = 0;
-          continue;
-        }
-
-        current <<= 1;
-        current |= bit;
-        currentLen++;
-        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
-
-        res = this.mul(res, wnd[current]);
-        currentLen = 0;
-        current = 0;
-      }
-      start = 26;
-    }
-
-    return res;
-  };
-
-  Red.prototype.convertTo = function convertTo (num) {
-    var r = num.umod(this.m);
-
-    return r === num ? r.clone() : r;
-  };
-
-  Red.prototype.convertFrom = function convertFrom (num) {
-    var res = num.clone();
-    res.red = null;
-    return res;
-  };
-
-  //
-  // Montgomery method engine
-  //
-
-  BN.mont = function mont (num) {
-    return new Mont(num);
-  };
-
-  function Mont (m) {
-    Red.call(this, m);
-
-    this.shift = this.m.bitLength();
-    if (this.shift % 26 !== 0) {
-      this.shift += 26 - (this.shift % 26);
-    }
-
-    this.r = new BN(1).iushln(this.shift);
-    this.r2 = this.imod(this.r.sqr());
-    this.rinv = this.r._invmp(this.m);
-
-    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
-    this.minv = this.minv.umod(this.r);
-    this.minv = this.r.sub(this.minv);
-  }
-  inherits(Mont, Red);
-
-  Mont.prototype.convertTo = function convertTo (num) {
-    return this.imod(num.ushln(this.shift));
-  };
-
-  Mont.prototype.convertFrom = function convertFrom (num) {
-    var r = this.imod(num.mul(this.rinv));
-    r.red = null;
-    return r;
-  };
-
-  Mont.prototype.imul = function imul (a, b) {
-    if (a.isZero() || b.isZero()) {
-      a.words[0] = 0;
-      a.length = 1;
-      return a;
-    }
-
-    var t = a.imul(b);
-    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
-    var u = t.isub(c).iushrn(this.shift);
-    var res = u;
-
-    if (u.cmp(this.m) >= 0) {
-      res = u.isub(this.m);
-    } else if (u.cmpn(0) < 0) {
-      res = u.iadd(this.m);
-    }
-
-    return res._forceRed(this);
-  };
-
-  Mont.prototype.mul = function mul (a, b) {
-    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
-
-    var t = a.mul(b);
-    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
-    var u = t.isub(c).iushrn(this.shift);
-    var res = u;
-    if (u.cmp(this.m) >= 0) {
-      res = u.isub(this.m);
-    } else if (u.cmpn(0) < 0) {
-      res = u.iadd(this.m);
-    }
-
-    return res._forceRed(this);
-  };
-
-  Mont.prototype.invm = function invm (a) {
-    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R
-    var res = this.imod(a._invmp(this.m).mul(this.r2));
-    return res._forceRed(this);
-  };
-})(typeof module === 'undefined' || module, this);
-
-},{"buffer":26}],25:[function(require,module,exports){
-var r;
-
-module.exports = function rand(len) {
-  if (!r)
-    r = new Rand(null);
-
-  return r.generate(len);
-};
-
-function Rand(rand) {
-  this.rand = rand;
-}
-module.exports.Rand = Rand;
-
-Rand.prototype.generate = function generate(len) {
-  return this._rand(len);
-};
-
-// Emulate crypto API using randy
-Rand.prototype._rand = function _rand(n) {
-  if (this.rand.getBytes)
-    return this.rand.getBytes(n);
-
-  var res = new Uint8Array(n);
-  for (var i = 0; i < res.length; i++)
-    res[i] = this.rand.getByte();
-  return res;
-};
-
-if (typeof self === 'object') {
-  if (self.crypto && self.crypto.getRandomValues) {
-    // Modern browsers
-    Rand.prototype._rand = function _rand(n) {
-      var arr = new Uint8Array(n);
-      self.crypto.getRandomValues(arr);
-      return arr;
-    };
-  } else if (self.msCrypto && self.msCrypto.getRandomValues) {
-    // IE
-    Rand.prototype._rand = function _rand(n) {
-      var arr = new Uint8Array(n);
-      self.msCrypto.getRandomValues(arr);
-      return arr;
-    };
-
-  // Safari's WebWorkers do not have `crypto`
-  } else if (typeof window === 'object') {
-    // Old junk
-    Rand.prototype._rand = function() {
-      throw new Error('Not implemented yet');
-    };
-  }
-} else {
-  // Node.js or Web worker with no crypto support
-  try {
-    var crypto = require('crypto');
-    if (typeof crypto.randomBytes !== 'function')
-      throw new Error('Not supported');
-
-    Rand.prototype._rand = function _rand(n) {
-      return crypto.randomBytes(n);
-    };
-  } catch (e) {
-  }
-}
-
-},{"crypto":26}],26:[function(require,module,exports){
-arguments[4][8][0].apply(exports,arguments)
-},{"dup":8}],27:[function(require,module,exports){
-// based on the aes implimentation in triple sec
-// https://github.com/keybase/triplesec
-// which is in turn based on the one from crypto-js
-// https://code.google.com/p/crypto-js/
-
-var Buffer = require('safe-buffer').Buffer
-
-function asUInt32Array (buf) {
-  if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)
-
-  var len = (buf.length / 4) | 0
-  var out = new Array(len)
-
-  for (var i = 0; i < len; i++) {
-    out[i] = buf.readUInt32BE(i * 4)
-  }
-
-  return out
-}
-
-function scrubVec (v) {
-  for (var i = 0; i < v.length; v++) {
-    v[i] = 0
-  }
-}
-
-function cryptBlock (M, keySchedule, SUB_MIX, SBOX, nRounds) {
-  var SUB_MIX0 = SUB_MIX[0]
-  var SUB_MIX1 = SUB_MIX[1]
-  var SUB_MIX2 = SUB_MIX[2]
-  var SUB_MIX3 = SUB_MIX[3]
-
-  var s0 = M[0] ^ keySchedule[0]
-  var s1 = M[1] ^ keySchedule[1]
-  var s2 = M[2] ^ keySchedule[2]
-  var s3 = M[3] ^ keySchedule[3]
-  var t0, t1, t2, t3
-  var ksRow = 4
-
-  for (var round = 1; round < nRounds; round++) {
-    t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[(s1 >>> 16) & 0xff] ^ SUB_MIX2[(s2 >>> 8) & 0xff] ^ SUB_MIX3[s3 & 0xff] ^ keySchedule[ksRow++]
-    t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[(s2 >>> 16) & 0xff] ^ SUB_MIX2[(s3 >>> 8) & 0xff] ^ SUB_MIX3[s0 & 0xff] ^ keySchedule[ksRow++]
-    t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[(s3 >>> 16) & 0xff] ^ SUB_MIX2[(s0 >>> 8) & 0xff] ^ SUB_MIX3[s1 & 0xff] ^ keySchedule[ksRow++]
-    t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[(s0 >>> 16) & 0xff] ^ SUB_MIX2[(s1 >>> 8) & 0xff] ^ SUB_MIX3[s2 & 0xff] ^ keySchedule[ksRow++]
-    s0 = t0
-    s1 = t1
-    s2 = t2
-    s3 = t3
-  }
-
-  t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]
-  t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]
-  t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]
-  t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]
-  t0 = t0 >>> 0
-  t1 = t1 >>> 0
-  t2 = t2 >>> 0
-  t3 = t3 >>> 0
-
-  return [t0, t1, t2, t3]
-}
-
-// AES constants
-var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]
-var G = (function () {
-  // Compute double table
-  var d = new Array(256)
-  for (var j = 0; j < 256; j++) {
-    if (j < 128) {
-      d[j] = j << 1
-    } else {
-      d[j] = (j << 1) ^ 0x11b
-    }
-  }
-
-  var SBOX = []
-  var INV_SBOX = []
-  var SUB_MIX = [[], [], [], []]
-  var INV_SUB_MIX = [[], [], [], []]
-
-  // Walk GF(2^8)
-  var x = 0
-  var xi = 0
-  for (var i = 0; i < 256; ++i) {
-    // Compute sbox
-    var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4)
-    sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63
-    SBOX[x] = sx
-    INV_SBOX[sx] = x
-
-    // Compute multiplication
-    var x2 = d[x]
-    var x4 = d[x2]
-    var x8 = d[x4]
-
-    // Compute sub bytes, mix columns tables
-    var t = (d[sx] * 0x101) ^ (sx * 0x1010100)
-    SUB_MIX[0][x] = (t << 24) | (t >>> 8)
-    SUB_MIX[1][x] = (t << 16) | (t >>> 16)
-    SUB_MIX[2][x] = (t << 8) | (t >>> 24)
-    SUB_MIX[3][x] = t
-
-    // Compute inv sub bytes, inv mix columns tables
-    t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)
-    INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8)
-    INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16)
-    INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24)
-    INV_SUB_MIX[3][sx] = t
-
-    if (x === 0) {
-      x = xi = 1
-    } else {
-      x = x2 ^ d[d[d[x8 ^ x2]]]
-      xi ^= d[d[xi]]
-    }
-  }
-
-  return {
-    SBOX: SBOX,
-    INV_SBOX: INV_SBOX,
-    SUB_MIX: SUB_MIX,
-    INV_SUB_MIX: INV_SUB_MIX
-  }
-})()
-
-function AES (key) {
-  this._key = asUInt32Array(key)
-  this._reset()
-}
-
-AES.blockSize = 4 * 4
-AES.keySize = 256 / 8
-AES.prototype.blockSize = AES.blockSize
-AES.prototype.keySize = AES.keySize
-AES.prototype._reset = function () {
-  var keyWords = this._key
-  var keySize = keyWords.length
-  var nRounds = keySize + 6
-  var ksRows = (nRounds + 1) * 4
-
-  var keySchedule = []
-  for (var k = 0; k < keySize; k++) {
-    keySchedule[k] = keyWords[k]
-  }
-
-  for (k = keySize; k < ksRows; k++) {
-    var t = keySchedule[k - 1]
-
-    if (k % keySize === 0) {
-      t = (t << 8) | (t >>> 24)
-      t =
-        (G.SBOX[t >>> 24] << 24) |
-        (G.SBOX[(t >>> 16) & 0xff] << 16) |
-        (G.SBOX[(t >>> 8) & 0xff] << 8) |
-        (G.SBOX[t & 0xff])
-
-      t ^= RCON[(k / keySize) | 0] << 24
-    } else if (keySize > 6 && k % keySize === 4) {
-      t =
-        (G.SBOX[t >>> 24] << 24) |
-        (G.SBOX[(t >>> 16) & 0xff] << 16) |
-        (G.SBOX[(t >>> 8) & 0xff] << 8) |
-        (G.SBOX[t & 0xff])
-    }
-
-    keySchedule[k] = keySchedule[k - keySize] ^ t
-  }
-
-  var invKeySchedule = []
-  for (var ik = 0; ik < ksRows; ik++) {
-    var ksR = ksRows - ik
-    var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)]
-
-    if (ik < 4 || ksR <= 4) {
-      invKeySchedule[ik] = tt
-    } else {
-      invKeySchedule[ik] =
-        G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^
-        G.INV_SUB_MIX[1][G.SBOX[(tt >>> 16) & 0xff]] ^
-        G.INV_SUB_MIX[2][G.SBOX[(tt >>> 8) & 0xff]] ^
-        G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]]
-    }
-  }
-
-  this._nRounds = nRounds
-  this._keySchedule = keySchedule
-  this._invKeySchedule = invKeySchedule
-}
-
-AES.prototype.encryptBlockRaw = function (M) {
-  M = asUInt32Array(M)
-  return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds)
-}
-
-AES.prototype.encryptBlock = function (M) {
-  var out = this.encryptBlockRaw(M)
-  var buf = Buffer.allocUnsafe(16)
-  buf.writeUInt32BE(out[0], 0)
-  buf.writeUInt32BE(out[1], 4)
-  buf.writeUInt32BE(out[2], 8)
-  buf.writeUInt32BE(out[3], 12)
-  return buf
-}
-
-AES.prototype.decryptBlock = function (M) {
-  M = asUInt32Array(M)
-
-  // swap
-  var m1 = M[1]
-  M[1] = M[3]
-  M[3] = m1
-
-  var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds)
-  var buf = Buffer.allocUnsafe(16)
-  buf.writeUInt32BE(out[0], 0)
-  buf.writeUInt32BE(out[3], 4)
-  buf.writeUInt32BE(out[2], 8)
-  buf.writeUInt32BE(out[1], 12)
-  return buf
-}
-
-AES.prototype.scrub = function () {
-  scrubVec(this._keySchedule)
-  scrubVec(this._invKeySchedule)
-  scrubVec(this._key)
-}
-
-module.exports.AES = AES
-
-},{"safe-buffer":148}],28:[function(require,module,exports){
-var aes = require('./aes')
-var Buffer = require('safe-buffer').Buffer
-var Transform = require('cipher-base')
-var inherits = require('inherits')
-var GHASH = require('./ghash')
-var xor = require('buffer-xor')
-var incr32 = require('./incr32')
-
-function xorTest (a, b) {
-  var out = 0
-  if (a.length !== b.length) out++
-
-  var len = Math.min(a.length, b.length)
-  for (var i = 0; i < len; ++i) {
-    out += (a[i] ^ b[i])
-  }
-
-  return out
-}
-
-function calcIv (self, iv, ck) {
-  if (iv.length === 12) {
-    self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])])
-    return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])])
-  }
-  var ghash = new GHASH(ck)
-  var len = iv.length
-  var toPad = len % 16
-  ghash.update(iv)
-  if (toPad) {
-    toPad = 16 - toPad
-    ghash.update(Buffer.alloc(toPad, 0))
-  }
-  ghash.update(Buffer.alloc(8, 0))
-  var ivBits = len * 8
-  var tail = Buffer.alloc(8)
-  tail.writeUIntBE(ivBits, 0, 8)
-  ghash.update(tail)
-  self._finID = ghash.state
-  var out = Buffer.from(self._finID)
-  incr32(out)
-  return out
-}
-function StreamCipher (mode, key, iv, decrypt) {
-  Transform.call(this)
-
-  var h = Buffer.alloc(4, 0)
-
-  this._cipher = new aes.AES(key)
-  var ck = this._cipher.encryptBlock(h)
-  this._ghash = new GHASH(ck)
-  iv = calcIv(this, iv, ck)
-
-  this._prev = Buffer.from(iv)
-  this._cache = Buffer.allocUnsafe(0)
-  this._secCache = Buffer.allocUnsafe(0)
-  this._decrypt = decrypt
-  this._alen = 0
-  this._len = 0
-  this._mode = mode
-
-  this._authTag = null
-  this._called = false
-}
-
-inherits(StreamCipher, Transform)
-
-StreamCipher.prototype._update = function (chunk) {
-  if (!this._called && this._alen) {
-    var rump = 16 - (this._alen % 16)
-    if (rump < 16) {
-      rump = Buffer.alloc(rump, 0)
-      this._ghash.update(rump)
-    }
-  }
-
-  this._called = true
-  var out = this._mode.encrypt(this, chunk)
-  if (this._decrypt) {
-    this._ghash.update(chunk)
-  } else {
-    this._ghash.update(out)
-  }
-  this._len += chunk.length
-  return out
-}
-
-StreamCipher.prototype._final = function () {
-  if (this._decrypt && !this._authTag) throw new Error('Unsupported state or unable to authenticate data')
-
-  var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID))
-  if (this._decrypt && xorTest(tag, this._authTag)) throw new Error('Unsupported state or unable to authenticate data')
-
-  this._authTag = tag
-  this._cipher.scrub()
-}
-
-StreamCipher.prototype.getAuthTag = function getAuthTag () {
-  if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error('Attempting to get auth tag in unsupported state')
-
-  return this._authTag
-}
-
-StreamCipher.prototype.setAuthTag = function setAuthTag (tag) {
-  if (!this._decrypt) throw new Error('Attempting to set auth tag in unsupported state')
-
-  this._authTag = tag
-}
-
-StreamCipher.prototype.setAAD = function setAAD (buf) {
-  if (this._called) throw new Error('Attempting to set AAD in unsupported state')
-
-  this._ghash.update(buf)
-  this._alen += buf.length
-}
-
-module.exports = StreamCipher
-
-},{"./aes":27,"./ghash":32,"./incr32":33,"buffer-xor":54,"cipher-base":56,"inherits":107,"safe-buffer":148}],29:[function(require,module,exports){
-var ciphers = require('./encrypter')
-var deciphers = require('./decrypter')
-var modes = require('./modes/list.json')
-
-function getCiphers () {
-  return Object.keys(modes)
-}
-
-exports.createCipher = exports.Cipher = ciphers.createCipher
-exports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv
-exports.createDecipher = exports.Decipher = deciphers.createDecipher
-exports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv
-exports.listCiphers = exports.getCiphers = getCiphers
-
-},{"./decrypter":30,"./encrypter":31,"./modes/list.json":41}],30:[function(require,module,exports){
-var AuthCipher = require('./authCipher')
-var Buffer = require('safe-buffer').Buffer
-var MODES = require('./modes')
-var StreamCipher = require('./streamCipher')
-var Transform = require('cipher-base')
-var aes = require('./aes')
-var ebtk = require('evp_bytestokey')
-var inherits = require('inherits')
-
-function Decipher (mode, key, iv) {
-  Transform.call(this)
-
-  this._cache = new Splitter()
-  this._last = void 0
-  this._cipher = new aes.AES(key)
-  this._prev = Buffer.from(iv)
-  this._mode = mode
-  this._autopadding = true
-}
-
-inherits(Decipher, Transform)
-
-Decipher.prototype._update = function (data) {
-  this._cache.add(data)
-  var chunk
-  var thing
-  var out = []
-  while ((chunk = this._cache.get(this._autopadding))) {
-    thing = this._mode.decrypt(this, chunk)
-    out.push(thing)
-  }
-  return Buffer.concat(out)
-}
-
-Decipher.prototype._final = function () {
-  var chunk = this._cache.flush()
-  if (this._autopadding) {
-    return unpad(this._mode.decrypt(this, chunk))
-  } else if (chunk) {
-    throw new Error('data not multiple of block length')
-  }
-}
-
-Decipher.prototype.setAutoPadding = function (setTo) {
-  this._autopadding = !!setTo
-  return this
-}
-
-function Splitter () {
-  this.cache = Buffer.allocUnsafe(0)
-}
-
-Splitter.prototype.add = function (data) {
-  this.cache = Buffer.concat([this.cache, data])
-}
-
-Splitter.prototype.get = function (autoPadding) {
-  var out
-  if (autoPadding) {
-    if (this.cache.length > 16) {
-      out = this.cache.slice(0, 16)
-      this.cache = this.cache.slice(16)
-      return out
-    }
-  } else {
-    if (this.cache.length >= 16) {
-      out = this.cache.slice(0, 16)
-      this.cache = this.cache.slice(16)
-      return out
-    }
-  }
-
-  return null
-}
-
-Splitter.prototype.flush = function () {
-  if (this.cache.length) return this.cache
-}
-
-function unpad (last) {
-  var padded = last[15]
-  if (padded < 1 || padded > 16) {
-    throw new Error('unable to decrypt data')
-  }
-  var i = -1
-  while (++i < padded) {
-    if (last[(i + (16 - padded))] !== padded) {
-      throw new Error('unable to decrypt data')
-    }
-  }
-  if (padded === 16) return
-
-  return last.slice(0, 16 - padded)
-}
-
-function createDecipheriv (suite, password, iv) {
-  var config = MODES[suite.toLowerCase()]
-  if (!config) throw new TypeError('invalid suite type')
-
-  if (typeof iv === 'string') iv = Buffer.from(iv)
-  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)
-
-  if (typeof password === 'string') password = Buffer.from(password)
-  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)
-
-  if (config.type === 'stream') {
-    return new StreamCipher(config.module, password, iv, true)
-  } else if (config.type === 'auth') {
-    return new AuthCipher(config.module, password, iv, true)
-  }
-
-  return new Decipher(config.module, password, iv)
-}
-
-function createDecipher (suite, password) {
-  var config = MODES[suite.toLowerCase()]
-  if (!config) throw new TypeError('invalid suite type')
-
-  var keys = ebtk(password, false, config.key, config.iv)
-  return createDecipheriv(suite, keys.key, keys.iv)
-}
-
-exports.createDecipher = createDecipher
-exports.createDecipheriv = createDecipheriv
-
-},{"./aes":27,"./authCipher":28,"./modes":40,"./streamCipher":43,"cipher-base":56,"evp_bytestokey":91,"inherits":107,"safe-buffer":148}],31:[function(require,module,exports){
-var MODES = require('./modes')
-var AuthCipher = require('./authCipher')
-var Buffer = require('safe-buffer').Buffer
-var StreamCipher = require('./streamCipher')
-var Transform = require('cipher-base')
-var aes = require('./aes')
-var ebtk = require('evp_bytestokey')
-var inherits = require('inherits')
-
-function Cipher (mode, key, iv) {
-  Transform.call(this)
-
-  this._cache = new Splitter()
-  this._cipher = new aes.AES(key)
-  this._prev = Buffer.from(iv)
-  this._mode = mode
-  this._autopadding = true
-}
-
-inherits(Cipher, Transform)
-
-Cipher.prototype._update = function (data) {
-  this._cache.add(data)
-  var chunk
-  var thing
-  var out = []
-
-  while ((chunk = this._cache.get())) {
-    thing = this._mode.encrypt(this, chunk)
-    out.push(thing)
-  }
-
-  return Buffer.concat(out)
-}
-
-var PADDING = Buffer.alloc(16, 0x10)
-
-Cipher.prototype._final = function () {
-  var chunk = this._cache.flush()
-  if (this._autopadding) {
-    chunk = this._mode.encrypt(this, chunk)
-    this._cipher.scrub()
-    return chunk
-  }
-
-  if (!chunk.equals(PADDING)) {
-    this._cipher.scrub()
-    throw new Error('data not multiple of block length')
-  }
-}
-
-Cipher.prototype.setAutoPadding = function (setTo) {
-  this._autopadding = !!setTo
-  return this
-}
-
-function Splitter () {
-  this.cache = Buffer.allocUnsafe(0)
-}
-
-Splitter.prototype.add = function (data) {
-  this.cache = Buffer.concat([this.cache, data])
-}
-
-Splitter.prototype.get = function () {
-  if (this.cache.length > 15) {
-    var out = this.cache.slice(0, 16)
-    this.cache = this.cache.slice(16)
-    return out
-  }
-  return null
-}
-
-Splitter.prototype.flush = function () {
-  var len = 16 - this.cache.length
-  var padBuff = Buffer.allocUnsafe(len)
-
-  var i = -1
-  while (++i < len) {
-    padBuff.writeUInt8(len, i)
-  }
-
-  return Buffer.concat([this.cache, padBuff])
-}
-
-function createCipheriv (suite, password, iv) {
-  var config = MODES[suite.toLowerCase()]
-  if (!config) throw new TypeError('invalid suite type')
-
-  if (typeof password === 'string') password = Buffer.from(password)
-  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)
-
-  if (typeof iv === 'string') iv = Buffer.from(iv)
-  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)
-
-  if (config.type === 'stream') {
-    return new StreamCipher(config.module, password, iv)
-  } else if (config.type === 'auth') {
-    return new AuthCipher(config.module, password, iv)
-  }
-
-  return new Cipher(config.module, password, iv)
-}
-
-function createCipher (suite, password) {
-  var config = MODES[suite.toLowerCase()]
-  if (!config) throw new TypeError('invalid suite type')
-
-  var keys = ebtk(password, false, config.key, config.iv)
-  return createCipheriv(suite, keys.key, keys.iv)
-}
-
-exports.createCipheriv = createCipheriv
-exports.createCipher = createCipher
-
-},{"./aes":27,"./authCipher":28,"./modes":40,"./streamCipher":43,"cipher-base":56,"evp_bytestokey":91,"inherits":107,"safe-buffer":148}],32:[function(require,module,exports){
-var Buffer = require('safe-buffer').Buffer
-var ZEROES = Buffer.alloc(16, 0)
-
-function toArray (buf) {
-  return [
-    buf.readUInt32BE(0),
-    buf.readUInt32BE(4),
-    buf.readUInt32BE(8),
-    buf.readUInt32BE(12)
-  ]
-}
-
-function fromArray (out) {
-  var buf = Buffer.allocUnsafe(16)
-  buf.writeUInt32BE(out[0] >>> 0, 0)
-  buf.writeUInt32BE(out[1] >>> 0, 4)
-  buf.writeUInt32BE(out[2] >>> 0, 8)
-  buf.writeUInt32BE(out[3] >>> 0, 12)
-  return buf
-}
-
-function GHASH (key) {
-  this.h = key
-  this.state = Buffer.alloc(16, 0)
-  this.cache = Buffer.allocUnsafe(0)
-}
-
-// from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html
-// by Juho Vähä-Herttua
-GHASH.prototype.ghash = function (block) {
-  var i = -1
-  while (++i < block.length) {
-    this.state[i] ^= block[i]
-  }
-  this._multiply()
-}
-
-GHASH.prototype._multiply = function () {
-  var Vi = toArray(this.h)
-  var Zi = [0, 0, 0, 0]
-  var j, xi, lsbVi
-  var i = -1
-  while (++i < 128) {
-    xi = (this.state[~~(i / 8)] & (1 << (7 - (i % 8)))) !== 0
-    if (xi) {
-      // Z_i+1 = Z_i ^ V_i
-      Zi[0] ^= Vi[0]
-      Zi[1] ^= Vi[1]
-      Zi[2] ^= Vi[2]
-      Zi[3] ^= Vi[3]
-    }
-
-    // Store the value of LSB(V_i)
-    lsbVi = (Vi[3] & 1) !== 0
-
-    // V_i+1 = V_i >> 1
-    for (j = 3; j > 0; j--) {
-      Vi[j] = (Vi[j] >>> 1) | ((Vi[j - 1] & 1) << 31)
-    }
-    Vi[0] = Vi[0] >>> 1
-
-    // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R
-    if (lsbVi) {
-      Vi[0] = Vi[0] ^ (0xe1 << 24)
-    }
-  }
-  this.state = fromArray(Zi)
-}
-
-GHASH.prototype.update = function (buf) {
-  this.cache = Buffer.concat([this.cache, buf])
-  var chunk
-  while (this.cache.length >= 16) {
-    chunk = this.cache.slice(0, 16)
-    this.cache = this.cache.slice(16)
-    this.ghash(chunk)
-  }
-}
-
-GHASH.prototype.final = function (abl, bl) {
-  if (this.cache.length) {
-    this.ghash(Buffer.concat([this.cache, ZEROES], 16))
-  }
-
-  this.ghash(fromArray([0, abl, 0, bl]))
-  return this.state
-}
-
-module.exports = GHASH
-
-},{"safe-buffer":148}],33:[function(require,module,exports){
-function incr32 (iv) {
-  var len = iv.length
-  var item
-  while (len--) {
-    item = iv.readUInt8(len)
-    if (item === 255) {
-      iv.writeUInt8(0, len)
-    } else {
-      item++
-      iv.writeUInt8(item, len)
-      break
-    }
-  }
-}
-module.exports = incr32
-
-},{}],34:[function(require,module,exports){
-var xor = require('buffer-xor')
-
-exports.encrypt = function (self, block) {
-  var data = xor(block, self._prev)
-
-  self._prev = self._cipher.encryptBlock(data)
-  return self._prev
-}
-
-exports.decrypt = function (self, block) {
-  var pad = self._prev
-
-  self._prev = block
-  var out = self._cipher.decryptBlock(block)
-
-  return xor(out, pad)
-}
-
-},{"buffer-xor":54}],35:[function(require,module,exports){
-var Buffer = require('safe-buffer').Buffer
-var xor = require('buffer-xor')
-
-function encryptStart (self, data, decrypt) {
-  var len = data.length
-  var out = xor(data, self._cache)
-  self._cache = self._cache.slice(len)
-  self._prev = Buffer.concat([self._prev, decrypt ? data : out])
-  return out
-}
-
-exports.encrypt = function (self, data, decrypt) {
-  var out = Buffer.allocUnsafe(0)
-  var len
-
-  while (data.length) {
-    if (self._cache.length === 0) {
-      self._cache = self._cipher.encryptBlock(self._prev)
-      self._prev = Buffer.allocUnsafe(0)
-    }
-
-    if (self._cache.length <= data.length) {
-      len = self._cache.length
-      out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)])
-      data = data.slice(len)
-    } else {
-      out = Buffer.concat([out, encryptStart(self, data, decrypt)])
-      break
-    }
-  }
-
-  return out
-}
-
-},{"buffer-xor":54,"safe-buffer":148}],36:[function(require,module,exports){
-var Buffer = require('safe-buffer').Buffer
-
-function encryptByte (self, byteParam, decrypt) {
-  var pad
-  var i = -1
-  var len = 8
-  var out = 0
-  var bit, value
-  while (++i < len) {
-    pad = self._cipher.encryptBlock(self._prev)
-    bit = (byteParam & (1 << (7 - i))) ? 0x80 : 0
-    value = pad[0] ^ bit
-    out += ((value & 0x80) >> (i % 8))
-    self._prev = shiftIn(self._prev, decrypt ? bit : value)
-  }
-  return out
-}
-
-function shiftIn (buffer, value) {
-  var len = buffer.length
-  var i = -1
-  var out = Buffer.allocUnsafe(buffer.length)
-  buffer = Buffer.concat([buffer, Buffer.from([value])])
-
-  while (++i < len) {
-    out[i] = buffer[i] << 1 | buffer[i + 1] >> (7)
-  }
-
-  return out
-}
-
-exports.encrypt = function (self, chunk, decrypt) {
-  var len = chunk.length
-  var out = Buffer.allocUnsafe(len)
-  var i = -1
-
-  while (++i < len) {
-    out[i] = encryptByte(self, chunk[i], decrypt)
-  }
-
-  return out
-}
-
-},{"safe-buffer":148}],37:[function(require,module,exports){
-var Buffer = require('safe-buffer').Buffer
-
-function encryptByte (self, byteParam, decrypt) {
-  var pad = self._cipher.encryptBlock(self._prev)
-  var out = pad[0] ^ byteParam
-
-  self._prev = Buffer.concat([
-    self._prev.slice(1),
-    Buffer.from([decrypt ? byteParam : out])
-  ])
-
-  return out
-}
-
-exports.encrypt = function (self, chunk, decrypt) {
-  var len = chunk.length
-  var out = Buffer.allocUnsafe(len)
-  var i = -1
-
-  while (++i < len) {
-    out[i] = encryptByte(self, chunk[i], decrypt)
-  }
-
-  return out
-}
-
-},{"safe-buffer":148}],38:[function(require,module,exports){
-var xor = require('buffer-xor')
-var Buffer = require('safe-buffer').Buffer
-var incr32 = require('../incr32')
-
-function getBlock (self) {
-  var out = self._cipher.encryptBlockRaw(self._prev)
-  incr32(self._prev)
-  return out
-}
-
-var blockSize = 16
-exports.encrypt = function (self, chunk) {
-  var chunkNum = Math.ceil(chunk.length / blockSize)
-  var start = self._cache.length
-  self._cache = Buffer.concat([
-    self._cache,
-    Buffer.allocUnsafe(chunkNum * blockSize)
-  ])
-  for (var i = 0; i < chunkNum; i++) {
-    var out = getBlock(self)
-    var offset = start + i * blockSize
-    self._cache.writeUInt32BE(out[0], offset + 0)
-    self._cache.writeUInt32BE(out[1], offset + 4)
-    self._cache.writeUInt32BE(out[2], offset + 8)
-    self._cache.writeUInt32BE(out[3], offset + 12)
-  }
-  var pad = self._cache.slice(0, chunk.length)
-  self._cache = self._cache.slice(chunk.length)
-  return xor(chunk, pad)
-}
-
-},{"../incr32":33,"buffer-xor":54,"safe-buffer":148}],39:[function(require,module,exports){
-exports.encrypt = function (self, block) {
-  return self._cipher.encryptBlock(block)
-}
-
-exports.decrypt = function (self, block) {
-  return self._cipher.decryptBlock(block)
-}
-
-},{}],40:[function(require,module,exports){
-var modeModules = {
-  ECB: require('./ecb'),
-  CBC: require('./cbc'),
-  CFB: require('./cfb'),
-  CFB8: require('./cfb8'),
-  CFB1: require('./cfb1'),
-  OFB: require('./ofb'),
-  CTR: require('./ctr'),
-  GCM: require('./ctr')
-}
-
-var modes = require('./list.json')
-
-for (var key in modes) {
-  modes[key].module = modeModules[modes[key].mode]
-}
-
-module.exports = modes
-
-},{"./cbc":34,"./cfb":35,"./cfb1":36,"./cfb8":37,"./ctr":38,"./ecb":39,"./list.json":41,"./ofb":42}],41:[function(require,module,exports){
-module.exports={
-  "aes-128-ecb": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 0,
-    "mode": "ECB",
-    "type": "block"
-  },
-  "aes-192-ecb": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 0,
-    "mode": "ECB",
-    "type": "block"
-  },
-  "aes-256-ecb": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 0,
-    "mode": "ECB",
-    "type": "block"
-  },
-  "aes-128-cbc": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 16,
-    "mode": "CBC",
-    "type": "block"
-  },
-  "aes-192-cbc": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 16,
-    "mode": "CBC",
-    "type": "block"
-  },
-  "aes-256-cbc": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 16,
-    "mode": "CBC",
-    "type": "block"
-  },
-  "aes128": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 16,
-    "mode": "CBC",
-    "type": "block"
-  },
-  "aes192": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 16,
-    "mode": "CBC",
-    "type": "block"
-  },
-  "aes256": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 16,
-    "mode": "CBC",
-    "type": "block"
-  },
-  "aes-128-cfb": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 16,
-    "mode": "CFB",
-    "type": "stream"
-  },
-  "aes-192-cfb": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 16,
-    "mode": "CFB",
-    "type": "stream"
-  },
-  "aes-256-cfb": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 16,
-    "mode": "CFB",
-    "type": "stream"
-  },
-  "aes-128-cfb8": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 16,
-    "mode": "CFB8",
-    "type": "stream"
-  },
-  "aes-192-cfb8": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 16,
-    "mode": "CFB8",
-    "type": "stream"
-  },
-  "aes-256-cfb8": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 16,
-    "mode": "CFB8",
-    "type": "stream"
-  },
-  "aes-128-cfb1": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 16,
-    "mode": "CFB1",
-    "type": "stream"
-  },
-  "aes-192-cfb1": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 16,
-    "mode": "CFB1",
-    "type": "stream"
-  },
-  "aes-256-cfb1": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 16,
-    "mode": "CFB1",
-    "type": "stream"
-  },
-  "aes-128-ofb": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 16,
-    "mode": "OFB",
-    "type": "stream"
-  },
-  "aes-192-ofb": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 16,
-    "mode": "OFB",
-    "type": "stream"
-  },
-  "aes-256-ofb": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 16,
-    "mode": "OFB",
-    "type": "stream"
-  },
-  "aes-128-ctr": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 16,
-    "mode": "CTR",
-    "type": "stream"
-  },
-  "aes-192-ctr": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 16,
-    "mode": "CTR",
-    "type": "stream"
-  },
-  "aes-256-ctr": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 16,
-    "mode": "CTR",
-    "type": "stream"
-  },
-  "aes-128-gcm": {
-    "cipher": "AES",
-    "key": 128,
-    "iv": 12,
-    "mode": "GCM",
-    "type": "auth"
-  },
-  "aes-192-gcm": {
-    "cipher": "AES",
-    "key": 192,
-    "iv": 12,
-    "mode": "GCM",
-    "type": "auth"
-  },
-  "aes-256-gcm": {
-    "cipher": "AES",
-    "key": 256,
-    "iv": 12,
-    "mode": "GCM",
-    "type": "auth"
-  }
-}
-
-},{}],42:[function(require,module,exports){
-(function (Buffer){
-var xor = require('buffer-xor')
-
-function getBlock (self) {
-  self._prev = self._cipher.encryptBlock(self._prev)
-  return self._prev
-}
-
-exports.encrypt = function (self, chunk) {
-  while (self._cache.length < chunk.length) {
-    self._cache = Buffer.concat([self._cache, getBlock(self)])
-  }
-
-  var pad = self._cache.slice(0, chunk.length)
-  self._cache = self._cache.slice(chunk.length)
-  return xor(chunk, pad)
-}
-
-}).call(this,require("buffer").Buffer)
-},{"buffer":55,"buffer-xor":54}],43:[function(require,module,exports){
-var aes = require('./aes')
-var Buffer = require('safe-buffer').Buffer
-var Transform = require('cipher-base')
-var inherits = require('inherits')
-
-function StreamCipher (mode, key, iv, decrypt) {
-  Transform.call(this)
-
-  this._cipher = new aes.AES(key)
-  this._prev = Buffer.from(iv)
-  this._cache = Buffer.allocUnsafe(0)
-  this._secCache = Buffer.allocUnsafe(0)
-  this._decrypt = decrypt
-  this._mode = mode
-}
-
-inherits(StreamCipher, Transform)
-
-StreamCipher.prototype._update = function (chunk) {
-  return this._mode.encrypt(this, chunk, this._decrypt)
-}
-
-StreamCipher.prototype._final = function () {
-  this._cipher.scrub()
-}
-
-module.exports = StreamCipher
-
-},{"./aes":27,"cipher-base":56,"inherits":107,"safe-buffer":148}],44:[function(require,module,exports){
-var DES = require('browserify-des')
-var aes = require('browserify-aes/browser')
-var aesModes = require('browserify-aes/modes')
-var desModes = require('browserify-des/modes')
-var ebtk = require('evp_bytestokey')
-
-function createCipher (suite, password) {
-  suite = suite.toLowerCase()
-
-  var keyLen, ivLen
-  if (aesModes[suite]) {
-    keyLen = aesModes[suite].key
-    ivLen = aesModes[suite].iv
-  } else if (desModes[suite]) {
-    keyLen = desModes[suite].key * 8
-    ivLen = desModes[suite].iv
-  } else {
-    throw new TypeError('invalid suite type')
-  }
-
-  var keys = ebtk(password, false, keyLen, ivLen)
-  return createCipheriv(suite, keys.key, keys.iv)
-}
-
-function createDecipher (suite, password) {
-  suite = suite.toLowerCase()
-
-  var keyLen, ivLen
-  if (aesModes[suite]) {
-    keyLen = aesModes[suite].key
-    ivLen = aesModes[suite].iv
-  } else if (desModes[suite]) {
-    keyLen = desModes[suite].key * 8
-    ivLen = desModes[suite].iv
-  } else {
-    throw new TypeError('invalid suite type')
-  }
-
-  var keys = ebtk(password, false, keyLen, ivLen)
-  return createDecipheriv(suite, keys.key, keys.iv)
-}
-
-function createCipheriv (suite, key, iv) {
-  suite = suite.toLowerCase()
-  if (aesModes[suite]) return aes.createCipheriv(suite, key, iv)
-  if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite })
-
-  throw new TypeError('invalid suite type')
-}
-
-function createDecipheriv (suite, key, iv) {
-  suite = suite.toLowerCase()
-  if (aesModes[suite]) return aes.createDecipheriv(suite, key, iv)
-  if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite, decrypt: true })
-
-  throw new TypeError('invalid suite type')
-}
-
-function getCiphers () {
-  return Object.keys(desModes).concat(aes.getCiphers())
-}
-
-exports.createCipher = exports.Cipher = createCipher
-exports.createCipheriv = exports.Cipheriv = createCipheriv
-exports.createDecipher = exports.Decipher = createDecipher
-exports.createDecipheriv = exports.Decipheriv = createDecipheriv
-exports.listCiphers = exports.getCiphers = getCiphers
-
-},{"browserify-aes/browser":29,"browserify-aes/modes":40,"browserify-des":45,"browserify-des/modes":46,"evp_bytestokey":91}],45:[function(require,module,exports){
-(function (Buffer){
-var CipherBase = require('cipher-base')
-var des = require('des.js')
-var inherits = require('inherits')
-
-var modes = {
-  'des-ede3-cbc': des.CBC.instantiate(des.EDE),
-  'des-ede3': des.EDE,
-  'des-ede-cbc': des.CBC.instantiate(des.EDE),
-  'des-ede': des.EDE,
-  'des-cbc': des.CBC.instantiate(des.DES),
-  'des-ecb': des.DES
-}
-modes.des = modes['des-cbc']
-modes.des3 = modes['des-ede3-cbc']
-module.exports = DES
-inherits(DES, CipherBase)
-function DES (opts) {
-  CipherBase.call(this)
-  var modeName = opts.mode.toLowerCase()
-  var mode = modes[modeName]
-  var type
-  if (opts.decrypt) {
-    type = 'decrypt'
-  } else {
-    type = 'encrypt'
-  }
-  var key = opts.key
-  if (modeName === 'des-ede' || modeName === 'des-ede-cbc') {
-    key = Buffer.concat([key, key.slice(0, 8)])
-  }
-  var iv = opts.iv
-  this._des = mode.create({
-    key: key,
-    iv: iv,
-    type: type
-  })
-}
-DES.prototype._update = function (data) {
-  return new Buffer(this._des.update(data))
-}
-DES.prototype._final = function () {
-  return new Buffer(this._des.final())
-}
-
-}).call(this,require("buffer").Buffer)
-},{"buffer":55,"cipher-base":56,"des.js":64,"inherits":107}],46:[function(require,module,exports){
-exports['des-ecb'] = {
-  key: 8,
-  iv: 0
-}
-exports['des-cbc'] = exports.des = {
-  key: 8,
-  iv: 8
-}
-exports['des-ede3-cbc'] = exports.des3 = {
-  key: 24,
-  iv: 8
-}
-exports['des-ede3'] = {
-  key: 24,
-  iv: 0
-}
-exports['des-ede-cbc'] = {
-  key: 16,
-  iv: 8
-}
-exports['des-ede'] = {
-  key: 16,
-  iv: 0
-}
-
-},{}],47:[function(require,module,exports){
-(function (Buffer){
-var bn = require('bn.js');
-var randomBytes = require('randombytes');
-module.exports = crt;
-function blind(priv) {
-  var r = getr(priv);
-  var blinder = r.toRed(bn.mont(priv.modulus))
-  .redPow(new bn(priv.publicExponent)).fromRed();
-  return {
-    blinder: blinder,
-    unblinder:r.invm(priv.modulus)
-  };
-}
-function crt(msg, priv) {
-  var blinds = blind(priv);
-  var len = priv.modulus.byteLength();
-  var mod = bn.mont(priv.modulus);
-  var blinded = new bn(msg).mul(blinds.blinder).umod(priv.modulus);
-  var c1 = blinded.toRed(bn.mont(priv.prime1));
-  var c2 = blinded.toRed(bn.mont(priv.prime2));
-  var qinv = priv.coefficient;
-  var p = priv.prime1;
-  var q = priv.prime2;
-  var m1 = c1.redPow(priv.exponent1);
-  var m2 = c2.redPow(priv.exponent2);
-  m1 = m1.fromRed();
-  m2 = m2.fromRed();
-  var h = m1.isub(m2).imul(qinv).umod(p);
-  h.imul(q);
-  m2.iadd(h);
-  return new Buffer(m2.imul(blinds.unblinder).umod(priv.modulus).toArray(false, len));
-}
-crt.getr = getr;
-function getr(priv) {
-  var len = priv.modulus.byteLength();
-  var r = new bn(randomBytes(len));
-  while (r.cmp(priv.modulus) >=  0 || !r.umod(priv.prime1) || !r.umod(priv.prime2)) {
-    r = new bn(randomBytes(len));
-  }
-  return r;
-}
-
-}).call(this,require("buffer").Buffer)
-},{"bn.js":24,"buffer":55,"randombytes":132}],48:[function(require,module,exports){
-module.exports = require('./browser/algorithms.json')
-
-},{"./browser/algorithms.json":49}],49:[function(require,module,exports){
-module.exports={
-  "sha224WithRSAEncryption": {
-    "sign": "rsa",
-    "hash": "sha224",
-    "id": "302d300d06096086480165030402040500041c"
-  },
-  "RSA-SHA224": {
-    "sign": "ecdsa/rsa",
-    "hash": "sha224",
-    "id": "302d300d06096086480165030402040500041c"
-  },
-  "sha256WithRSAEncryption": {
-    "sign": "rsa",
-    "hash": "sha256",
-    "id": "3031300d060960864801650304020105000420"
-  },
-  "RSA-SHA256": {
-    "sign": "ecdsa/rsa",
-    "hash": "sha256",
-    "id": "3031300d060960864801650304020105000420"
-  },
-  "sha384WithRSAEncryption": {
-    "sign": "rsa",
-    "hash": "sha384",
-    "id": "3041300d060960864801650304020205000430"
-  },
-  "RSA-SHA384": {
-    "sign": "ecdsa/rsa",
-    "hash": "sha384",
-    "id": "3041300d060960864801650304020205000430"
-  },
-  "sha512WithRSAEncryption": {
-    "sign": "rsa",
-    "hash": "sha512",
-    "id": "3051300d060960864801650304020305000440"
-  },
-  "RSA-SHA512": {
-    "sign": "ecdsa/rsa",
-    "hash": "sha512",
-    "id": "3051300d060960864801650304020305000440"
-  },
-  "RSA-SHA1": {
-    "sign": "rsa",
-    "hash": "sha1",
-    "id": "3021300906052b0e03021a05000414"
-  },
-  "ecdsa-with-SHA1": {
-    "sign": "ecdsa",
-    "hash": "sha1",
-    "id": ""
-  },
-  "sha256": {
-    "sign": "ecdsa",
-    "hash": "sha256",
-    "id": ""
-  },
-  "sha224": {
-    "sign": "ecdsa",
-    "hash": "sha224",
-    "id": ""
-  },
-  "sha384": {
-    "sign": "ecdsa",
-    "hash": "sha384",
-    "id": ""
-  },
-  "sha512": {
-    "sign": "ecdsa",
-    "hash": "sha512",
-    "id": ""
-  },
-  "DSA-SHA": {
-    "sign": "dsa",
-    "hash": "sha1",
-    "id": ""
-  },
-  "DSA-SHA1": {
-    "sign": "dsa",
-    "hash": "sha1",
-    "id": ""
-  },
-  "DSA": {
-    "sign": "dsa",
-    "hash": "sha1",
-    "id": ""
-  },
-  "DSA-WITH-SHA224": {
-    "sign": "dsa",
-    "hash": "sha224",
-    "id": ""
-  },
-  "DSA-SHA224": {
-    "sign": "dsa",
-    "hash": "sha224",
-    "id": ""
-  },
-  "DSA-WITH-SHA256": {
-    "sign": "dsa",
-    "hash": "sha256",
-    "id": ""
-  },
-  "DSA-SHA256": {
-    "sign": "dsa",
-    "hash": "sha256",
-    "id": ""
-  },
-  "DSA-WITH-SHA384": {
-    "sign": "dsa",
-    "hash": "sha384",
-    "id": ""
-  },
-  "DSA-SHA384": {
-    "sign": "dsa",
-    "hash": "sha384",
-    "id": ""
-  },
-  "DSA-WITH-SHA512": {
-    "sign": "dsa",
-    "hash": "sha512",
-    "id": ""
-  },
-  "DSA-SHA512": {
-    "sign": "dsa",
-    "hash": "sha512",
-    "id": ""
-  },
-  "DSA-RIPEMD160": {
-    "sign": "dsa",
-    "hash": "rmd160",
-    "id": ""
-  },
-  "ripemd160WithRSA": {
-    "sign": "rsa",
-    "hash": "rmd160",
-    "id": "3021300906052b2403020105000414"
-  },
-  "RSA-RIPEMD160": {
-    "sign": "rsa",
-    "hash": "rmd160",
-    "id": "3021300906052b2403020105000414"
-  },
-  "md5WithRSAEncryption": {
-    "sign": "rsa",
-    "hash": "md5",
-    "id": "3020300c06082a864886f70d020505000410"
-  },
-  "RSA-MD5": {
-    "sign": "rsa",
-    "hash": "md5",
-    "id": "3020300c06082a864886f70d020505000410"
-  }
-}
-
-},{}],50:[function(require,module,exports){
-module.exports={
-  "1.3.132.0.10": "secp256k1",
-  "1.3.132.0.33": "p224",
-  "1.2.840.10045.3.1.1": "p192",
-  "1.2.840.10045.3.1.7": "p256",
-  "1.3.132.0.34": "p384",
-  "1.3.132.0.35": "p521"
-}
-
-},{}],51:[function(require,module,exports){
-(function (Buffer){
-var createHash = require('create-hash')
-var stream = require('stream')
-var inherits = require('inherits')
-var sign = require('./sign')
-var verify = require('./verify')
-
-var algorithms = require('./algorithms.json')
-Object.keys(algorithms).forEach(function (key) {
-  algorithms[key].id = new Buffer(algorithms[key].id, 'hex')
-  algorithms[key.toLowerCase()] = algorithms[key]
-})
-
-function Sign (algorithm) {
-  stream.Writable.call(this)
-
-  var data = algorithms[algorithm]
-  if (!data) throw new Error('Unknown message digest')
-
-  this._hashType = data.hash
-  this._hash = createHash(data.hash)
-  this._tag = data.id
-  this._signType = data.sign
-}
-inherits(Sign, stream.Writable)
-
-Sign.prototype._write = function _write (data, _, done) {
-  this._hash.update(data)
-  done()
-}
-
-Sign.prototype.update = function update (data, enc) {
-  if (typeof data === 'string') data = new Buffer(data, enc)
-
-  this._hash.update(data)
-  return this
-}
-
-Sign.prototype.sign = function signMethod (key, enc) {
-  this.end()
-  var hash = this._hash.digest()
-  var sig = sign(hash, key, this._hashType, this._signType, this._tag)
-
-  return enc ? sig.toString(enc) : sig
-}
-
-function Verify (algorithm) {
-  stream.Writable.call(this)
-
-  var data = algorithms[algorithm]
-  if (!data) throw new Error('Unknown message digest')
-
-  this._hash = createHash(data.hash)
-  this._tag = data.id
-  this._signType = data.sign
-}
-inherits(Verify, stream.Writable)
-
-Verify.prototype._write = function _write (data, _, done) {
-  this._hash.update(data)
-  done()
-}
-
-Verify.prototype.update = function update (data, enc) {
-  if (typeof data === 'string') data = new Buffer(data, enc)
-
-  this._hash.update(data)
-  return this
-}
-
-Verify.prototype.verify = function verifyMethod (key, sig, enc) {
-  if (typeof sig === 'string') sig = new Buffer(sig, enc)
-
-  this.end()
-  var hash = this._hash.digest()
-  return verify(sig, hash, key, this._signType, this._tag)
-}
-
-function createSign (algorithm) {
-  return new Sign(algorithm)
-}
-
-function createVerify (algorithm) {
-  return new Verify(algorithm)
-}
-
-module.exports = {
-  Sign: createSign,
-  Verify: createVerify,
-  createSign: createSign,
-  createVerify: createVerify
-}
-
-}).call(this,require("buffer").Buffer)
-},{"./algorithms.json":49,"./sign":52,"./verify":53,"buffer":55,"create-hash":59,"inherits":107,"stream":157}],52:[function(require,module,exports){
-(function (Buffer){
-// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
-var createHmac = require('create-hmac')
-var crt = require('browserify-rsa')
-var EC = require('elliptic').ec
-var BN = require('bn.js')
-var parseKeys = require('parse-asn1')
-var curves = require('./curves.json')
-
-function sign (hash, key, hashType, signType, tag) {
-  var priv = parseKeys(key)
-  if (priv.curve) {
-    // rsa keys can be interpreted as ecdsa ones in openssl
-    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')
-    return ecSign(hash, priv)
-  } else if (priv.type === 'dsa') {
-    if (signType !== 'dsa') throw new Error('wrong private key type')
-    return dsaSign(hash, priv, hashType)
-  } else {
-    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')
-  }
-  hash = Buffer.concat([tag, hash])
-  var len = priv.modulus.byteLength()
-  var pad = [ 0, 1 ]
-  while (hash.length + pad.length + 1 < len) pad.push(0xff)
-  pad.push(0x00)
-  var i = -1
-  while (++i < hash.length) pad.push(hash[i])
-
-  var out = crt(pad, priv)
-  return out
-}
-
-function ecSign (hash, priv) {
-  var curveId = curves[priv.curve.join('.')]
-  if (!curveId) throw new Error('unknown curve ' + priv.curve.join('.'))
-
-  var curve = new EC(curveId)
-  var key = curve.keyFromPrivate(priv.privateKey)
-  var out = key.sign(hash)
-
-  return new Buffer(out.toDER())
-}
-
-function dsaSign (hash, priv, algo) {
-  var x = priv.params.priv_key
-  var p = priv.params.p
-  var q = priv.params.q
-  var g = priv.params.g
-  var r = new BN(0)
-  var k
-  var H = bits2int(hash, q).mod(q)
-  var s = false
-  var kv = getKey(x, q, hash, algo)
-  while (s === false) {
-    k = makeKey(q, kv, algo)
-    r = makeR(g, k, p, q)
-    s = k.invm(q).imul(H.add(x.mul(r))).mod(q)
-    if (s.cmpn(0) === 0) {
-      s = false
-      r = new BN(0)
-    }
-  }
-  return toDER(r, s)
-}
-
-function toDER (r, s) {
-  r = r.toArray()
-  s = s.toArray()
-
-  // Pad values
-  if (r[0] & 0x80) r = [ 0 ].concat(r)
-  if (s[0] & 0x80) s = [ 0 ].concat(s)
-
-  var total = r.length + s.length + 4
-  var res = [ 0x30, total, 0x02, r.length ]
-  res = res.concat(r, [ 0x02, s.length ], s)
-  return new Buffer(res)
-}
-
-function getKey (x, q, hash, algo) {
-  x = new Buffer(x.toArray())
-  if (x.length < q.byteLength()) {
-    var zeros = new Buffer(q.byteLength() - x.length)
-    zeros.fill(0)
-    x = Buffer.concat([ zeros, x ])
-  }
-  var hlen = hash.length
-  var hbits = bits2octets(hash, q)
-  var v = new Buffer(hlen)
-  v.fill(1)
-  var k = new Buffer(hlen)
-  k.fill(0)
-  k = createHmac(algo, k).update(v).update(new Buffer([ 0 ])).update(x).update(hbits).digest()
-  v = createHmac(algo, k).update(v).digest()
-  k = createHmac(algo, k).update(v).update(new Buffer([ 1 ])).update(x).update(hbits).digest()
-  v = createHmac(algo, k).update(v).digest()
-  return { k: k, v: v }
-}
-
-function bits2int (obits, q) {
-  var bits = new BN(obits)
-  var shift = (obits.length << 3) - q.bitLength()
-  if (shift > 0) bits.ishrn(shift)
-  return bits
-}
-
-function bits2octets (bits, q) {
-  bits = bits2int(bits, q)
-  bits = bits.mod(q)
-  var out = new Buffer(bits.toArray())
-  if (out.length < q.byteLength()) {
-    var zeros = new Buffer(q.byteLength() - out.length)
-    zeros.fill(0)
-    out = Buffer.concat([ zeros, out ])
-  }
-  return out
-}
-
-function makeKey (q, kv, algo) {
-  var t
-  var k
-
-  do {
-    t = new Buffer(0)
-
-    while (t.length * 8 < q.bitLength()) {
-      kv.v = createHmac(algo, kv.k).update(kv.v).digest()
-      t = Buffer.concat([ t, kv.v ])
-    }
-
-    k = bits2int(t, q)
-    kv.k = createHmac(algo, kv.k).update(kv.v).update(new Buffer([ 0 ])).digest()
-    kv.v = createHmac(algo, kv.k).update(kv.v).digest()
-  } while (k.cmp(q) !== -1)
-
-  return k
-}
-
-function makeR (g, k, p, q) {
-  return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q)
-}
-
-module.exports = sign
-module.exports.getKey = getKey
-module.exports.makeKey = makeKey
-
-}).call(this,require("buffer").Buffer)
-},{"./curves.json":50,"bn.js":24,"browserify-rsa":47,"buffer":55,"create-hmac":61,"elliptic":74,"parse-asn1":118}],53:[function(require,module,exports){
-(function (Buffer){
-// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
-var BN = require('bn.js')
-var EC = require('elliptic').ec
-var parseKeys = require('parse-asn1')
-var curves = require('./curves.json')
-
-function verify (sig, hash, key, signType, tag) {
-  var pub = parseKeys(key)
-  if (pub.type === 'ec') {
-    // rsa keys can be interpreted as ecdsa ones in openssl
-    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type')
-    return ecVerify(sig, hash, pub)
-  } else if (pub.type === 'dsa') {
-    if (signType !== 'dsa') throw new Error('wrong public key type')
-    return dsaVerify(sig, hash, pub)
-  } else {
-    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type')
-  }
-  hash = Buffer.concat([tag, hash])
-  var len = pub.modulus.byteLength()
-  var pad = [ 1 ]
-  var padNum = 0
-  while (hash.length + pad.length + 2 < len) {
-    pad.push(0xff)
-    padNum++
-  }
-  pad.push(0x00)
-  var i = -1
-  while (++i < hash.length) {
-    pad.push(hash[i])
-  }
-  pad = new Buffer(pad)
-  var red = BN.mont(pub.modulus)
-  sig = new BN(sig).toRed(red)
-
-  sig = sig.redPow(new BN(pub.publicExponent))
-  sig = new Buffer(sig.fromRed().toArray())
-  var out = padNum < 8 ? 1 : 0
-  len = Math.min(sig.length, pad.length)
-  if (sig.length !== pad.length) out = 1
-
-  i = -1
-  while (++i < len) out |= sig[i] ^ pad[i]
-  return out === 0
-}
-
-function ecVerify (sig, hash, pub) {
-  var curveId = curves[pub.data.algorithm.curve.join('.')]
-  if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.'))
-
-  var curve = new EC(curveId)
-  var pubkey = pub.data.subjectPrivateKey.data
-
-  return curve.verify(hash, sig, pubkey)
-}
-
-function dsaVerify (sig, hash, pub) {
-  var p = pub.data.p
-  var q = pub.data.q
-  var g = pub.data.g
-  var y = pub.data.pub_key
-  var unpacked = parseKeys.signature.decode(sig, 'der')
-  var s = unpacked.s
-  var r = unpacked.r
-  checkValue(s, q)
-  checkValue(r, q)
-  var montp = BN.mont(p)
-  var w = s.invm(q)
-  var v = g.toRed(montp)
-    .redPow(new BN(hash).mul(w).mod(q))
-    .fromRed()
-    .mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed())
-    .mod(p)
-    .mod(q)
-  return v.cmp(r) === 0
-}
-
-function checkValue (b, q) {
-  if (b.cmpn(0) <= 0) throw new Error('invalid sig')
-  if (b.cmp(q) >= q) throw new Error('invalid sig')
-}
-
-module.exports = verify
-
-}).call(this,require("buffer").Buffer)
-},{"./curves.json":50,"bn.js":24,"buffer":55,"elliptic":74,"parse-asn1":118}],54:[function(require,module,exports){
-(function (Buffer){
-module.exports = function xor (a, b) {
-  var length = Math.min(a.length, b.length)
-  var buffer = new Buffer(length)
-
-  for (var i = 0; i < length; ++i) {
-    buffer[i] = a[i] ^ b[i]
-  }
-
-  return buffer
-}
-
-}).call(this,require("buffer").Buffer)
-},{"buffer":55}],55:[function(require,module,exports){
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
-/* eslint-disable no-proto */
-
-'use strict'
-
-var base64 = require('base64-js')
-var ieee754 = require('ieee754')
-
-exports.Buffer = Buffer
-exports.SlowBuffer = SlowBuffer
-exports.INSPECT_MAX_BYTES = 50
-
-var K_MAX_LENGTH = 0x7fffffff
-exports.kMaxLength = K_MAX_LENGTH
-
-/**
- * If `Buffer.TYPED_ARRAY_SUPPORT`:
- *   === true    Use Uint8Array implementation (fastest)
- *   === false   Print warning and recommend using `buffer` v4.x which has an 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+.
- *
- * We report that the browser does not support typed arrays if the are not subclassable
- * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
- * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
- * for __proto__ and has a buggy typed array implementation.
- */
-Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
-
-if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
-    typeof console.error === 'function') {
-  console.error(
-    'This browser lacks typed array (Uint8Array) support which is required by ' +
-    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
-  )
-}
-
-function typedArraySupport () {
-  // Can typed array instances can be augmented?
-  try {
-    var arr = new Uint8Array(1)
-    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
-    return arr.foo() === 42
-  } catch (e) {
-    return false
-  }
-}
-
-Object.defineProperty(Buffer.prototype, 'parent', {
-  get: function () {
-    if (!(this instanceof Buffer)) {
-      return undefined
-    }
-    return this.buffer
-  }
-})
-
-Object.defineProperty(Buffer.prototype, 'offset', {
-  get: function () {
-    if (!(this instanceof Buffer)) {
-      return undefined
-    }
-    return this.byteOffset
-  }
-})
-
-function createBuffer (length) {
-  if (length > K_MAX_LENGTH) {
-    throw new RangeError('Invalid typed array length')
-  }
-  // Return an augmented `Uint8Array` instance
-  var buf = new Uint8Array(length)
-  buf.__proto__ = Buffer.prototype
-  return buf
-}
-
-/**
- * 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, encodingOrOffset, length) {
-  // Common case.
-  if (typeof arg === 'number') {
-    if (typeof encodingOrOffset === 'string') {
-      throw new Error(
-        'If encoding is specified then the first argument must be a string'
-      )
-    }
-    return allocUnsafe(arg)
-  }
-  return from(arg, encodingOrOffset, length)
-}
-
-// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
-if (typeof Symbol !== 'undefined' && Symbol.species &&
-    Buffer[Symbol.species] === Buffer) {
-  Object.defineProperty(Buffer, Symbol.species, {
-    value: null,
-    configurable: true,
-    enumerable: false,
-    writable: false
-  })
-}
-
-Buffer.poolSize = 8192 // not used by this implementation
-
-function from (value, encodingOrOffset, length) {
-  if (typeof value === 'number') {
-    throw new TypeError('"value" argument must not be a number')
-  }
-
-  if (isArrayBuffer(value) || (value && isArrayBuffer(value.buffer))) {
-    return fromArrayBuffer(value, encodingOrOffset, length)
-  }
-
-  if (typeof value === 'string') {
-    return fromString(value, encodingOrOffset)
-  }
-
-  return fromObject(value)
-}
-
-/**
- * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
- * if value is a number.
- * Buffer.from(str[, encoding])
- * Buffer.from(array)
- * Buffer.from(buffer)
- * Buffer.from(arrayBuffer[, byteOffset[, length]])
- **/
-Buffer.from = function (value, encodingOrOffset, length) {
-  return from(value, encodingOrOffset, length)
-}
-
-// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
-// https://github.com/feross/buffer/pull/148
-Buffer.prototype.__proto__ = Uint8Array.prototype
-Buffer.__proto__ = Uint8Array
-
-function assertSize (size) {
-  if (typeof size !== 'number') {
-    throw new TypeError('"size" argument must be of type number')
-  } else if (size < 0) {
-    throw new RangeError('"size" argument must not be negative')
-  }
-}
-
-function alloc (size, fill, encoding) {
-  assertSize(size)
-  if (size <= 0) {
-    return createBuffer(size)
-  }
-  if (fill !== undefined) {
-    // Only pay attention to encoding if it's a string. This
-    // prevents accidentally sending in a number that would
-    // be interpretted as a start offset.
-    return typeof encoding === 'string'
-      ? createBuffer(size).fill(fill, encoding)
-      : createBuffer(size).fill(fill)
-  }
-  return createBuffer(size)
-}
-
-/**
- * Creates a new filled Buffer instance.
- * alloc(size[, fill[, encoding]])
- **/
-Buffer.alloc = function (size, fill, encoding) {
-  return alloc(size, fill, encoding)
-}
-
-function allocUnsafe (size) {
-  assertSize(size)
-  return createBuffer(size < 0 ? 0 : checked(size) | 0)
-}
-
-/**
- * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
- * */
-Buffer.allocUnsafe = function (size) {
-  return allocUnsafe(size)
-}
-/**
- * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
- */
-Buffer.allocUnsafeSlow = function (size) {
-  return allocUnsafe(size)
-}
-
-function fromString (string, encoding) {
-  if (typeof encoding !== 'string' || encoding === '') {
-    encoding = 'utf8'
-  }
-
-  if (!Buffer.isEncoding(encoding)) {
-    throw new TypeError('Unknown encoding: ' + encoding)
-  }
-
-  var length = byteLength(string, encoding) | 0
-  var buf = createBuffer(length)
-
-  var actual = buf.write(string, encoding)
-
-  if (actual !== length) {
-    // Writing a hex string, for example, that contains invalid characters will
-    // cause everything after the first invalid character to be ignored. (e.g.
-    // 'abxxcd' will be treated as 'ab')
-    buf = buf.slice(0, actual)
-  }
-
-  return buf
-}
-
-function fromArrayLike (array) {
-  var length = array.length < 0 ? 0 : checked(array.length) | 0
-  var buf = createBuffer(length)
-  for (var i = 0; i < length; i += 1) {
-    buf[i] = array[i] & 255
-  }
-  return buf
-}
-
-function fromArrayBuffer (array, byteOffset, length) {
-  if (byteOffset < 0 || array.byteLength < byteOffset) {
-    throw new RangeError('"offset" is outside of buffer bounds')
-  }
-
-  if (array.byteLength < byteOffset + (length || 0)) {
-    throw new RangeError('"length" is outside of buffer bounds')
-  }
-
-  var buf
-  if (byteOffset === undefined && length === undefined) {
-    buf = new Uint8Array(array)
-  } else if (length === undefined) {
-    buf = new Uint8Array(array, byteOffset)
-  } else {
-    buf = new Uint8Array(array, byteOffset, length)
-  }
-
-  // Return an augmented `Uint8Array` instance
-  buf.__proto__ = Buffer.prototype
-  return buf
-}
-
-function fromObject (obj) {
-  if (Buffer.isBuffer(obj)) {
-    var len = checked(obj.length) | 0
-    var buf = createBuffer(len)
-
-    if (buf.length === 0) {
-      return buf
-    }
-
-    obj.copy(buf, 0, 0, len)
-    return buf
-  }
-
-  if (obj) {
-    if (ArrayBuffer.isView(obj) || 'length' in obj) {
-      if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
-        return createBuffer(0)
-      }
-      return fromArrayLike(obj)
-    }
-
-    if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
-      return fromArrayLike(obj.data)
-    }
-  }
-
-  throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object.')
-}
-
-function checked (length) {
-  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
-  // length is NaN (which is otherwise coerced to zero.)
-  if (length >= K_MAX_LENGTH) {
-    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
-                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
-  }
-  return length | 0
-}
-
-function SlowBuffer (length) {
-  if (+length != length) { // eslint-disable-line eqeqeq
-    length = 0
-  }
-  return Buffer.alloc(+length)
-}
-
-Buffer.isBuffer = function isBuffer (b) {
-  return b != null && b._isBuffer === true
-}
-
-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
-
-  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
-    if (a[i] !== b[i]) {
-      x = a[i]
-      y = b[i]
-      break
-    }
-  }
-
-  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 'latin1':
-    case 'binary':
-    case 'base64':
-    case 'ucs2':
-    case 'ucs-2':
-    case 'utf16le':
-    case 'utf-16le':
-      return true
-    default:
-      return false
-  }
-}
-
-Buffer.concat = function concat (list, length) {
-  if (!Array.isArray(list)) {
-    throw new TypeError('"list" argument must be an Array of Buffers')
-  }
-
-  if (list.length === 0) {
-    return Buffer.alloc(0)
-  }
-
-  var i
-  if (length === undefined) {
-    length = 0
-    for (i = 0; i < list.length; ++i) {
-      length += list[i].length
-    }
-  }
-
-  var buffer = Buffer.allocUnsafe(length)
-  var pos = 0
-  for (i = 0; i < list.length; ++i) {
-    var buf = list[i]
-    if (ArrayBuffer.isView(buf)) {
-      buf = Buffer.from(buf)
-    }
-    if (!Buffer.isBuffer(buf)) {
-      throw new TypeError('"list" argument must be an Array of Buffers')
-    }
-    buf.copy(buffer, pos)
-    pos += buf.length
-  }
-  return buffer
-}
-
-function byteLength (string, encoding) {
-  if (Buffer.isBuffer(string)) {
-    return string.length
-  }
-  if (ArrayBuffer.isView(string) || isArrayBuffer(string)) {
-    return string.byteLength
-  }
-  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 'latin1':
-      case 'binary':
-        return len
-      case 'utf8':
-      case 'utf-8':
-      case undefined:
-        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
-
-  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
-  // property of a typed array.
-
-  // This behaves neither like String nor Uint8Array in that we set start/end
-  // to their upper/lower bounds if the value passed is out of range.
-  // undefined is handled specially as per ECMA-262 6th Edition,
-  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
-  if (start === undefined || start < 0) {
-    start = 0
-  }
-  // Return early if start > this.length. Done here to prevent potential uint32
-  // coercion fail below.
-  if (start > this.length) {
-    return ''
-  }
-
-  if (end === undefined || end > this.length) {
-    end = this.length
-  }
-
-  if (end <= 0) {
-    return ''
-  }
-
-  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
-  end >>>= 0
-  start >>>= 0
-
-  if (end <= start) {
-    return ''
-  }
-
-  if (!encoding) encoding = 'utf8'
-
-  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 'latin1':
-      case 'binary':
-        return latin1Slice(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
-    }
-  }
-}
-
-// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
-// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
-// reliably in a browserify context because there could be multiple different
-// copies of the 'buffer' package in use. This method works even for Buffer
-// instances that were created from another copy of the `buffer` package.
-// See: https://github.com/feross/buffer/issues/154
-Buffer.prototype._isBuffer = true
-
-function swap (b, n, m) {
-  var i = b[n]
-  b[n] = b[m]
-  b[m] = i
-}
-
-Buffer.prototype.swap16 = function swap16 () {
-  var len = this.length
-  if (len % 2 !== 0) {
-    throw new RangeError('Buffer size must be a multiple of 16-bits')
-  }
-  for (var i = 0; i < len; i += 2) {
-    swap(this, i, i + 1)
-  }
-  return this
-}
-
-Buffer.prototype.swap32 = function swap32 () {
-  var len = this.length
-  if (len % 4 !== 0) {
-    throw new RangeError('Buffer size must be a multiple of 32-bits')
-  }
-  for (var i = 0; i < len; i += 4) {
-    swap(this, i, i + 3)
-    swap(this, i + 1, i + 2)
-  }
-  return this
-}
-
-Buffer.prototype.swap64 = function swap64 () {
-  var len = this.length
-  if (len % 8 !== 0) {
-    throw new RangeError('Buffer size must be a multiple of 64-bits')
-  }
-  for (var i = 0; i < len; i += 8) {
-    swap(this, i, i + 7)
-    swap(this, i + 1, i + 6)
-    swap(this, i + 2, i + 5)
-    swap(this, i + 3, i + 4)
-  }
-  return this
-}
-
-Buffer.prototype.toString = function toString () {
-  var length = this.length
-  if (length === 0) return ''
-  if (arguments.length === 0) return utf8Slice(this, 0, length)
-  return slowToString.apply(this, arguments)
-}
-
-Buffer.prototype.toLocaleString = Buffer.prototype.toString
-
-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 (target, start, end, thisStart, thisEnd) {
-  if (!Buffer.isBuffer(target)) {
-    throw new TypeError('Argument must be a Buffer')
-  }
-
-  if (start === undefined) {
-    start = 0
-  }
-  if (end === undefined) {
-    end = target ? target.length : 0
-  }
-  if (thisStart === undefined) {
-    thisStart = 0
-  }
-  if (thisEnd === undefined) {
-    thisEnd = this.length
-  }
-
-  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
-    throw new RangeError('out of range index')
-  }
-
-  if (thisStart >= thisEnd && start >= end) {
-    return 0
-  }
-  if (thisStart >= thisEnd) {
-    return -1
-  }
-  if (start >= end) {
-    return 1
-  }
-
-  start >>>= 0
-  end >>>= 0
-  thisStart >>>= 0
-  thisEnd >>>= 0
-
-  if (this === target) return 0
-
-  var x = thisEnd - thisStart
-  var y = end - start
-  var len = Math.min(x, y)
-
-  var thisCopy = this.slice(thisStart, thisEnd)
-  var targetCopy = target.slice(start, end)
-
-  for (var i = 0; i < len; ++i) {
-    if (thisCopy[i] !== targetCopy[i]) {
-      x = thisCopy[i]
-      y = targetCopy[i]
-      break
-    }
-  }
-
-  if (x < y) return -1
-  if (y < x) return 1
-  return 0
-}
-
-// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
-// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
-//
-// Arguments:
-// - buffer - a Buffer to search
-// - val - a string, Buffer, or number
-// - byteOffset - an index into `buffer`; will be clamped to an int32
-// - encoding - an optional encoding, relevant is val is a string
-// - dir - true for indexOf, false for lastIndexOf
-function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
-  // Empty buffer means no match
-  if (buffer.length === 0) return -1
-
-  // Normalize byteOffset
-  if (typeof byteOffset === 'string') {
-    encoding = byteOffset
-    byteOffset = 0
-  } else if (byteOffset > 0x7fffffff) {
-    byteOffset = 0x7fffffff
-  } else if (byteOffset < -0x80000000) {
-    byteOffset = -0x80000000
-  }
-  byteOffset = +byteOffset  // Coerce to Number.
-  if (numberIsNaN(byteOffset)) {
-    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
-    byteOffset = dir ? 0 : (buffer.length - 1)
-  }
-
-  // Normalize byteOffset: negative offsets start from the end of the buffer
-  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
-  if (byteOffset >= buffer.length) {
-    if (dir) return -1
-    else byteOffset = buffer.length - 1
-  } else if (byteOffset < 0) {
-    if (dir) byteOffset = 0
-    else return -1
-  }
-
-  // Normalize val
-  if (typeof val === 'string') {
-    val = Buffer.from(val, encoding)
-  }
-
-  // Finally, search either indexOf (if dir is true) or lastIndexOf
-  if (Buffer.isBuffer(val)) {
-    // Special case: looking for empty string/buffer always fails
-    if (val.length === 0) {
-      return -1
-    }
-    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
-  } else if (typeof val === 'number') {
-    val = val & 0xFF // Search for a byte value [0-255]
-    if (typeof Uint8Array.prototype.indexOf === 'function') {
-      if (dir) {
-        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
-      } else {
-        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
-      }
-    }
-    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
-  }
-
-  throw new TypeError('val must be string, number or Buffer')
-}
-
-function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
-  var indexSize = 1
-  var arrLength = arr.length
-  var valLength = val.length
-
-  if (encoding !== undefined) {
-    encoding = String(encoding).toLowerCase()
-    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
-        encoding === 'utf16le' || encoding === 'utf-16le') {
-      if (arr.length < 2 || val.length < 2) {
-        return -1
-      }
-      indexSize = 2
-      arrLength /= 2
-      valLength /= 2
-      byteOffset /= 2
-    }
-  }
-
-  function read (buf, i) {
-    if (indexSize === 1) {
-      return buf[i]
-    } else {
-      return buf.readUInt16BE(i * indexSize)
-    }
-  }
-
-  var i
-  if (dir) {
-    var foundIndex = -1
-    for (i = byteOffset; i < arrLength; i++) {
-      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
-        if (foundIndex === -1) foundIndex = i
-        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
-      } else {
-        if (foundIndex !== -1) i -= i - foundIndex
-        foundIndex = -1
-      }
-    }
-  } else {
-    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
-    for (i = byteOffset; i >= 0; i--) {
-      var found = true
-      for (var j = 0; j < valLength; j++) {
-        if (read(arr, i + j) !== read(val, j)) {
-          found = false
-          break
-        }
-      }
-      if (found) return i
-    }
-  }
-
-  return -1
-}
-
-Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
-  return this.indexOf(val, byteOffset, encoding) !== -1
-}
-
-Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
-  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
-}
-
-Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
-  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
-}
-
-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
-    }
-  }
-
-  var strLen = string.length
-
-  if (length > strLen / 2) {
-    length = strLen / 2
-  }
-  for (var i = 0; i < length; ++i) {
-    var parsed = parseInt(string.substr(i * 2, 2), 16)
-    if (numberIsNaN(parsed)) return i
-    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 latin1Write (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
-    }
-  } else {
-    throw new Error(
-      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
-    )
-  }
-
-  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 'latin1':
-      case 'binary':
-        return latin1Write(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 latin1Slice (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 = this.subarray(start, end)
-  // Return an augmented `Uint8Array` instance
-  newBuf.__proto__ = Buffer.prototype
-  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) {
-  offset = offset >>> 0
-  if (!noAssert) checkOffset(offset, 1, this.length)
-  return this[offset]
-}
-
-Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
-  offset = offset >>> 0
-  if (!noAssert) checkOffset(offset, 2, this.length)
-  return this[offset] | (this[offset + 1] << 8)
-}
-
-Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
-  offset = offset >>> 0
-  if (!noAssert) checkOffset(offset, 2, this.length)
-  return (this[offset] << 8) | this[offset + 1]
-}
-
-Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
-  offset = offset >>> 0
-  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) {
-  offset = offset >>> 0
-  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) {
-  offset = offset >>> 0
-  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) {
-  offset = offset >>> 0
-  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) {
-  offset = offset >>> 0
-  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) {
-  offset = offset >>> 0
-  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) {
-  offset = offset >>> 0
-  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) {
-  offset = offset >>> 0
-  if (!noAssert) checkOffset(offset, 4, this.length)
-  return ieee754.read(this, offset, true, 23, 4)
-}
-
-Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
-  offset = offset >>> 0
-  if (!noAssert) checkOffset(offset, 4, this.length)
-  return ieee754.read(this, offset, false, 23, 4)
-}
-
-Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
-  offset = offset >>> 0
-  if (!noAssert) checkOffset(offset, 8, this.length)
-  return ieee754.read(this, offset, true, 52, 8)
-}
-
-Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
-  offset = offset >>> 0
-  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" argument must be a Buffer instance')
-  if (value > max || value < min) throw new RangeError('"value" argument 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) {
-    var maxBytes = Math.pow(2, 8 * byteLength) - 1
-    checkInt(this, value, offset, byteLength, maxBytes, 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) {
-    var maxBytes = Math.pow(2, 8 * byteLength) - 1
-    checkInt(this, value, offset, byteLength, maxBytes, 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)
-  this[offset] = (value & 0xff)
-  return offset + 1
-}
-
-Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
-  value = +value
-  offset = offset >>> 0
-  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
-  this[offset] = (value & 0xff)
-  this[offset + 1] = (value >>> 8)
-  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)
-  this[offset] = (value >>> 8)
-  this[offset + 1] = (value & 0xff)
-  return offset + 2
-}
-
-Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
-  value = +value
-  offset = offset >>> 0
-  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
-  this[offset + 3] = (value >>> 24)
-  this[offset + 2] = (value >>> 16)
-  this[offset + 1] = (value >>> 8)
-  this[offset] = (value & 0xff)
-  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)
-  this[offset] = (value >>> 24)
-  this[offset + 1] = (value >>> 16)
-  this[offset + 2] = (value >>> 8)
-  this[offset + 3] = (value & 0xff)
-  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 = 0
-  this[offset] = value & 0xFF
-  while (++i < byteLength && (mul *= 0x100)) {
-    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
-      sub = 1
-    }
-    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 = 0
-  this[offset + i] = value & 0xFF
-  while (--i >= 0 && (mul *= 0x100)) {
-    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
-      sub = 1
-    }
-    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 (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)
-  this[offset] = (value & 0xff)
-  this[offset + 1] = (value >>> 8)
-  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)
-  this[offset] = (value >>> 8)
-  this[offset + 1] = (value & 0xff)
-  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)
-  this[offset] = (value & 0xff)
-  this[offset + 1] = (value >>> 8)
-  this[offset + 2] = (value >>> 16)
-  this[offset + 3] = (value >>> 24)
-  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
-  this[offset] = (value >>> 24)
-  this[offset + 1] = (value >>> 16)
-  this[offset + 2] = (value >>> 8)
-  this[offset + 3] = (value & 0xff)
-  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) {
-  value = +value
-  offset = offset >>> 0
-  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) {
-  value = +value
-  offset = offset >>> 0
-  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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
-  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('Index out of range')
-  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
-
-  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
-    // Use built-in when available, missing from IE11
-    this.copyWithin(targetStart, start, end)
-  } else if (this === target && start < targetStart && targetStart < end) {
-    // descending copy from end
-    for (var i = len - 1; i >= 0; --i) {
-      target[i + targetStart] = this[i + start]
-    }
-  } else {
-    Uint8Array.prototype.set.call(
-      target,
-      this.subarray(start, end),
-      targetStart
-    )
-  }
-
-  return len
-}
-
-// Usage:
-//    buffer.fill(number[, offset[, end]])
-//    buffer.fill(buffer[, offset[, end]])
-//    buffer.fill(string[, offset[, end]][, encoding])
-Buffer.prototype.fill = function fill (val, start, end, encoding) {
-  // Handle string cases:
-  if (typeof val === 'string') {
-    if (typeof start === 'string') {
-      encoding = start
-      start = 0
-      end = this.length
-    } else if (typeof end === 'string') {
-      encoding = end
-      end = this.length
-    }
-    if (encoding !== undefined && typeof encoding !== 'string') {
-      throw new TypeError('encoding must be a string')
-    }
-    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
-      throw new TypeError('Unknown encoding: ' + encoding)
-    }
-    if (val.length === 1) {
-      var code = val.charCodeAt(0)
-      if ((encoding === 'utf8' && code < 128) ||
-          encoding === 'latin1') {
-        // Fast path: If `val` fits into a single byte, use that numeric value.
-        val = code
-      }
-    }
-  } else if (typeof val === 'number') {
-    val = val & 255
-  }
-
-  // Invalid ranges are not set to a default, so can range check early.
-  if (start < 0 || this.length < start || this.length < end) {
-    throw new RangeError('Out of range index')
-  }
-
-  if (end <= start) {
-    return this
-  }
-
-  start = start >>> 0
-  end = end === undefined ? this.length : end >>> 0
-
-  if (!val) val = 0
-
-  var i
-  if (typeof val === 'number') {
-    for (i = start; i < end; ++i) {
-      this[i] = val
-    }
-  } else {
-    var bytes = Buffer.isBuffer(val)
-      ? val
-      : new Buffer(val, encoding)
-    var len = bytes.length
-    if (len === 0) {
-      throw new TypeError('The value "' + val +
-        '" is invalid for argument "value"')
-    }
-    for (i = 0; i < end - start; ++i) {
-      this[i + start] = bytes[i % len]
-    }
-  }
-
-  return this
-}
-
-// HELPER FUNCTIONS
-// ================
-
-var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
-
-function base64clean (str) {
-  // Node takes equal signs as end of the Base64 encoding
-  str = str.split('=')[0]
-  // Node strips out invalid characters like \n and \t from the string, base64-js does not
-  str = str.trim().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 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
-}
-
-// ArrayBuffers from another context (i.e. an iframe) do not pass the `instanceof` check
-// but they should be treated as valid. See: https://github.com/feross/buffer/issues/166
-function isArrayBuffer (obj) {
-  return obj instanceof ArrayBuffer ||
-    (obj != null && obj.constructor != null && obj.constructor.name === 'ArrayBuffer' &&
-      typeof obj.byteLength === 'number')
-}
-
-function numberIsNaN (obj) {
-  return obj !== obj // eslint-disable-line no-self-compare
-}
-
-},{"base64-js":23,"ieee754":106}],56:[function(require,module,exports){
-var Buffer = require('safe-buffer').Buffer
-var Transform = require('stream').Transform
-var StringDecoder = require('string_decoder').StringDecoder
-var inherits = require('inherits')
-
-function CipherBase (hashMode) {
-  Transform.call(this)
-  this.hashMode = typeof hashMode === 'string'
-  if (this.hashMode) {
-    this[hashMode] = this._finalOrDigest
-  } else {
-    this.final = this._finalOrDigest
-  }
-  if (this._final) {
-    this.__final = this._final
-    this._final = null
-  }
-  this._decoder = null
-  this._encoding = null
-}
-inherits(CipherBase, Transform)
-
-CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
-  if (typeof data === 'string') {
-    data = Buffer.from(data, inputEnc)
-  }
-
-  var outData = this._update(data)
-  if (this.hashMode) return this
-
-  if (outputEnc) {
-    outData = this._toString(outData, outputEnc)
-  }
-
-  return outData
-}
-
-CipherBase.prototype.setAutoPadding = function () {}
-CipherBase.prototype.getAuthTag = function () {
-  throw new Error('trying to get auth tag in unsupported state')
-}
-
-CipherBase.prototype.setAuthTag = function () {
-  throw new Error('trying to set auth tag in unsupported state')
-}
-
-CipherBase.prototype.setAAD = function () {
-  throw new Error('trying to set aad in unsupported state')
-}
-
-CipherBase.prototype._transform = function (data, _, next) {
-  var err
-  try {
-    if (this.hashMode) {
-      this._update(data)
-    } else {
-      this.push(this._update(data))
-    }
-  } catch (e) {
-    err = e
-  } finally {
-    next(err)
-  }
-}
-CipherBase.prototype._flush = function (done) {
-  var err
-  try {
-    this.push(this.__final())
-  } catch (e) {
-    err = e
-  }
-
-  done(err)
-}
-CipherBase.prototype._finalOrDigest = function (outputEnc) {
-  var outData = this.__final() || Buffer.alloc(0)
-  if (outputEnc) {
-    outData = this._toString(outData, outputEnc, true)
-  }
-  return outData
-}
-
-CipherBase.prototype._toString = function (value, enc, fin) {
-  if (!this._decoder) {
-    this._decoder = new StringDecoder(enc)
-    this._encoding = enc
-  }
-
-  if (this._encoding !== enc) throw new Error('can\'t switch encodings')
-
-  var out = this._decoder.write(value)
-  if (fin) {
-    out += this._decoder.end()
-  }
-
-  return out
-}
-
-module.exports = CipherBase
-
-},{"inherits":107,"safe-buffer":148,"stream":157,"string_decoder":158}],57:[function(require,module,exports){
-(function (Buffer){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// NOTE: These type checking functions intentionally don't use `instanceof`
-// because it is fragile and can be easily faked with `Object.create()`.
-
-function isArray(arg) {
-  if (Array.isArray) {
-    return Array.isArray(arg);
-  }
-  return objectToString(arg) === '[object Array]';
-}
-exports.isArray = isArray;
-
-function isBoolean(arg) {
-  return typeof arg === 'boolean';
-}
-exports.isBoolean = isBoolean;
-
-function isNull(arg) {
-  return arg === null;
-}
-exports.isNull = isNull;
-
-function isNullOrUndefined(arg) {
-  return arg == null;
-}
-exports.isNullOrUndefined = isNullOrUndefined;
-
-function isNumber(arg) {
-  return typeof arg === 'number';
-}
-exports.isNumber = isNumber;
-
-function isString(arg) {
-  return typeof arg === 'string';
-}
-exports.isString = isString;
-
-function isSymbol(arg) {
-  return typeof arg === 'symbol';
-}
-exports.isSymbol = isSymbol;
-
-function isUndefined(arg) {
-  return arg === void 0;
-}
-exports.isUndefined = isUndefined;
-
-function isRegExp(re) {
-  return objectToString(re) === '[object RegExp]';
-}
-exports.isRegExp = isRegExp;
-
-function isObject(arg) {
-  return typeof arg === 'object' && arg !== null;
-}
-exports.isObject = isObject;
-
-function isDate(d) {
-  return objectToString(d) === '[object Date]';
-}
-exports.isDate = isDate;
-
-function isError(e) {
-  return (objectToString(e) === '[object Error]' || e instanceof Error);
-}
-exports.isError = isError;
-
-function isFunction(arg) {
-  return typeof arg === 'function';
-}
-exports.isFunction = isFunction;
-
-function isPrimitive(arg) {
-  return arg === null ||
-         typeof arg === 'boolean' ||
-         typeof arg === 'number' ||
-         typeof arg === 'string' ||
-         typeof arg === 'symbol' ||  // ES6 symbol
-         typeof arg === 'undefined';
-}
-exports.isPrimitive = isPrimitive;
-
-exports.isBuffer = Buffer.isBuffer;
-
-function objectToString(o) {
-  return Object.prototype.toString.call(o);
-}
-
-}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
-},{"../../is-buffer/index.js":108}],58:[function(require,module,exports){
-(function (Buffer){
-var elliptic = require('elliptic')
-var BN = require('bn.js')
-
-module.exports = function createECDH (curve) {
-  return new ECDH(curve)
-}
-
-var aliases = {
-  secp256k1: {
-    name: 'secp256k1',
-    byteLength: 32
-  },
-  secp224r1: {
-    name: 'p224',
-    byteLength: 28
-  },
-  prime256v1: {
-    name: 'p256',
-    byteLength: 32
-  },
-  prime192v1: {
-    name: 'p192',
-    byteLength: 24
-  },
-  ed25519: {
-    name: 'ed25519',
-    byteLength: 32
-  },
-  secp384r1: {
-    name: 'p384',
-    byteLength: 48
-  },
-  secp521r1: {
-    name: 'p521',
-    byteLength: 66
-  }
-}
-
-aliases.p224 = aliases.secp224r1
-aliases.p256 = aliases.secp256r1 = aliases.prime256v1
-aliases.p192 = aliases.secp192r1 = aliases.prime192v1
-aliases.p384 = aliases.secp384r1
-aliases.p521 = aliases.secp521r1
-
-function ECDH (curve) {
-  this.curveType = aliases[curve]
-  if (!this.curveType) {
-    this.curveType = {
-      name: curve
-    }
-  }
-  this.curve = new elliptic.ec(this.curveType.name) // eslint-disable-line new-cap
-  this.keys = void 0
-}
-
-ECDH.prototype.generateKeys = function (enc, format) {
-  this.keys = this.curve.genKeyPair()
-  return this.getPublicKey(enc, format)
-}
-
-ECDH.prototype.computeSecret = function (other, inenc, enc) {
-  inenc = inenc || 'utf8'
-  if (!Buffer.isBuffer(other)) {
-    other = new Buffer(other, inenc)
-  }
-  var otherPub = this.curve.keyFromPublic(other).getPublic()
-  var out = otherPub.mul(this.keys.getPrivate()).getX()
-  return formatReturnValue(out, enc, this.curveType.byteLength)
-}
-
-ECDH.prototype.getPublicKey = function (enc, format) {
-  var key = this.keys.getPublic(format === 'compressed', true)
-  if (format === 'hybrid') {
-    if (key[key.length - 1] % 2) {
-      key[0] = 7
-    } else {
-      key[0] = 6
-    }
-  }
-  return formatReturnValue(key, enc)
-}
-
-ECDH.prototype.getPrivateKey = function (enc) {
-  return formatReturnValue(this.keys.getPrivate(), enc)
-}
-
-ECDH.prototype.setPublicKey = function (pub, enc) {
-  enc = enc || 'utf8'
-  if (!Buffer.isBuffer(pub)) {
-    pub = new Buffer(pub, enc)
-  }
-  this.keys._importPublic(pub)
-  return this
-}
-
-ECDH.prototype.setPrivateKey = function (priv, enc) {
-  enc = enc || 'utf8'
-  if (!Buffer.isBuffer(priv)) {
-    priv = new Buffer(priv, enc)
-  }
-
-  var _priv = new BN(priv)
-  _priv = _priv.toString(16)
-  this.keys = this.curve.genKeyPair()
-  this.keys._importPrivate(_priv)
-  return this
-}
-
-function formatReturnValue (bn, enc, len) {
-  if (!Array.isArray(bn)) {
-    bn = bn.toArray()
-  }
-  var buf = new Buffer(bn)
-  if (len && buf.length < len) {
-    var zeros = new Buffer(len - buf.length)
-    zeros.fill(0)
-    buf = Buffer.concat([zeros, buf])
-  }
-  if (!enc) {
-    return buf
-  } else {
-    return buf.toString(enc)
-  }
-}
-
-}).call(this,require("buffer").Buffer)
-},{"bn.js":24,"buffer":55,"elliptic":74}],59:[function(require,module,exports){
-'use strict'
-var inherits = require('inherits')
-var MD5 = require('md5.js')
-var RIPEMD160 = require('ripemd160')
-var sha = require('sha.js')
-var Base = require('cipher-base')
-
-function Hash (hash) {
-  Base.call(this, 'digest')
-
-  this._hash = hash
-}
-
-inherits(Hash, Base)
-
-Hash.prototype._update = function (data) {
-  this._hash.update(data)
-}
-
-Hash.prototype._final = function () {
-  return this._hash.digest()
-}
-
-module.exports = function createHash (alg) {
-  alg = alg.toLowerCase()
-  if (alg === 'md5') return new MD5()
-  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()
-
-  return new Hash(sha(alg))
-}
-
-},{"cipher-base":56,"inherits":107,"md5.js":110,"ripemd160":147,"sha.js":150}],60:[function(require,module,exports){
-var MD5 = require('md5.js')
-
-module.exports = function (buffer) {
-  return new MD5().update(buffer).digest()
-}
-
-},{"md5.js":110}],61:[function(require,module,exports){
-'use strict'
-var inherits = require('inherits')
-var Legacy = require('./legacy')
-var Base = require('cipher-base')
-var Buffer = require('safe-buffer').Buffer
-var md5 = require('create-hash/md5')
-var RIPEMD160 = require('ripemd160')
-
-var sha = require('sha.js')
-
-var ZEROS = Buffer.alloc(128)
-
-function Hmac (alg, key) {
-  Base.call(this, 'digest')
-  if (typeof key === 'string') {
-    key = Buffer.from(key)
-  }
-
-  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64
-
-  this._alg = alg
-  this._key = key
-  if (key.length > blocksize) {
-    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
-    key = hash.update(key).digest()
-  } else if (key.length < blocksize) {
-    key = Buffer.concat([key, ZEROS], blocksize)
-  }
-
-  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)
-  var opad = this._opad = Buffer.allocUnsafe(blocksize)
-
-  for (var i = 0; i < blocksize; i++) {
-    ipad[i] = key[i] ^ 0x36
-    opad[i] = key[i] ^ 0x5C
-  }
-  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
-  this._hash.update(ipad)
-}
-
-inherits(Hmac, Base)
-
-Hmac.prototype._update = function (data) {
-  this._hash.update(data)
-}
-
-Hmac.prototype._final = function () {
-  var h = this._hash.digest()
-  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)
-  return hash.update(this._opad).update(h).digest()
-}
-
-module.exports = function createHmac (alg, key) {
-  alg = alg.toLowerCase()
-  if (alg === 'rmd160' || alg === 'ripemd160') {
-    return new Hmac('rmd160', key)
-  }
-  if (alg === 'md5') {
-    return new Legacy(md5, key)
-  }
-  return new Hmac(alg, key)
-}
-
-},{"./legacy":62,"cipher-base":56,"create-hash/md5":60,"inherits":107,"ripemd160":147,"safe-buffer":148,"sha.js":150}],62:[function(require,module,exports){
-'use strict'
-var inherits = require('inherits')
-var Buffer = require('safe-buffer').Buffer
-
-var Base = require('cipher-base')
-
-var ZEROS = Buffer.alloc(128)
-var blocksize = 64
-
-function Hmac (alg, key) {
-  Base.call(this, 'digest')
-  if (typeof key === 'string') {
-    key = Buffer.from(key)
-  }
-
-  this._alg = alg
-  this._key = key
-
-  if (key.length > blocksize) {
-    key = alg(key)
-  } else if (key.length < blocksize) {
-    key = Buffer.concat([key, ZEROS], blocksize)
-  }
-
-  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)
-  var opad = this._opad = Buffer.allocUnsafe(blocksize)
-
-  for (var i = 0; i < blocksize; i++) {
-    ipad[i] = key[i] ^ 0x36
-    opad[i] = key[i] ^ 0x5C
-  }
-
-  this._hash = [ipad]
-}
-
-inherits(Hmac, Base)
-
-Hmac.prototype._update = function (data) {
-  this._hash.push(data)
-}
-
-Hmac.prototype._final = function () {
-  var h = this._alg(Buffer.concat(this._hash))
-  return this._alg(Buffer.concat([this._opad, h]))
-}
-module.exports = Hmac
-
-},{"cipher-base":56,"inherits":107,"safe-buffer":148}],63:[function(require,module,exports){
-'use strict'
-
-exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes')
-exports.createHash = exports.Hash = require('create-hash')
-exports.createHmac = exports.Hmac = require('create-hmac')
-
-var algos = require('browserify-sign/algos')
-var algoKeys = Object.keys(algos)
-var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys)
-exports.getHashes = function () {
-  return hashes
-}
-
-var p = require('pbkdf2')
-exports.pbkdf2 = p.pbkdf2
-exports.pbkdf2Sync = p.pbkdf2Sync
-
-var aes = require('browserify-cipher')
-
-exports.Cipher = aes.Cipher
-exports.createCipher = aes.createCipher
-exports.Cipheriv = aes.Cipheriv
-exports.createCipheriv = aes.createCipheriv
-exports.Decipher = aes.Decipher
-exports.createDecipher = aes.createDecipher
-exports.Decipheriv = aes.Decipheriv
-exports.createDecipheriv = aes.createDecipheriv
-exports.getCiphers = aes.getCiphers
-exports.listCiphers = aes.listCiphers
-
-var dh = require('diffie-hellman')
-
-exports.DiffieHellmanGroup = dh.DiffieHellmanGroup
-exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup
-exports.getDiffieHellman = dh.getDiffieHellman
-exports.createDiffieHellman = dh.createDiffieHellman
-exports.DiffieHellman = dh.DiffieHellman
-
-var sign = require('browserify-sign')
-
-exports.createSign = sign.createSign
-exports.Sign = sign.Sign
-exports.createVerify = sign.createVerify
-exports.Verify = sign.Verify
-
-exports.createECDH = require('create-ecdh')
-
-var publicEncrypt = require('public-encrypt')
-
-exports.publicEncrypt = publicEncrypt.publicEncrypt
-exports.privateEncrypt = publicEncrypt.privateEncrypt
-exports.publicDecrypt = publicEncrypt.publicDecrypt
-exports.privateDecrypt = publicEncrypt.privateDecrypt
-
-// the least I can do is make error messages for the rest of the node.js/crypto api.
-// ;[
-//   'createCredentials'
-// ].forEach(function (name) {
-//   exports[name] = function () {
-//     throw new Error([
-//       'sorry, ' + name + ' is not implemented yet',
-//       'we accept pull requests',
-//       'https://github.com/crypto-browserify/crypto-browserify'
-//     ].join('\n'))
-//   }
-// })
-
-var rf = require('randomfill')
-
-exports.randomFill = rf.randomFill
-exports.randomFillSync = rf.randomFillSync
-
-exports.createCredentials = function () {
-  throw new Error([
-    'sorry, createCredentials is not implemented yet',
-    'we accept pull requests',
-    'https://github.com/crypto-browserify/crypto-browserify'
-  ].join('\n'))
-}
-
-exports.constants = {
-  'DH_CHECK_P_NOT_SAFE_PRIME': 2,
-  'DH_CHECK_P_NOT_PRIME': 1,
-  'DH_UNABLE_TO_CHECK_GENERATOR': 4,
-  'DH_NOT_SUITABLE_GENERATOR': 8,
-  'NPN_ENABLED': 1,
-  'ALPN_ENABLED': 1,
-  'RSA_PKCS1_PADDING': 1,
-  'RSA_SSLV23_PADDING': 2,
-  'RSA_NO_PADDING': 3,
-  'RSA_PKCS1_OAEP_PADDING': 4,
-  'RSA_X931_PADDING': 5,
-  'RSA_PKCS1_PSS_PADDING': 6,
-  'POINT_CONVERSION_COMPRESSED': 2,
-  'POINT_CONVERSION_UNCOMPRESSED': 4,
-  'POINT_CONVERSION_HYBRID': 6
-}
-
-},{"browserify-cipher":44,"browserify-sign":51,"browserify-sign/algos":48,"create-ecdh":58,"create-hash":59,"create-hmac":61,"diffie-hellman":70,"pbkdf2":119,"public-encrypt":126,"randombytes":132,"randomfill":133}],64:[function(require,module,exports){
-'use strict';
-
-exports.utils = require('./des/utils');
-exports.Cipher = require('./des/cipher');
-exports.DES = require('./des/des');
-exports.CBC = require('./des/cbc');
-exports.EDE = require('./des/ede');
-
-},{"./des/cbc":65,"./des/cipher":66,"./des/des":67,"./des/ede":68,"./des/utils":69}],65:[function(require,module,exports){
-'use strict';
-
-var assert = require('minimalistic-assert');
-var inherits = require('inherits');
-
-var proto = {};
-
-function CBCState(iv) {
-  assert.equal(iv.length, 8, 'Invalid IV length');
-
-  this.iv = new Array(8);
-  for (var i = 0; i < this.iv.length; i++)
-    this.iv[i] = iv[i];
-}
-
-function instantiate(Base) {
-  function CBC(options) {
-    Base.call(this, options);
-    this._cbcInit();
-  }
-  inherits(CBC, Base);
-
-  var keys = Object.keys(proto);
-  for (var i = 0; i < keys.length; i++) {
-    var key = keys[i];
-    CBC.prototype[key] = proto[key];
-  }
-
-  CBC.create = function create(options) {
-    return new CBC(options);
-  };
-
-  return CBC;
-}
-
-exports.instantiate = instantiate;
-
-proto._cbcInit = function _cbcInit() {
-  var state = new CBCState(this.options.iv);
-  this._cbcState = state;
-};
-
-proto._update = function _update(inp, inOff, out, outOff) {
-  var state = this._cbcState;
-  var superProto = this.constructor.super_.prototype;
-
-  var iv = state.iv;
-  if (this.type === 'encrypt') {
-    for (var i = 0; i < this.blockSize; i++)
-      iv[i] ^= inp[inOff + i];
-
-    superProto._update.call(this, iv, 0, out, outOff);
-
-    for (var i = 0; i < this.blockSize; i++)
-      iv[i] = out[outOff + i];
-  } else {
-    superProto._update.call(this, inp, inOff, out, outOff);
-
-    for (var i = 0; i < this.blockSize; i++)
-      out[outOff + i] ^= iv[i];
-
-    for (var i = 0; i < this.blockSize; i++)
-      iv[i] = inp[inOff + i];
-  }
-};
-
-},{"inherits":107,"minimalistic-assert":112}],66:[function(require,module,exports){
-'use strict';
-
-var assert = require('minimalistic-assert');
-
-function Cipher(options) {
-  this.options = options;
-
-  this.type = this.options.type;
-  this.blockSize = 8;
-  this._init();
-
-  this.buffer = new Array(this.blockSize);
-  this.bufferOff = 0;
-}
-module.exports = Cipher;
-
-Cipher.prototype._init = function _init() {
-  // Might be overrided
-};
-
-Cipher.prototype.update = function update(data) {
-  if (data.length === 0)
-    return [];
-
-  if (this.type === 'decrypt')
-    return this._updateDecrypt(data);
-  else
-    return this._updateEncrypt(data);
-};
-
-Cipher.prototype._buffer = function _buffer(data, off) {
-  // Append data to buffer
-  var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);
-  for (var i = 0; i < min; i++)
-    this.buffer[this.bufferOff + i] = data[off + i];
-  this.bufferOff += min;
-
-  // Shift next
-  return min;
-};
-
-Cipher.prototype._flushBuffer = function _flushBuffer(out, off) {
-  this._update(this.buffer, 0, out, off);
-  this.bufferOff = 0;
-  return this.blockSize;
-};
-
-Cipher.prototype._updateEncrypt = function _updateEncrypt(data) {
-  var inputOff = 0;
-  var outputOff = 0;
-
-  var count = ((this.bufferOff + data.length) / this.blockSize) | 0;
-  var out = new Array(count * this.blockSize);
-
-  if (this.bufferOff !== 0) {
-    inputOff += this._buffer(data, inputOff);
-
-    if (this.bufferOff === this.buffer.length)
-      outputOff += this._flushBuffer(out, outputOff);
-  }
-
-  // Write blocks
-  var max = data.length - ((data.length - inputOff) % this.blockSize);
-  for (; inputOff < max; inputOff += this.blockSize) {
-    this._update(data, inputOff, out, outputOff);
-    outputOff += this.blockSize;
-  }
-
-  // Queue rest
-  for (; inputOff < data.length; inputOff++, this.bufferOff++)
-    this.buffer[this.bufferOff] = data[inputOff];
-
-  return out;
-};
-
-Cipher.prototype._updateDecrypt = function _updateDecrypt(data) {
-  var inputOff = 0;
-  var outputOff = 0;
-
-  var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1;
-  var out = new Array(count * this.blockSize);
-
-  // TODO(indutny): optimize it, this is far from optimal
-  for (; count > 0; count--) {
-    inputOff += this._buffer(data, inputOff);
-    outputOff += this._flushBuffer(out, outputOff);
-  }
-
-  // Buffer rest of the input
-  inputOff += this._buffer(data, inputOff);
-
-  return out;
-};
-
-Cipher.prototype.final = function final(buffer) {
-  var first;
-  if (buffer)
-    first = this.update(buffer);
-
-  var last;
-  if (this.type === 'encrypt')
-    last = this._finalEncrypt();
-  else
-    last = this._finalDecrypt();
-
-  if (first)
-    return first.concat(last);
-  else
-    return last;
-};
-
-Cipher.prototype._pad = function _pad(buffer, off) {
-  if (off === 0)
-    return false;
-
-  while (off < buffer.length)
-    buffer[off++] = 0;
-
-  return true;
-};
-
-Cipher.prototype._finalEncrypt = function _finalEncrypt() {
-  if (!this._pad(this.buffer, this.bufferOff))
-    return [];
-
-  var out = new Array(this.blockSize);
-  this._update(this.buffer, 0, out, 0);
-  return out;
-};
-
-Cipher.prototype._unpad = function _unpad(buffer) {
-  return buffer;
-};
-
-Cipher.prototype._finalDecrypt = function _finalDecrypt() {
-  assert.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt');
-  var out = new Array(this.blockSize);
-  this._flushBuffer(out, 0);
-
-  return this._unpad(out);
-};
-
-},{"minimalistic-assert":112}],67:[function(require,module,exports){
-'use strict';
-
-var assert = require('minimalistic-assert');
-var inherits = require('inherits');
-
-var des = require('../des');
-var utils = des.utils;
-var Cipher = des.Cipher;
-
-function DESState() {
-  this.tmp = new Array(2);
-  this.keys = null;
-}
-
-function DES(options) {
-  Cipher.call(this, options);
-
-  var state = new DESState();
-  this._desState = state;
-
-  this.deriveKeys(state, options.key);
-}
-inherits(DES, Cipher);
-module.exports = DES;
-
-DES.create = function create(options) {
-  return new DES(options);
-};
-
-var shiftTable = [
-  1, 1, 2, 2, 2, 2, 2, 2,
-  1, 2, 2, 2, 2, 2, 2, 1
-];
-
-DES.prototype.deriveKeys = function deriveKeys(state, key) {
-  state.keys = new Array(16 * 2);
-
-  assert.equal(key.length, this.blockSize, 'Invalid key length');
-
-  var kL = utils.readUInt32BE(key, 0);
-  var kR = utils.readUInt32BE(key, 4);
-
-  utils.pc1(kL, kR, state.tmp, 0);
-  kL = state.tmp[0];
-  kR = state.tmp[1];
-  for (var i = 0; i < state.keys.length; i += 2) {
-    var shift = shiftTable[i >>> 1];
-    kL = utils.r28shl(kL, shift);
-    kR = utils.r28shl(kR, shift);
-    utils.pc2(kL, kR, state.keys, i);
-  }
-};
-
-DES.prototype._update = function _update(inp, inOff, out, outOff) {
-  var state = this._desState;
-
-  var l = utils.readUInt32BE(inp, inOff);
-  var r = utils.readUInt32BE(inp, inOff + 4);
-
-  // Initial Permutation
-  utils.ip(l, r, state.tmp, 0);
-  l = state.tmp[0];
-  r = state.tmp[1];
-
-  if (this.type === 'encrypt')
-    this._encrypt(state, l, r, state.tmp, 0);
-  else
-    this._decrypt(state, l, r, state.tmp, 0);
-
-  l = state.tmp[0];
-  r = state.tmp[1];
-
-  utils.writeUInt32BE(out, l, outOff);
-  utils.writeUInt32BE(out, r, outOff + 4);
-};
-
-DES.prototype._pad = function _pad(buffer, off) {
-  var value = buffer.length - off;
-  for (var i = off; i < buffer.length; i++)
-    buffer[i] = value;
-
-  return true;
-};
-
-DES.prototype._unpad = function _unpad(buffer) {
-  var pad = buffer[buffer.length - 1];
-  for (var i = buffer.length - pad; i < buffer.length; i++)
-    assert.equal(buffer[i], pad);
-
-  return buffer.slice(0, buffer.length - pad);
-};
-
-DES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) {
-  var l = lStart;
-  var r = rStart;
-
-  // Apply f() x16 times
-  for (var i = 0; i < state.keys.length; i += 2) {
-    var keyL = state.keys[i];
-    var keyR = state.keys[i + 1];
-
-    // f(r, k)
-    utils.expand(r, state.tmp, 0);
-
-    keyL ^= state.tmp[0];
-    keyR ^= state.tmp[1];
-    var s = utils.substitute(keyL, keyR);
-    var f = utils.permute(s);
-
-    var t = r;
-    r = (l ^ f) >>> 0;
-    l = t;
-  }
-
-  // Reverse Initial Permutation
-  utils.rip(r, l, out, off);
-};
-
-DES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) {
-  var l = rStart;
-  var r = lStart;
-
-  // Apply f() x16 times
-  for (var i = state.keys.length - 2; i >= 0; i -= 2) {
-    var keyL = state.keys[i];
-    var keyR = state.keys[i + 1];
-
-    // f(r, k)
-    utils.expand(l, state.tmp, 0);
-
-    keyL ^= state.tmp[0];
-    keyR ^= state.tmp[1];
-    var s = utils.substitute(keyL, keyR);
-    var f = utils.permute(s);
-
-    var t = l;
-    l = (r ^ f) >>> 0;
-    r = t;
-  }
-
-  // Reverse Initial Permutation
-  utils.rip(l, r, out, off);
-};
-
-},{"../des":64,"inherits":107,"minimalistic-assert":112}],68:[function(require,module,exports){
-'use strict';
-
-var assert = require('minimalistic-assert');
-var inherits = require('inherits');
-
-var des = require('../des');
-var Cipher = des.Cipher;
-var DES = des.DES;
-
-function EDEState(type, key) {
-  assert.equal(key.length, 24, 'Invalid key length');
-
-  var k1 = key.slice(0, 8);
-  var k2 = key.slice(8, 16);
-  var k3 = key.slice(16, 24);
-
-  if (type === 'encrypt') {
-    this.ciphers = [
-      DES.create({ type: 'encrypt', key: k1 }),
-      DES.create({ type: 'decrypt', key: k2 }),
-      DES.create({ type: 'encrypt', key: k3 })
-    ];
-  } else {
-    this.ciphers = [
-      DES.create({ type: 'decrypt', key: k3 }),
-      DES.create({ type: 'encrypt', key: k2 }),
-      DES.create({ type: 'decrypt', key: k1 })
-    ];
-  }
-}
-
-function EDE(options) {
-  Cipher.call(this, options);
-
-  var state = new EDEState(this.type, this.options.key);
-  this._edeState = state;
-}
-inherits(EDE, Cipher);
-
-module.exports = EDE;
-
-EDE.create = function create(options) {
-  return new EDE(options);
-};
-
-EDE.prototype._update = function _update(inp, inOff, out, outOff) {
-  var state = this._edeState;
-
-  state.ciphers[0]._update(inp, inOff, out, outOff);
-  state.ciphers[1]._update(out, outOff, out, outOff);
-  state.ciphers[2]._update(out, outOff, out, outOff);
-};
-
-EDE.prototype._pad = DES.prototype._pad;
-EDE.prototype._unpad = DES.prototype._unpad;
-
-},{"../des":64,"inherits":107,"minimalistic-assert":112}],69:[function(require,module,exports){
-'use strict';
-
-exports.readUInt32BE = function readUInt32BE(bytes, off) {
-  var res =  (bytes[0 + off] << 24) |
-             (bytes[1 + off] << 16) |
-             (bytes[2 + off] << 8) |
-             bytes[3 + off];
-  return res >>> 0;
-};
-
-exports.writeUInt32BE = function writeUInt32BE(bytes, value, off) {
-  bytes[0 + off] = value >>> 24;
-  bytes[1 + off] = (value >>> 16) & 0xff;
-  bytes[2 + off] = (value >>> 8) & 0xff;
-  bytes[3 + off] = value & 0xff;
-};
-
-exports.ip = function ip(inL, inR, out, off) {
-  var outL = 0;
-  var outR = 0;
-
-  for (var i = 6; i >= 0; i -= 2) {
-    for (var j = 0; j <= 24; j += 8) {
-      outL <<= 1;
-      outL |= (inR >>> (j + i)) & 1;
-    }
-    for (var j = 0; j <= 24; j += 8) {
-      outL <<= 1;
-      outL |= (inL >>> (j + i)) & 1;
-    }
-  }
-
-  for (var i = 6; i >= 0; i -= 2) {
-    for (var j = 1; j <= 25; j += 8) {
-      outR <<= 1;
-      outR |= (inR >>> (j + i)) & 1;
-    }
-    for (var j = 1; j <= 25; j += 8) {
-      outR <<= 1;
-      outR |= (inL >>> (j + i)) & 1;
-    }
-  }
-
-  out[off + 0] = outL >>> 0;
-  out[off + 1] = outR >>> 0;
-};
-
-exports.rip = function rip(inL, inR, out, off) {
-  var outL = 0;
-  var outR = 0;
-
-  for (var i = 0; i < 4; i++) {
-    for (var j = 24; j >= 0; j -= 8) {
-      outL <<= 1;
-      outL |= (inR >>> (j + i)) & 1;
-      outL <<= 1;
-      outL |= (inL >>> (j + i)) & 1;
-    }
-  }
-  for (var i = 4; i < 8; i++) {
-    for (var j = 24; j >= 0; j -= 8) {
-      outR <<= 1;
-      outR |= (inR >>> (j + i)) & 1;
-      outR <<= 1;
-      outR |= (inL >>> (j + i)) & 1;
-    }
-  }
-
-  out[off + 0] = outL >>> 0;
-  out[off + 1] = outR >>> 0;
-};
-
-exports.pc1 = function pc1(inL, inR, out, off) {
-  var outL = 0;
-  var outR = 0;
-
-  // 7, 15, 23, 31, 39, 47, 55, 63
-  // 6, 14, 22, 30, 39, 47, 55, 63
-  // 5, 13, 21, 29, 39, 47, 55, 63
-  // 4, 12, 20, 28
-  for (var i = 7; i >= 5; i--) {
-    for (var j = 0; j <= 24; j += 8) {
-      outL <<= 1;
-      outL |= (inR >> (j + i)) & 1;
-    }
-    for (var j = 0; j <= 24; j += 8) {
-      outL <<= 1;
-      outL |= (inL >> (j + i)) & 1;
-    }
-  }
-  for (var j = 0; j <= 24; j += 8) {
-    outL <<= 1;
-    outL |= (inR >> (j + i)) & 1;
-  }
-
-  // 1, 9, 17, 25, 33, 41, 49, 57
-  // 2, 10, 18, 26, 34, 42, 50, 58
-  // 3, 11, 19, 27, 35, 43, 51, 59
-  // 36, 44, 52, 60
-  for (var i = 1; i <= 3; i++) {
-    for (var j = 0; j <= 24; j += 8) {
-      outR <<= 1;
-      outR |= (inR >> (j + i)) & 1;
-    }
-    for (var j = 0; j <= 24; j += 8) {
-      outR <<= 1;
-      outR |= (inL >> (j + i)) & 1;
-    }
-  }
-  for (var j = 0; j <= 24; j += 8) {
-    outR <<= 1;
-    outR |= (inL >> (j + i)) & 1;
-  }
-
-  out[off + 0] = outL >>> 0;
-  out[off + 1] = outR >>> 0;
-};
-
-exports.r28shl = function r28shl(num, shift) {
-  return ((num << shift) & 0xfffffff) | (num >>> (28 - shift));
-};
-
-var pc2table = [
-  // inL => outL
-  14, 11, 17, 4, 27, 23, 25, 0,
-  13, 22, 7, 18, 5, 9, 16, 24,
-  2, 20, 12, 21, 1, 8, 15, 26,
-
-  // inR => outR
-  15, 4, 25, 19, 9, 1, 26, 16,
-  5, 11, 23, 8, 12, 7, 17, 0,
-  22, 3, 10, 14, 6, 20, 27, 24
-];
-
-exports.pc2 = function pc2(inL, inR, out, off) {
-  var outL = 0;
-  var outR = 0;
-
-  var len = pc2table.length >>> 1;
-  for (var i = 0; i < len; i++) {
-    outL <<= 1;
-    outL |= (inL >>> pc2table[i]) & 0x1;
-  }
-  for (var i = len; i < pc2table.length; i++) {
-    outR <<= 1;
-    outR |= (inR >>> pc2table[i]) & 0x1;
-  }
-
-  out[off + 0] = outL >>> 0;
-  out[off + 1] = outR >>> 0;
-};
-
-exports.expand = function expand(r, out, off) {
-  var outL = 0;
-  var outR = 0;
-
-  outL = ((r & 1) << 5) | (r >>> 27);
-  for (var i = 23; i >= 15; i -= 4) {
-    outL <<= 6;
-    outL |= (r >>> i) & 0x3f;
-  }
-  for (var i = 11; i >= 3; i -= 4) {
-    outR |= (r >>> i) & 0x3f;
-    outR <<= 6;
-  }
-  outR |= ((r & 0x1f) << 1) | (r >>> 31);
-
-  out[off + 0] = outL >>> 0;
-  out[off + 1] = outR >>> 0;
-};
-
-var sTable = [
-  14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1,
-  3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8,
-  4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7,
-  15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13,
-
-  15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14,
-  9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5,
-  0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2,
-  5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9,
-
-  10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10,
-  1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1,
-  13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7,
-  11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12,
-
-  7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3,
-  1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9,
-  10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8,
-  15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14,
-
-  2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1,
-  8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6,
-  4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13,
-  15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3,
-
-  12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5,
-  0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8,
-  9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10,
-  7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13,
-
-  4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10,
-  3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6,
-  1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7,
-  10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12,
-
-  13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4,
-  10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2,
-  7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13,
-  0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11
-];
-
-exports.substitute = function substitute(inL, inR) {
-  var out = 0;
-  for (var i = 0; i < 4; i++) {
-    var b = (inL >>> (18 - i * 6)) & 0x3f;
-    var sb = sTable[i * 0x40 + b];
-
-    out <<= 4;
-    out |= sb;
-  }
-  for (var i = 0; i < 4; i++) {
-    var b = (inR >>> (18 - i * 6)) & 0x3f;
-    var sb = sTable[4 * 0x40 + i * 0x40 + b];
-
-    out <<= 4;
-    out |= sb;
-  }
-  return out >>> 0;
-};
-
-var permuteTable = [
-  16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22,
-  30, 24, 8, 18, 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7
-];
-
-exports.permute = function permute(num) {
-  var out = 0;
-  for (var i = 0; i < permuteTable.length; i++) {
-    out <<= 1;
-    out |= (num >>> permuteTable[i]) & 0x1;
-  }
-  return out >>> 0;
-};
-
-exports.padSplit = function padSplit(num, size, group) {
-  var str = num.toString(2);
-  while (str.length < size)
-    str = '0' + str;
-
-  var out = [];
-  for (var i = 0; i < size; i += group)
-    out.push(str.slice(i, i + group));
-  return out.join(' ');
-};
-
-},{}],70:[function(require,module,exports){
-(function (Buffer){
-var generatePrime = require('./lib/generatePrime')
-var primes = require('./lib/primes.json')
-
-var DH = require('./lib/dh')
-
-function getDiffieHellman (mod) {
-  var prime = new Buffer(primes[mod].prime, 'hex')
-  var gen = new Buffer(primes[mod].gen, 'hex')
-
-  return new DH(prime, gen)
-}
-
-var ENCODINGS = {
-  'binary': true, 'hex': true, 'base64': true
-}
-
-function createDiffieHellman (prime, enc, generator, genc) {
-  if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) {
-    return createDiffieHellman(prime, 'binary', enc, generator)
-  }
-
-  enc = enc || 'binary'
-  genc = genc || 'binary'
-  generator = generator || new Buffer([2])
-
-  if (!Buffer.isBuffer(generator)) {
-    generator = new Buffer(generator, genc)
-  }
-
-  if (typeof prime === 'number') {
-    return new DH(generatePrime(prime, generator), generator, true)
-  }
-
-  if (!Buffer.isBuffer(prime)) {
-    prime = new Buffer(prime, enc)
-  }
-
-  return new DH(prime, generator, true)
-}
-
-exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman
-exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman
-
-}).call(this,require("buffer").Buffer)
-},{"./lib/dh":71,"./lib/generatePrime":72,"./lib/primes.json":73,"buffer":55}],71:[function(require,module,exports){
-(function (Buffer){
-var BN = require('bn.js');
-var MillerRabin = require('miller-rabin');
-var millerRabin = new MillerRabin();
-var TWENTYFOUR = new BN(24);
-var ELEVEN = new BN(11);
-var TEN = new BN(10);
-var THREE = new BN(3);
-var SEVEN = new BN(7);
-var primes = require('./generatePrime');
-var randomBytes = require('randombytes');
-module.exports = DH;
-
-function setPublicKey(pub, enc) {
-  enc = enc || 'utf8';
-  if (!Buffer.isBuffer(pub)) {
-    pub = new Buffer(pub, enc);
-  }
-  this._pub = new BN(pub);
-  return this;
-}
-
-function setPrivateKey(priv, enc) {
-  enc = enc || 'utf8';
-  if (!Buffer.isBuffer(priv)) {
-    priv = new Buffer(priv, enc);
-  }
-  this._priv = new BN(priv);
-  return this;
-}
-
-var primeCache = {};
-function checkPrime(prime, generator) {
-  var gen = generator.toString('hex');
-  var hex = [gen, prime.toString(16)].join('_');
-  if (hex in primeCache) {
-    return primeCache[hex];
-  }
-  var error = 0;
-
-  if (prime.isEven() ||
-    !primes.simpleSieve ||
-    !primes.fermatTest(prime) ||
-    !millerRabin.test(prime)) {
-    //not a prime so +1
-    error += 1;
-
-    if (gen === '02' || gen === '05') {
-      // we'd be able to check the generator
-      // it would fail so +8
-      error += 8;
-    } else {
-      //we wouldn't be able to test the generator
-      // so +4
-      error += 4;
-    }
-    primeCache[hex] = error;
-    return error;
-  }
-  if (!millerRabin.test(prime.shrn(1))) {
-    //not a safe prime
-    error += 2;
-  }
-  var rem;
-  switch (gen) {
-    case '02':
-      if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) {
-        // unsuidable generator
-        error += 8;
-      }
-      break;
-    case '05':
-      rem = prime.mod(TEN);
-      if (rem.cmp(THREE) && rem.cmp(SEVEN)) {
-        // prime mod 10 needs to equal 3 or 7
-        error += 8;
-      }
-      break;
-    default:
-      error += 4;
-  }
-  primeCache[hex] = error;
-  return error;
-}
-
-function DH(prime, generator, malleable) {
-  this.setGenerator(generator);
-  this.__prime = new BN(prime);
-  this._prime = BN.mont(this.__prime);
-  this._primeLen = prime.length;
-  this._pub = undefined;
-  this._priv = undefined;
-  this._primeCode = undefined;
-  if (malleable) {
-    this.setPublicKey = setPublicKey;
-    this.setPrivateKey = setPrivateKey;
-  } else {
-    this._primeCode = 8;
-  }
-}
-Object.defineProperty(DH.prototype, 'verifyError', {
-  enumerable: true,
-  get: function () {
-    if (typeof this._primeCode !== 'number') {
-      this._primeCode = checkPrime(this.__prime, this.__gen);
-    }
-    return this._primeCode;
-  }
-});
-DH.prototype.generateKeys = function () {
-  if (!this._priv) {
-    this._priv = new BN(randomBytes(this._primeLen));
-  }
-  this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed();
-  return this.getPublicKey();
-};
-
-DH.prototype.computeSecret = function (other) {
-  other = new BN(other);
-  other = other.toRed(this._prime);
-  var secret = other.redPow(this._priv).fromRed();
-  var out = new Buffer(secret.toArray());
-  var prime = this.getPrime();
-  if (out.length < prime.length) {
-    var front = new Buffer(prime.length - out.length);
-    front.fill(0);
-    out = Buffer.concat([front, out]);
-  }
-  return out;
-};
-
-DH.prototype.getPublicKey = function getPublicKey(enc) {
-  return formatReturnValue(this._pub, enc);
-};
-
-DH.prototype.getPrivateKey = function getPrivateKey(enc) {
-  return formatReturnValue(this._priv, enc);
-};
-
-DH.prototype.getPrime = function (enc) {
-  return formatReturnValue(this.__prime, enc);
-};
-
-DH.prototype.getGenerator = function (enc) {
-  return formatReturnValue(this._gen, enc);
-};
-
-DH.prototype.setGenerator = function (gen, enc) {
-  enc = enc || 'utf8';
-  if (!Buffer.isBuffer(gen)) {
-    gen = new Buffer(gen, enc);
-  }
-  this.__gen = gen;
-  this._gen = new BN(gen);
-  return this;
-};
-
-function formatReturnValue(bn, enc) {
-  var buf = new Buffer(bn.toArray());
-  if (!enc) {
-    return buf;
-  } else {
-    return buf.toString(enc);
-  }
-}
-
-}).call(this,require("buffer").Buffer)
-},{"./generatePrime":72,"bn.js":24,"buffer":55,"miller-rabin":111,"randombytes":132}],72:[function(require,module,exports){
-var randomBytes = require('randombytes');
-module.exports = findPrime;
-findPrime.simpleSieve = simpleSieve;
-findPrime.fermatTest = fermatTest;
-var BN = require('bn.js');
-var TWENTYFOUR = new BN(24);
-var MillerRabin = require('miller-rabin');
-var millerRabin = new MillerRabin();
-var ONE = new BN(1);
-var TWO = new BN(2);
-var FIVE = new BN(5);
-var SIXTEEN = new BN(16);
-var EIGHT = new BN(8);
-var TEN = new BN(10);
-var THREE = new BN(3);
-var SEVEN = new BN(7);
-var ELEVEN = new BN(11);
-var FOUR = new BN(4);
-var TWELVE = new BN(12);
-var primes = null;
-
-function _getPrimes() {
-  if (primes !== null)
-    return primes;
-
-  var limit = 0x100000;
-  var res = [];
-  res[0] = 2;
-  for (var i = 1, k = 3; k < limit; k += 2) {
-    var sqrt = Math.ceil(Math.sqrt(k));
-    for (var j = 0; j < i && res[j] <= sqrt; j++)
-      if (k % res[j] === 0)
-        break;
-
-    if (i !== j && res[j] <= sqrt)
-      continue;
-
-    res[i++] = k;
-  }
-  primes = res;
-  return res;
-}
-
-function simpleSieve(p) {
-  var primes = _getPrimes();
-
-  for (var i = 0; i < primes.length; i++)
-    if (p.modn(primes[i]) === 0) {
-      if (p.cmpn(primes[i]) === 0) {
-        return true;
-      } else {
-        return false;
-      }
-    }
-
-  return true;
-}
-
-function fermatTest(p) {
-  var red = BN.mont(p);
-  return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0;
-}
-
-function findPrime(bits, gen) {
-  if (bits < 16) {
-    // this is what openssl does
-    if (gen === 2 || gen === 5) {
-      return new BN([0x8c, 0x7b]);
-    } else {
-      return new BN([0x8c, 0x27]);
-    }
-  }
-  gen = new BN(gen);
-
-  var num, n2;
-
-  while (true) {
-    num = new BN(randomBytes(Math.ceil(bits / 8)));
-    while (num.bitLength() > bits) {
-      num.ishrn(1);
-    }
-    if (num.isEven()) {
-      num.iadd(ONE);
-    }
-    if (!num.testn(1)) {
-      num.iadd(TWO);
-    }
-    if (!gen.cmp(TWO)) {
-      while (num.mod(TWENTYFOUR).cmp(ELEVEN)) {
-        num.iadd(FOUR);
-      }
-    } else if (!gen.cmp(FIVE)) {
-      while (num.mod(TEN).cmp(THREE)) {
-        num.iadd(FOUR);
-      }
-    }
-    n2 = num.shrn(1);
-    if (simpleSieve(n2) && simpleSieve(num) &&
-      fermatTest(n2) && fermatTest(num) &&
-      millerRabin.test(n2) && millerRabin.test(num)) {
-      return num;
-    }
-  }
-
-}
-
-},{"bn.js":24,"miller-rabin":111,"randombytes":132}],73:[function(require,module,exports){
-module.exports={
-    "modp1": {
-        "gen": "02",
-        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff"
-    },
-    "modp2": {
-        "gen": "02",
-        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff"
-    },
-    "modp5": {
-        "gen": "02",
-        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff"
-    },
-    "modp14": {
-        "gen": "02",
-        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff"
-    },
-    "modp15": {
-        "gen": "02",
-        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff"
-    },
-    "modp16": {
-        "gen": "02",
-        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff"
-    },
-    "modp17": {
-        "gen": "02",
-        "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff"
-    },
-    "modp18": {
-        "gen": "02",
-        "prime": "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"
-    }
-}
-},{}],74:[function(require,module,exports){
-'use strict';
-
-var elliptic = exports;
-
-elliptic.version = require('../package.json').version;
-elliptic.utils = require('./elliptic/utils');
-elliptic.rand = require('brorand');
-elliptic.curve = require('./elliptic/curve');
-elliptic.curves = require('./elliptic/curves');
-
-// Protocols
-elliptic.ec = require('./elliptic/ec');
-elliptic.eddsa = require('./elliptic/eddsa');
-
-},{"../package.json":89,"./elliptic/curve":77,"./elliptic/curves":80,"./elliptic/ec":81,"./elliptic/eddsa":84,"./elliptic/utils":88,"brorand":25}],75:[function(require,module,exports){
-'use strict';
-
-var BN = require('bn.js');
-var elliptic = require('../../elliptic');
-var utils = elliptic.utils;
-var getNAF = utils.getNAF;
-var getJSF = utils.getJSF;
-var assert = utils.assert;
-
-function BaseCurve(type, conf) {
-  this.type = type;
-  this.p = new BN(conf.p, 16);
-
-  // Use Montgomery, when there is no fast reduction for the prime
-  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);
-
-  // Useful for many curves
-  this.zero = new BN(0).toRed(this.red);
-  this.one = new BN(1).toRed(this.red);
-  this.two = new BN(2).toRed(this.red);
-
-  // Curve configuration, optional
-  this.n = conf.n && new BN(conf.n, 16);
-  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);
-
-  // Temporary arrays
-  this._wnafT1 = new Array(4);
-  this._wnafT2 = new Array(4);
-  this._wnafT3 = new Array(4);
-  this._wnafT4 = new Array(4);
-
-  // Generalized Greg Maxwell's trick
-  var adjustCount = this.n && this.p.div(this.n);
-  if (!adjustCount || adjustCount.cmpn(100) > 0) {
-    this.redN = null;
-  } else {
-    this._maxwellTrick = true;
-    this.redN = this.n.toRed(this.red);
-  }
-}
-module.exports = BaseCurve;
-
-BaseCurve.prototype.point = function point() {
-  throw new Error('Not implemented');
-};
-
-BaseCurve.prototype.validate = function validate() {
-  throw new Error('Not implemented');
-};
-
-BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
-  assert(p.precomputed);
-  var doubles = p._getDoubles();
-
-  var naf = getNAF(k, 1);
-  var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);
-  I /= 3;
-
-  // Translate into more windowed form
-  var repr = [];
-  for (var j = 0; j < naf.length; j += doubles.step) {
-    var nafW = 0;
-    for (var k = j + doubles.step - 1; k >= j; k--)
-      nafW = (nafW << 1) + naf[k];
-    repr.push(nafW);
-  }
-
-  var a = this.jpoint(null, null, null);
-  var b = this.jpoint(null, null, null);
-  for (var i = I; i > 0; i--) {
-    for (var j = 0; j < repr.length; j++) {
-      var nafW = repr[j];
-      if (nafW === i)
-        b = b.mixedAdd(doubles.points[j]);
-      else if (nafW === -i)
-        b = b.mixedAdd(doubles.points[j].neg());
-    }
-    a = a.add(b);
-  }
-  return a.toP();
-};
-
-BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
-  var w = 4;
-
-  // Precompute window
-  var nafPoints = p._getNAFPoints(w);
-  w = nafPoints.wnd;
-  var wnd = nafPoints.points;
-
-  // Get NAF form
-  var naf = getNAF(k, w);
-
-  // Add `this`*(N+1) for every w-NAF index
-  var acc = this.jpoint(null, null, null);
-  for (var i = naf.length - 1; i >= 0; i--) {
-    // Count zeroes
-    for (var k = 0; i >= 0 && naf[i] === 0; i--)
-      k++;
-    if (i >= 0)
-      k++;
-    acc = acc.dblp(k);
-
-    if (i < 0)
-      break;
-    var z = naf[i];
-    assert(z !== 0);
-    if (p.type === 'affine') {
-      // J +- P
-      if (z > 0)
-        acc = acc.mixedAdd(wnd[(z - 1) >> 1]);
-      else
-        acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());
-    } else {
-      // J +- J
-      if (z > 0)
-        acc = acc.add(wnd[(z - 1) >> 1]);
-      else
-        acc = acc.add(wnd[(-z - 1) >> 1].neg());
-    }
-  }
-  return p.type === 'affine' ? acc.toP() : acc;
-};
-
-BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,
-                                                       points,
-                                                       coeffs,
-                                                       len,
-                                                       jacobianResult) {
-  var wndWidth = this._wnafT1;
-  var wnd = this._wnafT2;
-  var naf = this._wnafT3;
-
-  // Fill all arrays
-  var max = 0;
-  for (var i = 0; i < len; i++) {
-    var p = points[i];
-    var nafPoints = p._getNAFPoints(defW);
-    wndWidth[i] = nafPoints.wnd;
-    wnd[i] = nafPoints.points;
-  }
-
-  // Comb small window NAFs
-  for (var i = len - 1; i >= 1; i -= 2) {
-    var a = i - 1;
-    var b = i;
-    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
-      naf[a] = getNAF(coeffs[a], wndWidth[a]);
-      naf[b] = getNAF(coeffs[b], wndWidth[b]);
-      max = Math.max(naf[a].length, max);
-      max = Math.max(naf[b].length, max);
-      continue;
-    }
-
-    var comb = [
-      points[a], /* 1 */
-      null, /* 3 */
-      null, /* 5 */
-      points[b] /* 7 */
-    ];
-
-    // Try to avoid Projective points, if possible
-    if (points[a].y.cmp(points[b].y) === 0) {
-      comb[1] = points[a].add(points[b]);
-      comb[2] = points[a].toJ().mixedAdd(points[b].neg());
-    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
-      comb[1] = points[a].toJ().mixedAdd(points[b]);
-      comb[2] = points[a].add(points[b].neg());
-    } else {
-      comb[1] = points[a].toJ().mixedAdd(points[b]);
-      comb[2] = points[a].toJ().mixedAdd(points[b].neg());
-    }
-
-    var index = [
-      -3, /* -1 -1 */
-      -1, /* -1 0 */
-      -5, /* -1 1 */
-      -7, /* 0 -1 */
-      0, /* 0 0 */
-      7, /* 0 1 */
-      5, /* 1 -1 */
-      1, /* 1 0 */
-      3  /* 1 1 */
-    ];
-
-    var jsf = getJSF(coeffs[a], coeffs[b]);
-    max = Math.max(jsf[0].length, max);
-    naf[a] = new Array(max);
-    naf[b] = new Array(max);
-    for (var j = 0; j < max; j++) {
-      var ja = jsf[0][j] | 0;
-      var jb = jsf[1][j] | 0;
-
-      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
-      naf[b][j] = 0;
-      wnd[a] = comb;
-    }
-  }
-
-  var acc = this.jpoint(null, null, null);
-  var tmp = this._wnafT4;
-  for (var i = max; i >= 0; i--) {
-    var k = 0;
-
-    while (i >= 0) {
-      var zero = true;
-      for (var j = 0; j < len; j++) {
-        tmp[j] = naf[j][i] | 0;
-        if (tmp[j] !== 0)
-          zero = false;
-      }
-      if (!zero)
-        break;
-      k++;
-      i--;
-    }
-    if (i >= 0)
-      k++;
-    acc = acc.dblp(k);
-    if (i < 0)
-      break;
-
-    for (var j = 0; j < len; j++) {
-      var z = tmp[j];
-      var p;
-      if (z === 0)
-        continue;
-      else if (z > 0)
-        p = wnd[j][(z - 1) >> 1];
-      else if (z < 0)
-        p = wnd[j][(-z - 1) >> 1].neg();
-
-      if (p.type === 'affine')
-        acc = acc.mixedAdd(p);
-      else
-        acc = acc.add(p);
-    }
-  }
-  // Zeroify references
-  for (var i = 0; i < len; i++)
-    wnd[i] = null;
-
-  if (jacobianResult)
-    return acc;
-  else
-    return acc.toP();
-};
-
-function BasePoint(curve, type) {
-  this.curve = curve;
-  this.type = type;
-  this.precomputed = null;
-}
-BaseCurve.BasePoint = BasePoint;
-
-BasePoint.prototype.eq = function eq(/*other*/) {
-  throw new Error('Not implemented');
-};
-
-BasePoint.prototype.validate = function validate() {
-  return this.curve.validate(this);
-};
-
-BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
-  bytes = utils.toArray(bytes, enc);
-
-  var len = this.p.byteLength();
-
-  // uncompressed, hybrid-odd, hybrid-even
-  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&
-      bytes.length - 1 === 2 * len) {
-    if (bytes[0] === 0x06)
-      assert(bytes[bytes.length - 1] % 2 === 0);
-    else if (bytes[0] === 0x07)
-      assert(bytes[bytes.length - 1] % 2 === 1);
-
-    var res =  this.point(bytes.slice(1, 1 + len),
-                          bytes.slice(1 + len, 1 + 2 * len));
-
-    return res;
-  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&
-              bytes.length - 1 === len) {
-    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);
-  }
-  throw new Error('Unknown point format');
-};
-
-BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
-  return this.encode(enc, true);
-};
-
-BasePoint.prototype._encode = function _encode(compact) {
-  var len = this.curve.p.byteLength();
-  var x = this.getX().toArray('be', len);
-
-  if (compact)
-    return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x);
-
-  return [ 0x04 ].concat(x, this.getY().toArray('be', len)) ;
-};
-
-BasePoint.prototype.encode = function encode(enc, compact) {
-  return utils.encode(this._encode(compact), enc);
-};
-
-BasePoint.prototype.precompute = function precompute(power) {
-  if (this.precomputed)
-    return this;
-
-  var precomputed = {
-    doubles: null,
-    naf: null,
-    beta: null
-  };
-  precomputed.naf = this._getNAFPoints(8);
-  precomputed.doubles = this._getDoubles(4, power);
-  precomputed.beta = this._getBeta();
-  this.precomputed = precomputed;
-
-  return this;
-};
-
-BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
-  if (!this.precomputed)
-    return false;
-
-  var doubles = this.precomputed.doubles;
-  if (!doubles)
-    return false;
-
-  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
-};
-
-BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
-  if (this.precomputed && this.precomputed.doubles)
-    return this.precomputed.doubles;
-
-  var doubles = [ this ];
-  var acc = this;
-  for (var i = 0; i < power; i += step) {
-    for (var j = 0; j < step; j++)
-      acc = acc.dbl();
-    doubles.push(acc);
-  }
-  return {
-    step: step,
-    points: doubles
-  };
-};
-
-BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
-  if (this.precomputed && this.precomputed.naf)
-    return this.precomputed.naf;
-
-  var res = [ this ];
-  var max = (1 << wnd) - 1;
-  var dbl = max === 1 ? null : this.dbl();
-  for (var i = 1; i < max; i++)
-    res[i] = res[i - 1].add(dbl);
-  return {
-    wnd: wnd,
-    points: res
-  };
-};
-
-BasePoint.prototype._getBeta = function _getBeta() {
-  return null;
-};
-
-BasePoint.prototype.dblp = function dblp(k) {
-  var r = this;
-  for (var i = 0; i < k; i++)
-    r = r.dbl();
-  return r;
-};
-
-},{"../../elliptic":74,"bn.js":24}],76:[function(require,module,exports){
-'use strict';
-
-var curve = require('../curve');
-var elliptic = require('../../elliptic');
-var BN = require('bn.js');
-var inherits = require('inherits');
-var Base = curve.base;
-
-var assert = elliptic.utils.assert;
-
-function EdwardsCurve(conf) {
-  // NOTE: Important as we are creating point in Base.call()
-  this.twisted = (conf.a | 0) !== 1;
-  this.mOneA = this.twisted && (conf.a | 0) === -1;
-  this.extended = this.mOneA;
-
-  Base.call(this, 'edwards', conf);
-
-  this.a = new BN(conf.a, 16).umod(this.red.m);
-  this.a = this.a.toRed(this.red);
-  this.c = new BN(conf.c, 16).toRed(this.red);
-  this.c2 = this.c.redSqr();
-  this.d = new BN(conf.d, 16).toRed(this.red);
-  this.dd = this.d.redAdd(this.d);
-
-  assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
-  this.oneC = (conf.c | 0) === 1;
-}
-inherits(EdwardsCurve, Base);
-module.exports = EdwardsCurve;
-
-EdwardsCurve.prototype._mulA = function _mulA(num) {
-  if (this.mOneA)
-    return num.redNeg();
-  else
-    return this.a.redMul(num);
-};
-
-EdwardsCurve.prototype._mulC = function _mulC(num) {
-  if (this.oneC)
-    return num;
-  else
-    return this.c.redMul(num);
-};
-
-// Just for compatibility with Short curve
-EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
-  return this.point(x, y, z, t);
-};
-
-EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
-  x = new BN(x, 16);
-  if (!x.red)
-    x = x.toRed(this.red);
-
-  var x2 = x.redSqr();
-  var rhs = this.c2.redSub(this.a.redMul(x2));
-  var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
-
-  var y2 = rhs.redMul(lhs.redInvm());
-  var y = y2.redSqrt();
-  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
-    throw new Error('invalid point');
-
-  var isOdd = y.fromRed().isOdd();
-  if (odd && !isOdd || !odd && isOdd)
-    y = y.redNeg();
-
-  return this.point(x, y);
-};
-
-EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
-  y = new BN(y, 16);
-  if (!y.red)
-    y = y.toRed(this.red);
-
-  // x^2 = (y^2 - 1) / (d y^2 + 1)
-  var y2 = y.redSqr();
-  var lhs = y2.redSub(this.one);
-  var rhs = y2.redMul(this.d).redAdd(this.one);
-  var x2 = lhs.redMul(rhs.redInvm());
-
-  if (x2.cmp(this.zero) === 0) {
-    if (odd)
-      throw new Error('invalid point');
-    else
-      return this.point(this.zero, y);
-  }
-
-  var x = x2.redSqrt();
-  if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)
-    throw new Error('invalid point');
-
-  if (x.isOdd() !== odd)
-    x = x.redNeg();
-
-  return this.point(x, y);
-};
-
-EdwardsCurve.prototype.validate = function validate(point) {
-  if (point.isInfinity())
-    return true;
-
-  // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)
-  point.normalize();
-
-  var x2 = point.x.redSqr();
-  var y2 = point.y.redSqr();
-  var lhs = x2.redMul(this.a).redAdd(y2);
-  var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
-
-  return lhs.cmp(rhs) === 0;
-};
-
-function Point(curve, x, y, z, t) {
-  Base.BasePoint.call(this, curve, 'projective');
-  if (x === null && y === null && z === null) {
-    this.x = this.curve.zero;
-    this.y = this.curve.one;
-    this.z = this.curve.one;
-    this.t = this.curve.zero;
-    this.zOne = true;
-  } else {
-    this.x = new BN(x, 16);
-    this.y = new BN(y, 16);
-    this.z = z ? new BN(z, 16) : this.curve.one;
-    this.t = t && new BN(t, 16);
-    if (!this.x.red)
-      this.x = this.x.toRed(this.curve.red);
-    if (!this.y.red)
-      this.y = this.y.toRed(this.curve.red);
-    if (!this.z.red)
-      this.z = this.z.toRed(this.curve.red);
-    if (this.t && !this.t.red)
-      this.t = this.t.toRed(this.curve.red);
-    this.zOne = this.z === this.curve.one;
-
-    // Use extended coordinates
-    if (this.curve.extended && !this.t) {
-      this.t = this.x.redMul(this.y);
-      if (!this.zOne)
-        this.t = this.t.redMul(this.z.redInvm());
-    }
-  }
-}
-inherits(Point, Base.BasePoint);
-
-EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
-  return Point.fromJSON(this, obj);
-};
-
-EdwardsCurve.prototype.point = function point(x, y, z, t) {
-  return new Point(this, x, y, z, t);
-};
-
-Point.fromJSON = function fromJSON(curve, obj) {
-  return new Point(curve, obj[0], obj[1], obj[2]);
-};
-
-Point.prototype.inspect = function inspect() {
-  if (this.isInfinity())
-    return '<EC Point Infinity>';
-  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
-      ' y: ' + this.y.fromRed().toString(16, 2) +
-      ' z: ' + this.z.fromRed().toString(16, 2) + '>';
-};
-
-Point.prototype.isInfinity = function isInfinity() {
-  // XXX This code assumes that zero is always zero in red
-  return this.x.cmpn(0) === 0 &&
-         this.y.cmp(this.z) === 0;
-};
-
-Point.prototype._extDbl = function _extDbl() {
-  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
-  //     #doubling-dbl-2008-hwcd
-  // 4M + 4S
-
-  // A = X1^2
-  var a = this.x.redSqr();
-  // B = Y1^2
-  var b = this.y.redSqr();
-  // C = 2 * Z1^2
-  var c = this.z.redSqr();
-  c = c.redIAdd(c);
-  // D = a * A
-  var d = this.curve._mulA(a);
-  // E = (X1 + Y1)^2 - A - B
-  var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);
-  // G = D + B
-  var g = d.redAdd(b);
-  // F = G - C
-  var f = g.redSub(c);
-  // H = D - B
-  var h = d.redSub(b);
-  // X3 = E * F
-  var nx = e.redMul(f);
-  // Y3 = G * H
-  var ny = g.redMul(h);
-  // T3 = E * H
-  var nt = e.redMul(h);
-  // Z3 = F * G
-  var nz = f.redMul(g);
-  return this.curve.point(nx, ny, nz, nt);
-};
-
-Point.prototype._projDbl = function _projDbl() {
-  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
-  //     #doubling-dbl-2008-bbjlp
-  //     #doubling-dbl-2007-bl
-  // and others
-  // Generally 3M + 4S or 2M + 4S
-
-  // B = (X1 + Y1)^2
-  var b = this.x.redAdd(this.y).redSqr();
-  // C = X1^2
-  var c = this.x.redSqr();
-  // D = Y1^2
-  var d = this.y.redSqr();
-
-  var nx;
-  var ny;
-  var nz;
-  if (this.curve.twisted) {
-    // E = a * C
-    var e = this.curve._mulA(c);
-    // F = E + D
-    var f = e.redAdd(d);
-    if (this.zOne) {
-      // X3 = (B - C - D) * (F - 2)
-      nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));
-      // Y3 = F * (E - D)
-      ny = f.redMul(e.redSub(d));
-      // Z3 = F^2 - 2 * F
-      nz = f.redSqr().redSub(f).redSub(f);
-    } else {
-      // H = Z1^2
-      var h = this.z.redSqr();
-      // J = F - 2 * H
-      var j = f.redSub(h).redISub(h);
-      // X3 = (B-C-D)*J
-      nx = b.redSub(c).redISub(d).redMul(j);
-      // Y3 = F * (E - D)
-      ny = f.redMul(e.redSub(d));
-      // Z3 = F * J
-      nz = f.redMul(j);
-    }
-  } else {
-    // E = C + D
-    var e = c.redAdd(d);
-    // H = (c * Z1)^2
-    var h = this.curve._mulC(this.c.redMul(this.z)).redSqr();
-    // J = E - 2 * H
-    var j = e.redSub(h).redSub(h);
-    // X3 = c * (B - E) * J
-    nx = this.curve._mulC(b.redISub(e)).redMul(j);
-    // Y3 = c * E * (C - D)
-    ny = this.curve._mulC(e).redMul(c.redISub(d));
-    // Z3 = E * J
-    nz = e.redMul(j);
-  }
-  return this.curve.point(nx, ny, nz);
-};
-
-Point.prototype.dbl = function dbl() {
-  if (this.isInfinity())
-    return this;
-
-  // Double in extended coordinates
-  if (this.curve.extended)
-    return this._extDbl();
-  else
-    return this._projDbl();
-};
-
-Point.prototype._extAdd = function _extAdd(p) {
-  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
-  //     #addition-add-2008-hwcd-3
-  // 8M
-
-  // A = (Y1 - X1) * (Y2 - X2)
-  var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));
-  // B = (Y1 + X1) * (Y2 + X2)
-  var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));
-  // C = T1 * k * T2
-  var c = this.t.redMul(this.curve.dd).redMul(p.t);
-  // D = Z1 * 2 * Z2
-  var d = this.z.redMul(p.z.redAdd(p.z));
-  // E = B - A
-  var e = b.redSub(a);
-  // F = D - C
-  var f = d.redSub(c);
-  // G = D + C
-  var g = d.redAdd(c);
-  // H = B + A
-  var h = b.redAdd(a);
-  // X3 = E * F
-  var nx = e.redMul(f);
-  // Y3 = G * H
-  var ny = g.redMul(h);
-  // T3 = E * H
-  var nt = e.redMul(h);
-  // Z3 = F * G
-  var nz = f.redMul(g);
-  return this.curve.point(nx, ny, nz, nt);
-};
-
-Point.prototype._projAdd = function _projAdd(p) {
-  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
-  //     #addition-add-2008-bbjlp
-  //     #addition-add-2007-bl
-  // 10M + 1S
-
-  // A = Z1 * Z2
-  var a = this.z.redMul(p.z);
-  // B = A^2
-  var b = a.redSqr();
-  // C = X1 * X2
-  var c = this.x.redMul(p.x);
-  // D = Y1 * Y2
-  var d = this.y.redMul(p.y);
-  // E = d * C * D
-  var e = this.curve.d.redMul(c).redMul(d);
-  // F = B - E
-  var f = b.redSub(e);
-  // G = B + E
-  var g = b.redAdd(e);
-  // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)
-  var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
-  var nx = a.redMul(f).redMul(tmp);
-  var ny;
-  var nz;
-  if (this.curve.twisted) {
-    // Y3 = A * G * (D - a * C)
-    ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));
-    // Z3 = F * G
-    nz = f.redMul(g);
-  } else {
-    // Y3 = A * G * (D - C)
-    ny = a.redMul(g).redMul(d.redSub(c));
-    // Z3 = c * F * G
-    nz = this.curve._mulC(f).redMul(g);
-  }
-  return this.curve.point(nx, ny, nz);
-};
-
-Point.prototype.add = function add(p) {
-  if (this.isInfinity())
-    return p;
-  if (p.isInfinity())
-    return this;
-
-  if (this.curve.extended)
-    return this._extAdd(p);
-  else
-    return this._projAdd(p);
-};
-
-Point.prototype.mul = function mul(k) {
-  if (this._hasDoubles(k))
-    return this.curve._fixedNafMul(this, k);
-  else
-    return this.curve._wnafMul(this, k);
-};
-
-Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
-  return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, false);
-};
-
-Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
-  return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, true);
-};
-
-Point.prototype.normalize = function normalize() {
-  if (this.zOne)
-    return this;
-
-  // Normalize coordinates
-  var zi = this.z.redInvm();
-  this.x = this.x.redMul(zi);
-  this.y = this.y.redMul(zi);
-  if (this.t)
-    this.t = this.t.redMul(zi);
-  this.z = this.curve.one;
-  this.zOne = true;
-  return this;
-};
-
-Point.prototype.neg = function neg() {
-  return this.curve.point(this.x.redNeg(),
-                          this.y,
-                          this.z,
-                          this.t && this.t.redNeg());
-};
-
-Point.prototype.getX = function getX() {
-  this.normalize();
-  return this.x.fromRed();
-};
-
-Point.prototype.getY = function getY() {
-  this.normalize();
-  return this.y.fromRed();
-};
-
-Point.prototype.eq = function eq(other) {
-  return this === other ||
-         this.getX().cmp(other.getX()) === 0 &&
-         this.getY().cmp(other.getY()) === 0;
-};
-
-Point.prototype.eqXToP = function eqXToP(x) {
-  var rx = x.toRed(this.curve.red).redMul(this.z);
-  if (this.x.cmp(rx) === 0)
-    return true;
-
-  var xc = x.clone();
-  var t = this.curve.redN.redMul(this.z);
-  for (;;) {
-    xc.iadd(this.curve.n);
-    if (xc.cmp(this.curve.p) >= 0)
-      return false;
-
-    rx.redIAdd(t);
-    if (this.x.cmp(rx) === 0)
-      return true;
-  }
-  return false;
-};
-
-// Compatibility with BaseCurve
-Point.prototype.toP = Point.prototype.normalize;
-Point.prototype.mixedAdd = Point.prototype.add;
-
-},{"../../elliptic":74,"../curve":77,"bn.js":24,"inherits":107}],77:[function(require,module,exports){
-'use strict';
-
-var curve = exports;
-
-curve.base = require('./base');
-curve.short = require('./short');
-curve.mont = require('./mont');
-curve.edwards = require('./edwards');
-
-},{"./base":75,"./edwards":76,"./mont":78,"./short":79}],78:[function(require,module,exports){
-'use strict';
-
-var curve = require('../curve');
-var BN = require('bn.js');
-var inherits = require('inherits');
-var Base = curve.base;
-
-var elliptic = require('../../elliptic');
-var utils = elliptic.utils;
-
-function MontCurve(conf) {
-  Base.call(this, 'mont', conf);
-
-  this.a = new BN(conf.a, 16).toRed(this.red);
-  this.b = new BN(conf.b, 16).toRed(this.red);
-  this.i4 = new BN(4).toRed(this.red).redInvm();
-  this.two = new BN(2).toRed(this.red);
-  this.a24 = this.i4.redMul(this.a.redAdd(this.two));
-}
-inherits(MontCurve, Base);
-module.exports = MontCurve;
-
-MontCurve.prototype.validate = function validate(point) {
-  var x = point.normalize().x;
-  var x2 = x.redSqr();
-  var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
-  var y = rhs.redSqrt();
-
-  return y.redSqr().cmp(rhs) === 0;
-};
-
-function Point(curve, x, z) {
-  Base.BasePoint.call(this, curve, 'projective');
-  if (x === null && z === null) {
-    this.x = this.curve.one;
-    this.z = this.curve.zero;
-  } else {
-    this.x = new BN(x, 16);
-    this.z = new BN(z, 16);
-    if (!this.x.red)
-      this.x = this.x.toRed(this.curve.red);
-    if (!this.z.red)
-      this.z = this.z.toRed(this.curve.red);
-  }
-}
-inherits(Point, Base.BasePoint);
-
-MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
-  return this.point(utils.toArray(bytes, enc), 1);
-};
-
-MontCurve.prototype.point = function point(x, z) {
-  return new Point(this, x, z);
-};
-
-MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
-  return Point.fromJSON(this, obj);
-};
-
-Point.prototype.precompute = function precompute() {
-  // No-op
-};
-
-Point.prototype._encode = function _encode() {
-  return this.getX().toArray('be', this.curve.p.byteLength());
-};
-
-Point.fromJSON = function fromJSON(curve, obj) {
-  return new Point(curve, obj[0], obj[1] || curve.one);
-};
-
-Point.prototype.inspect = function inspect() {
-  if (this.isInfinity())
-    return '<EC Point Infinity>';
-  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
-      ' z: ' + this.z.fromRed().toString(16, 2) + '>';
-};
-
-Point.prototype.isInfinity = function isInfinity() {
-  // XXX This code assumes that zero is always zero in red
-  return this.z.cmpn(0) === 0;
-};
-
-Point.prototype.dbl = function dbl() {
-  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3
-  // 2M + 2S + 4A
-
-  // A = X1 + Z1
-  var a = this.x.redAdd(this.z);
-  // AA = A^2
-  var aa = a.redSqr();
-  // B = X1 - Z1
-  var b = this.x.redSub(this.z);
-  // BB = B^2
-  var bb = b.redSqr();
-  // C = AA - BB
-  var c = aa.redSub(bb);
-  // X3 = AA * BB
-  var nx = aa.redMul(bb);
-  // Z3 = C * (BB + A24 * C)
-  var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
-  return this.curve.point(nx, nz);
-};
-
-Point.prototype.add = function add() {
-  throw new Error('Not supported on Montgomery curve');
-};
-
-Point.prototype.diffAdd = function diffAdd(p, diff) {
-  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3
-  // 4M + 2S + 6A
-
-  // A = X2 + Z2
-  var a = this.x.redAdd(this.z);
-  // B = X2 - Z2
-  var b = this.x.redSub(this.z);
-  // C = X3 + Z3
-  var c = p.x.redAdd(p.z);
-  // D = X3 - Z3
-  var d = p.x.redSub(p.z);
-  // DA = D * A
-  var da = d.redMul(a);
-  // CB = C * B
-  var cb = c.redMul(b);
-  // X5 = Z1 * (DA + CB)^2
-  var nx = diff.z.redMul(da.redAdd(cb).redSqr());
-  // Z5 = X1 * (DA - CB)^2
-  var nz = diff.x.redMul(da.redISub(cb).redSqr());
-  return this.curve.point(nx, nz);
-};
-
-Point.prototype.mul = function mul(k) {
-  var t = k.clone();
-  var a = this; // (N / 2) * Q + Q
-  var b = this.curve.point(null, null); // (N / 2) * Q
-  var c = this; // Q
-
-  for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))
-    bits.push(t.andln(1));
-
-  for (var i = bits.length - 1; i >= 0; i--) {
-    if (bits[i] === 0) {
-      // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q
-      a = a.diffAdd(b, c);
-      // N * Q = 2 * ((N / 2) * Q + Q))
-      b = b.dbl();
-    } else {
-      // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)
-      b = a.diffAdd(b, c);
-      // N * Q + Q = 2 * ((N / 2) * Q + Q)
-      a = a.dbl();
-    }
-  }
-  return b;
-};
-
-Point.prototype.mulAdd = function mulAdd() {
-  throw new Error('Not supported on Montgomery curve');
-};
-
-Point.prototype.jumlAdd = function jumlAdd() {
-  throw new Error('Not supported on Montgomery curve');
-};
-
-Point.prototype.eq = function eq(other) {
-  return this.getX().cmp(other.getX()) === 0;
-};
-
-Point.prototype.normalize = function normalize() {
-  this.x = this.x.redMul(this.z.redInvm());
-  this.z = this.curve.one;
-  return this;
-};
-
-Point.prototype.getX = function getX() {
-  // Normalize coordinates
-  this.normalize();
-
-  return this.x.fromRed();
-};
-
-},{"../../elliptic":74,"../curve":77,"bn.js":24,"inherits":107}],79:[function(require,module,exports){
-'use strict';
-
-var curve = require('../curve');
-var elliptic = require('../../elliptic');
-var BN = require('bn.js');
-var inherits = require('inherits');
-var Base = curve.base;
-
-var assert = elliptic.utils.assert;
-
-function ShortCurve(conf) {
-  Base.call(this, 'short', conf);
-
-  this.a = new BN(conf.a, 16).toRed(this.red);
-  this.b = new BN(conf.b, 16).toRed(this.red);
-  this.tinv = this.two.redInvm();
-
-  this.zeroA = this.a.fromRed().cmpn(0) === 0;
-  this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;
-
-  // If the curve is endomorphic, precalculate beta and lambda
-  this.endo = this._getEndomorphism(conf);
-  this._endoWnafT1 = new Array(4);
-  this._endoWnafT2 = new Array(4);
-}
-inherits(ShortCurve, Base);
-module.exports = ShortCurve;
-
-ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
-  // No efficient endomorphism
-  if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)
-    return;
-
-  // Compute beta and lambda, that lambda * P = (beta * Px; Py)
-  var beta;
-  var lambda;
-  if (conf.beta) {
-    beta = new BN(conf.beta, 16).toRed(this.red);
-  } else {
-    var betas = this._getEndoRoots(this.p);
-    // Choose the smallest beta
-    beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
-    beta = beta.toRed(this.red);
-  }
-  if (conf.lambda) {
-    lambda = new BN(conf.lambda, 16);
-  } else {
-    // Choose the lambda that is matching selected beta
-    var lambdas = this._getEndoRoots(this.n);
-    if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
-      lambda = lambdas[0];
-    } else {
-      lambda = lambdas[1];
-      assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
-    }
-  }
-
-  // Get basis vectors, used for balanced length-two representation
-  var basis;
-  if (conf.basis) {
-    basis = conf.basis.map(function(vec) {
-      return {
-        a: new BN(vec.a, 16),
-        b: new BN(vec.b, 16)
-      };
-    });
-  } else {
-    basis = this._getEndoBasis(lambda);
-  }
-
-  return {
-    beta: beta,
-    lambda: lambda,
-    basis: basis
-  };
-};
-
-ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
-  // Find roots of for x^2 + x + 1 in F
-  // Root = (-1 +- Sqrt(-3)) / 2
-  //
-  var red = num === this.p ? this.red : BN.mont(num);
-  var tinv = new BN(2).toRed(red).redInvm();
-  var ntinv = tinv.redNeg();
-
-  var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
-
-  var l1 = ntinv.redAdd(s).fromRed();
-  var l2 = ntinv.redSub(s).fromRed();
-  return [ l1, l2 ];
-};
-
-ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
-  // aprxSqrt >= sqrt(this.n)
-  var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
-
-  // 3.74
-  // Run EGCD, until r(L + 1) < aprxSqrt
-  var u = lambda;
-  var v = this.n.clone();
-  var x1 = new BN(1);
-  var y1 = new BN(0);
-  var x2 = new BN(0);
-  var y2 = new BN(1);
-
-  // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)
-  var a0;
-  var b0;
-  // First vector
-  var a1;
-  var b1;
-  // Second vector
-  var a2;
-  var b2;
-
-  var prevR;
-  var i = 0;
-  var r;
-  var x;
-  while (u.cmpn(0) !== 0) {
-    var q = v.div(u);
-    r = v.sub(q.mul(u));
-    x = x2.sub(q.mul(x1));
-    var y = y2.sub(q.mul(y1));
-
-    if (!a1 && r.cmp(aprxSqrt) < 0) {
-      a0 = prevR.neg();
-      b0 = x1;
-      a1 = r.neg();
-      b1 = x;
-    } else if (a1 && ++i === 2) {
-      break;
-    }
-    prevR = r;
-
-    v = u;
-    u = r;
-    x2 = x1;
-    x1 = x;
-    y2 = y1;
-    y1 = y;
-  }
-  a2 = r.neg();
-  b2 = x;
-
-  var len1 = a1.sqr().add(b1.sqr());
-  var len2 = a2.sqr().add(b2.sqr());
-  if (len2.cmp(len1) >= 0) {
-    a2 = a0;
-    b2 = b0;
-  }
-
-  // Normalize signs
-  if (a1.negative) {
-    a1 = a1.neg();
-    b1 = b1.neg();
-  }
-  if (a2.negative) {
-    a2 = a2.neg();
-    b2 = b2.neg();
-  }
-
-  return [
-    { a: a1, b: b1 },
-    { a: a2, b: b2 }
-  ];
-};
-
-ShortCurve.prototype._endoSplit = function _endoSplit(k) {
-  var basis = this.endo.basis;
-  var v1 = basis[0];
-  var v2 = basis[1];
-
-  var c1 = v2.b.mul(k).divRound(this.n);
-  var c2 = v1.b.neg().mul(k).divRound(this.n);
-
-  var p1 = c1.mul(v1.a);
-  var p2 = c2.mul(v2.a);
-  var q1 = c1.mul(v1.b);
-  var q2 = c2.mul(v2.b);
-
-  // Calculate answer
-  var k1 = k.sub(p1).sub(p2);
-  var k2 = q1.add(q2).neg();
-  return { k1: k1, k2: k2 };
-};
-
-ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
-  x = new BN(x, 16);
-  if (!x.red)
-    x = x.toRed(this.red);
-
-  var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
-  var y = y2.redSqrt();
-  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
-    throw new Error('invalid point');
-
-  // XXX Is there any way to tell if the number is odd without converting it
-  // to non-red form?
-  var isOdd = y.fromRed().isOdd();
-  if (odd && !isOdd || !odd && isOdd)
-    y = y.redNeg();
-
-  return this.point(x, y);
-};
-
-ShortCurve.prototype.validate = function validate(point) {
-  if (point.inf)
-    return true;
-
-  var x = point.x;
-  var y = point.y;
-
-  var ax = this.a.redMul(x);
-  var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
-  return y.redSqr().redISub(rhs).cmpn(0) === 0;
-};
-
-ShortCurve.prototype._endoWnafMulAdd =
-    function _endoWnafMulAdd(points, coeffs, jacobianResult) {
-  var npoints = this._endoWnafT1;
-  var ncoeffs = this._endoWnafT2;
-  for (var i = 0; i < points.length; i++) {
-    var split = this._endoSplit(coeffs[i]);
-    var p = points[i];
-    var beta = p._getBeta();
-
-    if (split.k1.negative) {
-      split.k1.ineg();
-      p = p.neg(true);
-    }
-    if (split.k2.negative) {
-      split.k2.ineg();
-      beta = beta.neg(true);
-    }
-
-    npoints[i * 2] = p;
-    npoints[i * 2 + 1] = beta;
-    ncoeffs[i * 2] = split.k1;
-    ncoeffs[i * 2 + 1] = split.k2;
-  }
-  var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);
-
-  // Clean-up references to points and coefficients
-  for (var j = 0; j < i * 2; j++) {
-    npoints[j] = null;
-    ncoeffs[j] = null;
-  }
-  return res;
-};
-
-function Point(curve, x, y, isRed) {
-  Base.BasePoint.call(this, curve, 'affine');
-  if (x === null && y === null) {
-    this.x = null;
-    this.y = null;
-    this.inf = true;
-  } else {
-    this.x = new BN(x, 16);
-    this.y = new BN(y, 16);
-    // Force redgomery representation when loading from JSON
-    if (isRed) {
-      this.x.forceRed(this.curve.red);
-      this.y.forceRed(this.curve.red);
-    }
-    if (!this.x.red)
-      this.x = this.x.toRed(this.curve.red);
-    if (!this.y.red)
-      this.y = this.y.toRed(this.curve.red);
-    this.inf = false;
-  }
-}
-inherits(Point, Base.BasePoint);
-
-ShortCurve.prototype.point = function point(x, y, isRed) {
-  return new Point(this, x, y, isRed);
-};
-
-ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
-  return Point.fromJSON(this, obj, red);
-};
-
-Point.prototype._getBeta = function _getBeta() {
-  if (!this.curve.endo)
-    return;
-
-  var pre = this.precomputed;
-  if (pre && pre.beta)
-    return pre.beta;
-
-  var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
-  if (pre) {
-    var curve = this.curve;
-    var endoMul = function(p) {
-      return curve.point(p.x.redMul(curve.endo.beta), p.y);
-    };
-    pre.beta = beta;
-    beta.precomputed = {
-      beta: null,
-      naf: pre.naf && {
-        wnd: pre.naf.wnd,
-        points: pre.naf.points.map(endoMul)
-      },
-      doubles: pre.doubles && {
-        step: pre.doubles.step,
-        points: pre.doubles.points.map(endoMul)
-      }
-    };
-  }
-  return beta;
-};
-
-Point.prototype.toJSON = function toJSON() {
-  if (!this.precomputed)
-    return [ this.x, this.y ];
-
-  return [ this.x, this.y, this.precomputed && {
-    doubles: this.precomputed.doubles && {
-      step: this.precomputed.doubles.step,
-      points: this.precomputed.doubles.points.slice(1)
-    },
-    naf: this.precomputed.naf && {
-      wnd: this.precomputed.naf.wnd,
-      points: this.precomputed.naf.points.slice(1)
-    }
-  } ];
-};
-
-Point.fromJSON = function fromJSON(curve, obj, red) {
-  if (typeof obj === 'string')
-    obj = JSON.parse(obj);
-  var res = curve.point(obj[0], obj[1], red);
-  if (!obj[2])
-    return res;
-
-  function obj2point(obj) {
-    return curve.point(obj[0], obj[1], red);
-  }
-
-  var pre = obj[2];
-  res.precomputed = {
-    beta: null,
-    doubles: pre.doubles && {
-      step: pre.doubles.step,
-      points: [ res ].concat(pre.doubles.points.map(obj2point))
-    },
-    naf: pre.naf && {
-      wnd: pre.naf.wnd,
-      points: [ res ].concat(pre.naf.points.map(obj2point))
-    }
-  };
-  return res;
-};
-
-Point.prototype.inspect = function inspect() {
-  if (this.isInfinity())
-    return '<EC Point Infinity>';
-  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
-      ' y: ' + this.y.fromRed().toString(16, 2) + '>';
-};
-
-Point.prototype.isInfinity = function isInfinity() {
-  return this.inf;
-};
-
-Point.prototype.add = function add(p) {
-  // O + P = P
-  if (this.inf)
-    return p;
-
-  // P + O = P
-  if (p.inf)
-    return this;
-
-  // P + P = 2P
-  if (this.eq(p))
-    return this.dbl();
-
-  // P + (-P) = O
-  if (this.neg().eq(p))
-    return this.curve.point(null, null);
-
-  // P + Q = O
-  if (this.x.cmp(p.x) === 0)
-    return this.curve.point(null, null);
-
-  var c = this.y.redSub(p.y);
-  if (c.cmpn(0) !== 0)
-    c = c.redMul(this.x.redSub(p.x).redInvm());
-  var nx = c.redSqr().redISub(this.x).redISub(p.x);
-  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
-  return this.curve.point(nx, ny);
-};
-
-Point.prototype.dbl = function dbl() {
-  if (this.inf)
-    return this;
-
-  // 2P = O
-  var ys1 = this.y.redAdd(this.y);
-  if (ys1.cmpn(0) === 0)
-    return this.curve.point(null, null);
-
-  var a = this.curve.a;
-
-  var x2 = this.x.redSqr();
-  var dyinv = ys1.redInvm();
-  var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
-
-  var nx = c.redSqr().redISub(this.x.redAdd(this.x));
-  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
-  return this.curve.point(nx, ny);
-};
-
-Point.prototype.getX = function getX() {
-  return this.x.fromRed();
-};
-
-Point.prototype.getY = function getY() {
-  return this.y.fromRed();
-};
-
-Point.prototype.mul = function mul(k) {
-  k = new BN(k, 16);
-
-  if (this._hasDoubles(k))
-    return this.curve._fixedNafMul(this, k);
-  else if (this.curve.endo)
-    return this.curve._endoWnafMulAdd([ this ], [ k ]);
-  else
-    return this.curve._wnafMul(this, k);
-};
-
-Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
-  var points = [ this, p2 ];
-  var coeffs = [ k1, k2 ];
-  if (this.curve.endo)
-    return this.curve._endoWnafMulAdd(points, coeffs);
-  else
-    return this.curve._wnafMulAdd(1, points, coeffs, 2);
-};
-
-Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
-  var points = [ this, p2 ];
-  var coeffs = [ k1, k2 ];
-  if (this.curve.endo)
-    return this.curve._endoWnafMulAdd(points, coeffs, true);
-  else
-    return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
-};
-
-Point.prototype.eq = function eq(p) {
-  return this === p ||
-         this.inf === p.inf &&
-             (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
-};
-
-Point.prototype.neg = function neg(_precompute) {
-  if (this.inf)
-    return this;
-
-  var res = this.curve.point(this.x, this.y.redNeg());
-  if (_precompute && this.precomputed) {
-    var pre = this.precomputed;
-    var negate = function(p) {
-      return p.neg();
-    };
-    res.precomputed = {
-      naf: pre.naf && {
-        wnd: pre.naf.wnd,
-        points: pre.naf.points.map(negate)
-      },
-      doubles: pre.doubles && {
-        step: pre.doubles.step,
-        points: pre.doubles.points.map(negate)
-      }
-    };
-  }
-  return res;
-};
-
-Point.prototype.toJ = function toJ() {
-  if (this.inf)
-    return this.curve.jpoint(null, null, null);
-
-  var res = this.curve.jpoint(this.x, this.y, this.curve.one);
-  return res;
-};
-
-function JPoint(curve, x, y, z) {
-  Base.BasePoint.call(this, curve, 'jacobian');
-  if (x === null && y === null && z === null) {
-    this.x = this.curve.one;
-    this.y = this.curve.one;
-    this.z = new BN(0);
-  } else {
-    this.x = new BN(x, 16);
-    this.y = new BN(y, 16);
-    this.z = new BN(z, 16);
-  }
-  if (!this.x.red)
-    this.x = this.x.toRed(this.curve.red);
-  if (!this.y.red)
-    this.y = this.y.toRed(this.curve.red);
-  if (!this.z.red)
-    this.z = this.z.toRed(this.curve.red);
-
-  this.zOne = this.z === this.curve.one;
-}
-inherits(JPoint, Base.BasePoint);
-
-ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
-  return new JPoint(this, x, y, z);
-};
-
-JPoint.prototype.toP = function toP() {
-  if (this.isInfinity())
-    return this.curve.point(null, null);
-
-  var zinv = this.z.redInvm();
-  var zinv2 = zinv.redSqr();
-  var ax = this.x.redMul(zinv2);
-  var ay = this.y.redMul(zinv2).redMul(zinv);
-
-  return this.curve.point(ax, ay);
-};
-
-JPoint.prototype.neg = function neg() {
-  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
-};
-
-JPoint.prototype.add = function add(p) {
-  // O + P = P
-  if (this.isInfinity())
-    return p;
-
-  // P + O = P
-  if (p.isInfinity())
-    return this;
-
-  // 12M + 4S + 7A
-  var pz2 = p.z.redSqr();
-  var z2 = this.z.redSqr();
-  var u1 = this.x.redMul(pz2);
-  var u2 = p.x.redMul(z2);
-  var s1 = this.y.redMul(pz2.redMul(p.z));
-  var s2 = p.y.redMul(z2.redMul(this.z));
-
-  var h = u1.redSub(u2);
-  var r = s1.redSub(s2);
-  if (h.cmpn(0) === 0) {
-    if (r.cmpn(0) !== 0)
-      return this.curve.jpoint(null, null, null);
-    else
-      return this.dbl();
-  }
-
-  var h2 = h.redSqr();
-  var h3 = h2.redMul(h);
-  var v = u1.redMul(h2);
-
-  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
-  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
-  var nz = this.z.redMul(p.z).redMul(h);
-
-  return this.curve.jpoint(nx, ny, nz);
-};
-
-JPoint.prototype.mixedAdd = function mixedAdd(p) {
-  // O + P = P
-  if (this.isInfinity())
-    return p.toJ();
-
-  // P + O = P
-  if (p.isInfinity())
-    return this;
-
-  // 8M + 3S + 7A
-  var z2 = this.z.redSqr();
-  var u1 = this.x;
-  var u2 = p.x.redMul(z2);
-  var s1 = this.y;
-  var s2 = p.y.redMul(z2).redMul(this.z);
-
-  var h = u1.redSub(u2);
-  var r = s1.redSub(s2);
-  if (h.cmpn(0) === 0) {
-    if (r.cmpn(0) !== 0)
-      return this.curve.jpoint(null, null, null);
-    else
-      return this.dbl();
-  }
-
-  var h2 = h.redSqr();
-  var h3 = h2.redMul(h);
-  var v = u1.redMul(h2);
-
-  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
-  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
-  var nz = this.z.redMul(h);
-
-  return this.curve.jpoint(nx, ny, nz);
-};
-
-JPoint.prototype.dblp = function dblp(pow) {
-  if (pow === 0)
-    return this;
-  if (this.isInfinity())
-    return this;
-  if (!pow)
-    return this.dbl();
-
-  if (this.curve.zeroA || this.curve.threeA) {
-    var r = this;
-    for (var i = 0; i < pow; i++)
-      r = r.dbl();
-    return r;
-  }
-
-  // 1M + 2S + 1A + N * (4S + 5M + 8A)
-  // N = 1 => 6M + 6S + 9A
-  var a = this.curve.a;
-  var tinv = this.curve.tinv;
-
-  var jx = this.x;
-  var jy = this.y;
-  var jz = this.z;
-  var jz4 = jz.redSqr().redSqr();
-
-  // Reuse results
-  var jyd = jy.redAdd(jy);
-  for (var i = 0; i < pow; i++) {
-    var jx2 = jx.redSqr();
-    var jyd2 = jyd.redSqr();
-    var jyd4 = jyd2.redSqr();
-    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
-
-    var t1 = jx.redMul(jyd2);
-    var nx = c.redSqr().redISub(t1.redAdd(t1));
-    var t2 = t1.redISub(nx);
-    var dny = c.redMul(t2);
-    dny = dny.redIAdd(dny).redISub(jyd4);
-    var nz = jyd.redMul(jz);
-    if (i + 1 < pow)
-      jz4 = jz4.redMul(jyd4);
-
-    jx = nx;
-    jz = nz;
-    jyd = dny;
-  }
-
-  return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
-};
-
-JPoint.prototype.dbl = function dbl() {
-  if (this.isInfinity())
-    return this;
-
-  if (this.curve.zeroA)
-    return this._zeroDbl();
-  else if (this.curve.threeA)
-    return this._threeDbl();
-  else
-    return this._dbl();
-};
-
-JPoint.prototype._zeroDbl = function _zeroDbl() {
-  var nx;
-  var ny;
-  var nz;
-  // Z = 1
-  if (this.zOne) {
-    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
-    //     #doubling-mdbl-2007-bl
-    // 1M + 5S + 14A
-
-    // XX = X1^2
-    var xx = this.x.redSqr();
-    // YY = Y1^2
-    var yy = this.y.redSqr();
-    // YYYY = YY^2
-    var yyyy = yy.redSqr();
-    // S = 2 * ((X1 + YY)^2 - XX - YYYY)
-    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
-    s = s.redIAdd(s);
-    // M = 3 * XX + a; a = 0
-    var m = xx.redAdd(xx).redIAdd(xx);
-    // T = M ^ 2 - 2*S
-    var t = m.redSqr().redISub(s).redISub(s);
-
-    // 8 * YYYY
-    var yyyy8 = yyyy.redIAdd(yyyy);
-    yyyy8 = yyyy8.redIAdd(yyyy8);
-    yyyy8 = yyyy8.redIAdd(yyyy8);
-
-    // X3 = T
-    nx = t;
-    // Y3 = M * (S - T) - 8 * YYYY
-    ny = m.redMul(s.redISub(t)).redISub(yyyy8);
-    // Z3 = 2*Y1
-    nz = this.y.redAdd(this.y);
-  } else {
-    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
-    //     #doubling-dbl-2009-l
-    // 2M + 5S + 13A
-
-    // A = X1^2
-    var a = this.x.redSqr();
-    // B = Y1^2
-    var b = this.y.redSqr();
-    // C = B^2
-    var c = b.redSqr();
-    // D = 2 * ((X1 + B)^2 - A - C)
-    var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
-    d = d.redIAdd(d);
-    // E = 3 * A
-    var e = a.redAdd(a).redIAdd(a);
-    // F = E^2
-    var f = e.redSqr();
-
-    // 8 * C
-    var c8 = c.redIAdd(c);
-    c8 = c8.redIAdd(c8);
-    c8 = c8.redIAdd(c8);
-
-    // X3 = F - 2 * D
-    nx = f.redISub(d).redISub(d);
-    // Y3 = E * (D - X3) - 8 * C
-    ny = e.redMul(d.redISub(nx)).redISub(c8);
-    // Z3 = 2 * Y1 * Z1
-    nz = this.y.redMul(this.z);
-    nz = nz.redIAdd(nz);
-  }
-
-  return this.curve.jpoint(nx, ny, nz);
-};
-
-JPoint.prototype._threeDbl = function _threeDbl() {
-  var nx;
-  var ny;
-  var nz;
-  // Z = 1
-  if (this.zOne) {
-    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html
-    //     #doubling-mdbl-2007-bl
-    // 1M + 5S + 15A
-
-    // XX = X1^2
-    var xx = this.x.redSqr();
-    // YY = Y1^2
-    var yy = this.y.redSqr();
-    // YYYY = YY^2
-    var yyyy = yy.redSqr();
-    // S = 2 * ((X1 + YY)^2 - XX - YYYY)
-    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
-    s = s.redIAdd(s);
-    // M = 3 * XX + a
-    var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
-    // T = M^2 - 2 * S
-    var t = m.redSqr().redISub(s).redISub(s);
-    // X3 = T
-    nx = t;
-    // Y3 = M * (S - T) - 8 * YYYY
-    var yyyy8 = yyyy.redIAdd(yyyy);
-    yyyy8 = yyyy8.redIAdd(yyyy8);
-    yyyy8 = yyyy8.redIAdd(yyyy8);
-    ny = m.redMul(s.redISub(t)).redISub(yyyy8);
-    // Z3 = 2 * Y1
-    nz = this.y.redAdd(this.y);
-  } else {
-    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b
-    // 3M + 5S
-
-    // delta = Z1^2
-    var delta = this.z.redSqr();
-    // gamma = Y1^2
-    var gamma = this.y.redSqr();
-    // beta = X1 * gamma
-    var beta = this.x.redMul(gamma);
-    // alpha = 3 * (X1 - delta) * (X1 + delta)
-    var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
-    alpha = alpha.redAdd(alpha).redIAdd(alpha);
-    // X3 = alpha^2 - 8 * beta
-    var beta4 = beta.redIAdd(beta);
-    beta4 = beta4.redIAdd(beta4);
-    var beta8 = beta4.redAdd(beta4);
-    nx = alpha.redSqr().redISub(beta8);
-    // Z3 = (Y1 + Z1)^2 - gamma - delta
-    nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
-    // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2
-    var ggamma8 = gamma.redSqr();
-    ggamma8 = ggamma8.redIAdd(ggamma8);
-    ggamma8 = ggamma8.redIAdd(ggamma8);
-    ggamma8 = ggamma8.redIAdd(ggamma8);
-    ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
-  }
-
-  return this.curve.jpoint(nx, ny, nz);
-};
-
-JPoint.prototype._dbl = function _dbl() {
-  var a = this.curve.a;
-
-  // 4M + 6S + 10A
-  var jx = this.x;
-  var jy = this.y;
-  var jz = this.z;
-  var jz4 = jz.redSqr().redSqr();
-
-  var jx2 = jx.redSqr();
-  var jy2 = jy.redSqr();
-
-  var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
-
-  var jxd4 = jx.redAdd(jx);
-  jxd4 = jxd4.redIAdd(jxd4);
-  var t1 = jxd4.redMul(jy2);
-  var nx = c.redSqr().redISub(t1.redAdd(t1));
-  var t2 = t1.redISub(nx);
-
-  var jyd8 = jy2.redSqr();
-  jyd8 = jyd8.redIAdd(jyd8);
-  jyd8 = jyd8.redIAdd(jyd8);
-  jyd8 = jyd8.redIAdd(jyd8);
-  var ny = c.redMul(t2).redISub(jyd8);
-  var nz = jy.redAdd(jy).redMul(jz);
-
-  return this.curve.jpoint(nx, ny, nz);
-};
-
-JPoint.prototype.trpl = function trpl() {
-  if (!this.curve.zeroA)
-    return this.dbl().add(this);
-
-  // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl
-  // 5M + 10S + ...
-
-  // XX = X1^2
-  var xx = this.x.redSqr();
-  // YY = Y1^2
-  var yy = this.y.redSqr();
-  // ZZ = Z1^2
-  var zz = this.z.redSqr();
-  // YYYY = YY^2
-  var yyyy = yy.redSqr();
-  // M = 3 * XX + a * ZZ2; a = 0
-  var m = xx.redAdd(xx).redIAdd(xx);
-  // MM = M^2
-  var mm = m.redSqr();
-  // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM
-  var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
-  e = e.redIAdd(e);
-  e = e.redAdd(e).redIAdd(e);
-  e = e.redISub(mm);
-  // EE = E^2
-  var ee = e.redSqr();
-  // T = 16*YYYY
-  var t = yyyy.redIAdd(yyyy);
-  t = t.redIAdd(t);
-  t = t.redIAdd(t);
-  t = t.redIAdd(t);
-  // U = (M + E)^2 - MM - EE - T
-  var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
-  // X3 = 4 * (X1 * EE - 4 * YY * U)
-  var yyu4 = yy.redMul(u);
-  yyu4 = yyu4.redIAdd(yyu4);
-  yyu4 = yyu4.redIAdd(yyu4);
-  var nx = this.x.redMul(ee).redISub(yyu4);
-  nx = nx.redIAdd(nx);
-  nx = nx.redIAdd(nx);
-  // Y3 = 8 * Y1 * (U * (T - U) - E * EE)
-  var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
-  ny = ny.redIAdd(ny);
-  ny = ny.redIAdd(ny);
-  ny = ny.redIAdd(ny);
-  // Z3 = (Z1 + E)^2 - ZZ - EE
-  var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
-
-  return this.curve.jpoint(nx, ny, nz);
-};
-
-JPoint.prototype.mul = function mul(k, kbase) {
-  k = new BN(k, kbase);
-
-  return this.curve._wnafMul(this, k);
-};
-
-JPoint.prototype.eq = function eq(p) {
-  if (p.type === 'affine')
-    return this.eq(p.toJ());
-
-  if (this === p)
-    return true;
-
-  // x1 * z2^2 == x2 * z1^2
-  var z2 = this.z.redSqr();
-  var pz2 = p.z.redSqr();
-  if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)
-    return false;
-
-  // y1 * z2^3 == y2 * z1^3
-  var z3 = z2.redMul(this.z);
-  var pz3 = pz2.redMul(p.z);
-  return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
-};
-
-JPoint.prototype.eqXToP = function eqXToP(x) {
-  var zs = this.z.redSqr();
-  var rx = x.toRed(this.curve.red).redMul(zs);
-  if (this.x.cmp(rx) === 0)
-    return true;
-
-  var xc = x.clone();
-  var t = this.curve.redN.redMul(zs);
-  for (;;) {
-    xc.iadd(this.curve.n);
-    if (xc.cmp(this.curve.p) >= 0)
-      return false;
-
-    rx.redIAdd(t);
-    if (this.x.cmp(rx) === 0)
-      return true;
-  }
-  return false;
-};
-
-JPoint.prototype.inspect = function inspect() {
-  if (this.isInfinity())
-    return '<EC JPoint Infinity>';
-  return '<EC JPoint x: ' + this.x.toString(16, 2) +
-      ' y: ' + this.y.toString(16, 2) +
-      ' z: ' + this.z.toString(16, 2) + '>';
-};
-
-JPoint.prototype.isInfinity = function isInfinity() {
-  // XXX This code assumes that zero is always zero in red
-  return this.z.cmpn(0) === 0;
-};
-
-},{"../../elliptic":74,"../curve":77,"bn.js":24,"inherits":107}],80:[function(require,module,exports){
-'use strict';
-
-var curves = exports;
-
-var hash = require('hash.js');
-var elliptic = require('../elliptic');
-
-var assert = elliptic.utils.assert;
-
-function PresetCurve(options) {
-  if (options.type === 'short')
-    this.curve = new elliptic.curve.short(options);
-  else if (options.type === 'edwards')
-    this.curve = new elliptic.curve.edwards(options);
-  else
-    this.curve = new elliptic.curve.mont(options);
-  this.g = this.curve.g;
-  this.n = this.curve.n;
-  this.hash = options.hash;
-
-  assert(this.g.validate(), 'Invalid curve');
-  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');
-}
-curves.PresetCurve = PresetCurve;
-
-function defineCurve(name, options) {
-  Object.defineProperty(curves, name, {
-    configurable: true,
-    enumerable: true,
-    get: function() {
-      var curve = new PresetCurve(options);
-      Object.defineProperty(curves, name, {
-        configurable: true,
-        enumerable: true,
-        value: curve
-      });
-      return curve;
-    }
-  });
-}
-
-defineCurve('p192', {
-  type: 'short',
-  prime: 'p192',
-  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',
-  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',
-  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',
-  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',
-  hash: hash.sha256,
-  gRed: false,
-  g: [
-    '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',
-    '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811'
-  ]
-});
-
-defineCurve('p224', {
-  type: 'short',
-  prime: 'p224',
-  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',
-  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',
-  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',
-  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',
-  hash: hash.sha256,
-  gRed: false,
-  g: [
-    'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',
-    'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34'
-  ]
-});
-
-defineCurve('p256', {
-  type: 'short',
-  prime: null,
-  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',
-  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',
-  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',
-  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',
-  hash: hash.sha256,
-  gRed: false,
-  g: [
-    '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',
-    '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5'
-  ]
-});
-
-defineCurve('p384', {
-  type: 'short',
-  prime: null,
-  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
-     'fffffffe ffffffff 00000000 00000000 ffffffff',
-  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
-     'fffffffe ffffffff 00000000 00000000 fffffffc',
-  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +
-     '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',
-  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +
-     'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',
-  hash: hash.sha384,
-  gRed: false,
-  g: [
-    'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +
-    '5502f25d bf55296c 3a545e38 72760ab7',
-    '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +
-    '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f'
-  ]
-});
-
-defineCurve('p521', {
-  type: 'short',
-  prime: null,
-  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
-     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
-     'ffffffff ffffffff ffffffff ffffffff ffffffff',
-  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
-     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
-     'ffffffff ffffffff ffffffff ffffffff fffffffc',
-  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +
-     '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +
-     '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',
-  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
-     'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +
-     'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',
-  hash: hash.sha512,
-  gRed: false,
-  g: [
-    '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +
-    '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +
-    'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',
-    '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +
-    '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +
-    '3fad0761 353c7086 a272c240 88be9476 9fd16650'
-  ]
-});
-
-defineCurve('curve25519', {
-  type: 'mont',
-  prime: 'p25519',
-  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
-  a: '76d06',
-  b: '1',
-  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
-  hash: hash.sha256,
-  gRed: false,
-  g: [
-    '9'
-  ]
-});
-
-defineCurve('ed25519', {
-  type: 'edwards',
-  prime: 'p25519',
-  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
-  a: '-1',
-  c: '1',
-  // -121665 * (121666^(-1)) (mod P)
-  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',
-  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
-  hash: hash.sha256,
-  gRed: false,
-  g: [
-    '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',
-
-    // 4/5
-    '6666666666666666666666666666666666666666666666666666666666666658'
-  ]
-});
-
-var pre;
-try {
-  pre = require('./precomputed/secp256k1');
-} catch (e) {
-  pre = undefined;
-}
-
-defineCurve('secp256k1', {
-  type: 'short',
-  prime: 'k256',
-  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',
-  a: '0',
-  b: '7',
-  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',
-  h: '1',
-  hash: hash.sha256,
-
-  // Precomputed endomorphism
-  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',
-  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
-  basis: [
-    {
-      a: '3086d221a7d46bcde86c90e49284eb15',
-      b: '-e4437ed6010e88286f547fa90abfe4c3'
-    },
-    {
-      a: '114ca50f7a8e2f3f657c1108d9d44cfd8',
-      b: '3086d221a7d46bcde86c90e49284eb15'
-    }
-  ],
-
-  gRed: false,
-  g: [
-    '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
-    '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
-    pre
-  ]
-});
-
-},{"../elliptic":74,"./precomputed/secp256k1":87,"hash.js":93}],81:[function(require,module,exports){
-'use strict';
-
-var BN = require('bn.js');
-var HmacDRBG = require('hmac-drbg');
-var elliptic = require('../../elliptic');
-var utils = elliptic.utils;
-var assert = utils.assert;
-
-var KeyPair = require('./key');
-var Signature = require('./signature');
-
-function EC(options) {
-  if (!(this instanceof EC))
-    return new EC(options);
-
-  // Shortcut `elliptic.ec(curve-name)`
-  if (typeof options === 'string') {
-    assert(elliptic.curves.hasOwnProperty(options), 'Unknown curve ' + options);
-
-    options = elliptic.curves[options];
-  }
-
-  // Shortcut for `elliptic.ec(elliptic.curves.curveName)`
-  if (options instanceof elliptic.curves.PresetCurve)
-    options = { curve: options };
-
-  this.curve = options.curve.curve;
-  this.n = this.curve.n;
-  this.nh = this.n.ushrn(1);
-  this.g = this.curve.g;
-
-  // Point on curve
-  this.g = options.curve.g;
-  this.g.precompute(options.curve.n.bitLength() + 1);
-
-  // Hash for function for DRBG
-  this.hash = options.hash || options.curve.hash;
-}
-module.exports = EC;
-
-EC.prototype.keyPair = function keyPair(options) {
-  return new KeyPair(this, options);
-};
-
-EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
-  return KeyPair.fromPrivate(this, priv, enc);
-};
-
-EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
-  return KeyPair.fromPublic(this, pub, enc);
-};
-
-EC.prototype.genKeyPair = function genKeyPair(options) {
-  if (!options)
-    options = {};
-
-  // Instantiate Hmac_DRBG
-  var drbg = new HmacDRBG({
-    hash: this.hash,
-    pers: options.pers,
-    persEnc: options.persEnc || 'utf8',
-    entropy: options.entropy || elliptic.rand(this.hash.hmacStrength),
-    entropyEnc: options.entropy && options.entropyEnc || 'utf8',
-    nonce: this.n.toArray()
-  });
-
-  var bytes = this.n.byteLength();
-  var ns2 = this.n.sub(new BN(2));
-  do {
-    var priv = new BN(drbg.generate(bytes));
-    if (priv.cmp(ns2) > 0)
-      continue;
-
-    priv.iaddn(1);
-    return this.keyFromPrivate(priv);
-  } while (true);
-};
-
-EC.prototype._truncateToN = function truncateToN(msg, truncOnly) {
-  var delta = msg.byteLength() * 8 - this.n.bitLength();
-  if (delta > 0)
-    msg = msg.ushrn(delta);
-  if (!truncOnly && msg.cmp(this.n) >= 0)
-    return msg.sub(this.n);
-  else
-    return msg;
-};
-
-EC.prototype.sign = function sign(msg, key, enc, options) {
-  if (typeof enc === 'object') {
-    options = enc;
-    enc = null;
-  }
-  if (!options)
-    options = {};
-
-  key = this.keyFromPrivate(key, enc);
-  msg = this._truncateToN(new BN(msg, 16));
-
-  // Zero-extend key to provide enough entropy
-  var bytes = this.n.byteLength();
-  var bkey = key.getPrivate().toArray('be', bytes);
-
-  // Zero-extend nonce to have the same byte size as N
-  var nonce = msg.toArray('be', bytes);
-
-  // Instantiate Hmac_DRBG
-  var drbg = new HmacDRBG({
-    hash: this.hash,
-    entropy: bkey,
-    nonce: nonce,
-    pers: options.pers,
-    persEnc: options.persEnc || 'utf8'
-  });
-
-  // Number of bytes to generate
-  var ns1 = this.n.sub(new BN(1));
-
-  for (var iter = 0; true; iter++) {
-    var k = options.k ?
-        options.k(iter) :
-        new BN(drbg.generate(this.n.byteLength()));
-    k = this._truncateToN(k, true);
-    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)
-      continue;
-
-    var kp = this.g.mul(k);
-    if (kp.isInfinity())
-      continue;
-
-    var kpX = kp.getX();
-    var r = kpX.umod(this.n);
-    if (r.cmpn(0) === 0)
-      continue;
-
-    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
-    s = s.umod(this.n);
-    if (s.cmpn(0) === 0)
-      continue;
-
-    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |
-                        (kpX.cmp(r) !== 0 ? 2 : 0);
-
-    // Use complement of `s`, if it is > `n / 2`
-    if (options.canonical && s.cmp(this.nh) > 0) {
-      s = this.n.sub(s);
-      recoveryParam ^= 1;
-    }
-
-    return new Signature({ r: r, s: s, recoveryParam: recoveryParam });
-  }
-};
-
-EC.prototype.verify = function verify(msg, signature, key, enc) {
-  msg = this._truncateToN(new BN(msg, 16));
-  key = this.keyFromPublic(key, enc);
-  signature = new Signature(signature, 'hex');
-
-  // Perform primitive values validation
-  var r = signature.r;
-  var s = signature.s;
-  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)
-    return false;
-  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)
-    return false;
-
-  // Validate signature
-  var sinv = s.invm(this.n);
-  var u1 = sinv.mul(msg).umod(this.n);
-  var u2 = sinv.mul(r).umod(this.n);
-
-  if (!this.curve._maxwellTrick) {
-    var p = this.g.mulAdd(u1, key.getPublic(), u2);
-    if (p.isInfinity())
-      return false;
-
-    return p.getX().umod(this.n).cmp(r) === 0;
-  }
-
-  // NOTE: Greg Maxwell's trick, inspired by:
-  // https://git.io/vad3K
-
-  var p = this.g.jmulAdd(u1, key.getPublic(), u2);
-  if (p.isInfinity())
-    return false;
-
-  // Compare `p.x` of Jacobian point with `r`,
-  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the
-  // inverse of `p.z^2`
-  return p.eqXToP(r);
-};
-
-EC.prototype.recoverPubKey = function(msg, signature, j, enc) {
-  assert((3 & j) === j, 'The recovery param is more than two bits');
-  signature = new Signature(signature, enc);
-
-  var n = this.n;
-  var e = new BN(msg);
-  var r = signature.r;
-  var s = signature.s;
-
-  // A set LSB signifies that the y-coordinate is odd
-  var isYOdd = j & 1;
-  var isSecondKey = j >> 1;
-  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)
-    throw new Error('Unable to find sencond key candinate');
-
-  // 1.1. Let x = r + jn.
-  if (isSecondKey)
-    r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);
-  else
-    r = this.curve.pointFromX(r, isYOdd);
-
-  var rInv = signature.r.invm(n);
-  var s1 = n.sub(e).mul(rInv).umod(n);
-  var s2 = s.mul(rInv).umod(n);
-
-  // 1.6.1 Compute Q = r^-1 (sR -  eG)
-  //               Q = r^-1 (sR + -eG)
-  return this.g.mulAdd(s1, r, s2);
-};
-
-EC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {
-  signature = new Signature(signature, enc);
-  if (signature.recoveryParam !== null)
-    return signature.recoveryParam;
-
-  for (var i = 0; i < 4; i++) {
-    var Qprime;
-    try {
-      Qprime = this.recoverPubKey(e, signature, i);
-    } catch (e) {
-      continue;
-    }
-
-    if (Qprime.eq(Q))
-      return i;
-  }
-  throw new Error('Unable to find valid recovery factor');
-};
-
-},{"../../elliptic":74,"./key":82,"./signature":83,"bn.js":24,"hmac-drbg":105}],82:[function(require,module,exports){
-'use strict';
-
-var BN = require('bn.js');
-var elliptic = require('../../elliptic');
-var utils = elliptic.utils;
-var assert = utils.assert;
-
-function KeyPair(ec, options) {
-  this.ec = ec;
-  this.priv = null;
-  this.pub = null;
-
-  // KeyPair(ec, { priv: ..., pub: ... })
-  if (options.priv)
-    this._importPrivate(options.priv, options.privEnc);
-  if (options.pub)
-    this._importPublic(options.pub, options.pubEnc);
-}
-module.exports = KeyPair;
-
-KeyPair.fromPublic = function fromPublic(ec, pub, enc) {
-  if (pub instanceof KeyPair)
-    return pub;
-
-  return new KeyPair(ec, {
-    pub: pub,
-    pubEnc: enc
-  });
-};
-
-KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {
-  if (priv instanceof KeyPair)
-    return priv;
-
-  return new KeyPair(ec, {
-    priv: priv,
-    privEnc: enc
-  });
-};
-
-KeyPair.prototype.validate = function validate() {
-  var pub = this.getPublic();
-
-  if (pub.isInfinity())
-    return { result: false, reason: 'Invalid public key' };
-  if (!pub.validate())
-    return { result: false, reason: 'Public key is not a point' };
-  if (!pub.mul(this.ec.curve.n).isInfinity())
-    return { result: false, reason: 'Public key * N != O' };
-
-  return { result: true, reason: null };
-};
-
-KeyPair.prototype.getPublic = function getPublic(compact, enc) {
-  // compact is optional argument
-  if (typeof compact === 'string') {
-    enc = compact;
-    compact = null;
-  }
-
-  if (!this.pub)
-    this.pub = this.ec.g.mul(this.priv);
-
-  if (!enc)
-    return this.pub;
-
-  return this.pub.encode(enc, compact);
-};
-
-KeyPair.prototype.getPrivate = function getPrivate(enc) {
-  if (enc === 'hex')
-    return this.priv.toString(16, 2);
-  else
-    return this.priv;
-};
-
-KeyPair.prototype._importPrivate = function _importPrivate(key, enc) {
-  this.priv = new BN(key, enc || 16);
-
-  // Ensure that the priv won't be bigger than n, otherwise we may fail
-  // in fixed multiplication method
-  this.priv = this.priv.umod(this.ec.curve.n);
-};
-
-KeyPair.prototype._importPublic = function _importPublic(key, enc) {
-  if (key.x || key.y) {
-    // Montgomery points only have an `x` coordinate.
-    // Weierstrass/Edwards points on the other hand have both `x` and
-    // `y` coordinates.
-    if (this.ec.curve.type === 'mont') {
-      assert(key.x, 'Need x coordinate');
-    } else if (this.ec.curve.type === 'short' ||
-               this.ec.curve.type === 'edwards') {
-      assert(key.x && key.y, 'Need both x and y coordinate');
-    }
-    this.pub = this.ec.curve.point(key.x, key.y);
-    return;
-  }
-  this.pub = this.ec.curve.decodePoint(key, enc);
-};
-
-// ECDH
-KeyPair.prototype.derive = function derive(pub) {
-  return pub.mul(this.priv).getX();
-};
-
-// ECDSA
-KeyPair.prototype.sign = function sign(msg, enc, options) {
-  return this.ec.sign(msg, this, enc, options);
-};
-
-KeyPair.prototype.verify = function verify(msg, signature) {
-  return this.ec.verify(msg, signature, this);
-};
-
-KeyPair.prototype.inspect = function inspect() {
-  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +
-         ' pub: ' + (this.pub && this.pub.inspect()) + ' >';
-};
-
-},{"../../elliptic":74,"bn.js":24}],83:[function(require,module,exports){
-'use strict';
-
-var BN = require('bn.js');
-
-var elliptic = require('../../elliptic');
-var utils = elliptic.utils;
-var assert = utils.assert;
-
-function Signature(options, enc) {
-  if (options instanceof Signature)
-    return options;
-
-  if (this._importDER(options, enc))
-    return;
-
-  assert(options.r && options.s, 'Signature without r or s');
-  this.r = new BN(options.r, 16);
-  this.s = new BN(options.s, 16);
-  if (options.recoveryParam === undefined)
-    this.recoveryParam = null;
-  else
-    this.recoveryParam = options.recoveryParam;
-}
-module.exports = Signature;
-
-function Position() {
-  this.place = 0;
-}
-
-function getLength(buf, p) {
-  var initial = buf[p.place++];
-  if (!(initial & 0x80)) {
-    return initial;
-  }
-  var octetLen = initial & 0xf;
-  var val = 0;
-  for (var i = 0, off = p.place; i < octetLen; i++, off++) {
-    val <<= 8;
-    val |= buf[off];
-  }
-  p.place = off;
-  return val;
-}
-
-function rmPadding(buf) {
-  var i = 0;
-  var len = buf.length - 1;
-  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {
-    i++;
-  }
-  if (i === 0) {
-    return buf;
-  }
-  return buf.slice(i);
-}
-
-Signature.prototype._importDER = function _importDER(data, enc) {
-  data = utils.toArray(data, enc);
-  var p = new Position();
-  if (data[p.place++] !== 0x30) {
-    return false;
-  }
-  var len = getLength(data, p);
-  if ((len + p.place) !== data.length) {
-    return false;
-  }
-  if (data[p.place++] !== 0x02) {
-    return false;
-  }
-  var rlen = getLength(data, p);
-  var r = data.slice(p.place, rlen + p.place);
-  p.place += rlen;
-  if (data[p.place++] !== 0x02) {
-    return false;
-  }
-  var slen = getLength(data, p);
-  if (data.length !== slen + p.place) {
-    return false;
-  }
-  var s = data.slice(p.place, slen + p.place);
-  if (r[0] === 0 && (r[1] & 0x80)) {
-    r = r.slice(1);
-  }
-  if (s[0] === 0 && (s[1] & 0x80)) {
-    s = s.slice(1);
-  }
-
-  this.r = new BN(r);
-  this.s = new BN(s);
-  this.recoveryParam = null;
-
-  return true;
-};
-
-function constructLength(arr, len) {
-  if (len < 0x80) {
-    arr.push(len);
-    return;
-  }
-  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
-  arr.push(octets | 0x80);
-  while (--octets) {
-    arr.push((len >>> (octets << 3)) & 0xff);
-  }
-  arr.push(len);
-}
-
-Signature.prototype.toDER = function toDER(enc) {
-  var r = this.r.toArray();
-  var s = this.s.toArray();
-
-  // Pad values
-  if (r[0] & 0x80)
-    r = [ 0 ].concat(r);
-  // Pad values
-  if (s[0] & 0x80)
-    s = [ 0 ].concat(s);
-
-  r = rmPadding(r);
-  s = rmPadding(s);
-
-  while (!s[0] && !(s[1] & 0x80)) {
-    s = s.slice(1);
-  }
-  var arr = [ 0x02 ];
-  constructLength(arr, r.length);
-  arr = arr.concat(r);
-  arr.push(0x02);
-  constructLength(arr, s.length);
-  var backHalf = arr.concat(s);
-  var res = [ 0x30 ];
-  constructLength(res, backHalf.length);
-  res = res.concat(backHalf);
-  return utils.encode(res, enc);
-};
-
-},{"../../elliptic":74,"bn.js":24}],84:[function(require,module,exports){
-'use strict';
-
-var hash = require('hash.js');
-var elliptic = require('../../elliptic');
-var utils = elliptic.utils;
-var assert = utils.assert;
-var parseBytes = utils.parseBytes;
-var KeyPair = require('./key');
-var Signature = require('./signature');
-
-function EDDSA(curve) {
-  assert(curve === 'ed25519', 'only tested with ed25519 so far');
-
-  if (!(this instanceof EDDSA))
-    return new EDDSA(curve);
-
-  var curve = elliptic.curves[curve].curve;
-  this.curve = curve;
-  this.g = curve.g;
-  this.g.precompute(curve.n.bitLength() + 1);
-
-  this.pointClass = curve.point().constructor;
-  this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
-  this.hash = hash.sha512;
-}
-
-module.exports = EDDSA;
-
-/**
-* @param {Array|String} message - message bytes
-* @param {Array|String|KeyPair} secret - secret bytes or a keypair
-* @returns {Signature} - signature
-*/
-EDDSA.prototype.sign = function sign(message, secret) {
-  message = parseBytes(message);
-  var key = this.keyFromSecret(secret);
-  var r = this.hashInt(key.messagePrefix(), message);
-  var R = this.g.mul(r);
-  var Rencoded = this.encodePoint(R);
-  var s_ = this.hashInt(Rencoded, key.pubBytes(), message)
-               .mul(key.priv());
-  var S = r.add(s_).umod(this.curve.n);
-  return this.makeSignature({ R: R, S: S, Rencoded: Rencoded });
-};
-
-/**
-* @param {Array} message - message bytes
-* @param {Array|String|Signature} sig - sig bytes
-* @param {Array|String|Point|KeyPair} pub - public key
-* @returns {Boolean} - true if public key matches sig of message
-*/
-EDDSA.prototype.verify = function verify(message, sig, pub) {
-  message = parseBytes(message);
-  sig = this.makeSignature(sig);
-  var key = this.keyFromPublic(pub);
-  var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);
-  var SG = this.g.mul(sig.S());
-  var RplusAh = sig.R().add(key.pub().mul(h));
-  return RplusAh.eq(SG);
-};
-
-EDDSA.prototype.hashInt = function hashInt() {
-  var hash = this.hash();
-  for (var i = 0; i < arguments.length; i++)
-    hash.update(arguments[i]);
-  return utils.intFromLE(hash.digest()).umod(this.curve.n);
-};
-
-EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
-  return KeyPair.fromPublic(this, pub);
-};
-
-EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
-  return KeyPair.fromSecret(this, secret);
-};
-
-EDDSA.prototype.makeSignature = function makeSignature(sig) {
-  if (sig instanceof Signature)
-    return sig;
-  return new Signature(this, sig);
-};
-
-/**
-* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2
-*
-* EDDSA defines methods for encoding and decoding points and integers. These are
-* helper convenience methods, that pass along to utility functions implied
-* parameters.
-*
-*/
-EDDSA.prototype.encodePoint = function encodePoint(point) {
-  var enc = point.getY().toArray('le', this.encodingLength);
-  enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;
-  return enc;
-};
-
-EDDSA.prototype.decodePoint = function decodePoint(bytes) {
-  bytes = utils.parseBytes(bytes);
-
-  var lastIx = bytes.length - 1;
-  var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);
-  var xIsOdd = (bytes[lastIx] & 0x80) !== 0;
-
-  var y = utils.intFromLE(normed);
-  return this.curve.pointFromY(y, xIsOdd);
-};
-
-EDDSA.prototype.encodeInt = function encodeInt(num) {
-  return num.toArray('le', this.encodingLength);
-};
-
-EDDSA.prototype.decodeInt = function decodeInt(bytes) {
-  return utils.intFromLE(bytes);
-};
-
-EDDSA.prototype.isPoint = function isPoint(val) {
-  return val instanceof this.pointClass;
-};
-
-},{"../../elliptic":74,"./key":85,"./signature":86,"hash.js":93}],85:[function(require,module,exports){
-'use strict';
-
-var elliptic = require('../../elliptic');
-var utils = elliptic.utils;
-var assert = utils.assert;
-var parseBytes = utils.parseBytes;
-var cachedProperty = utils.cachedProperty;
-
-/**
-* @param {EDDSA} eddsa - instance
-* @param {Object} params - public/private key parameters
-*
-* @param {Array<Byte>} [params.secret] - secret seed bytes
-* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)
-* @param {Array<Byte>} [params.pub] - public key point encoded as bytes
-*
-*/
-function KeyPair(eddsa, params) {
-  this.eddsa = eddsa;
-  this._secret = parseBytes(params.secret);
-  if (eddsa.isPoint(params.pub))
-    this._pub = params.pub;
-  else
-    this._pubBytes = parseBytes(params.pub);
-}
-
-KeyPair.fromPublic = function fromPublic(eddsa, pub) {
-  if (pub instanceof KeyPair)
-    return pub;
-  return new KeyPair(eddsa, { pub: pub });
-};
-
-KeyPair.fromSecret = function fromSecret(eddsa, secret) {
-  if (secret instanceof KeyPair)
-    return secret;
-  return new KeyPair(eddsa, { secret: secret });
-};
-
-KeyPair.prototype.secret = function secret() {
-  return this._secret;
-};
-
-cachedProperty(KeyPair, 'pubBytes', function pubBytes() {
-  return this.eddsa.encodePoint(this.pub());
-});
-
-cachedProperty(KeyPair, 'pub', function pub() {
-  if (this._pubBytes)
-    return this.eddsa.decodePoint(this._pubBytes);
-  return this.eddsa.g.mul(this.priv());
-});
-
-cachedProperty(KeyPair, 'privBytes', function privBytes() {
-  var eddsa = this.eddsa;
-  var hash = this.hash();
-  var lastIx = eddsa.encodingLength - 1;
-
-  var a = hash.slice(0, eddsa.encodingLength);
-  a[0] &= 248;
-  a[lastIx] &= 127;
-  a[lastIx] |= 64;
-
-  return a;
-});
-
-cachedProperty(KeyPair, 'priv', function priv() {
-  return this.eddsa.decodeInt(this.privBytes());
-});
-
-cachedProperty(KeyPair, 'hash', function hash() {
-  return this.eddsa.hash().update(this.secret()).digest();
-});
-
-cachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {
-  return this.hash().slice(this.eddsa.encodingLength);
-});
-
-KeyPair.prototype.sign = function sign(message) {
-  assert(this._secret, 'KeyPair can only verify');
-  return this.eddsa.sign(message, this);
-};
-
-KeyPair.prototype.verify = function verify(message, sig) {
-  return this.eddsa.verify(message, sig, this);
-};
-
-KeyPair.prototype.getSecret = function getSecret(enc) {
-  assert(this._secret, 'KeyPair is public only');
-  return utils.encode(this.secret(), enc);
-};
-
-KeyPair.prototype.getPublic = function getPublic(enc) {
-  return utils.encode(this.pubBytes(), enc);
-};
-
-module.exports = KeyPair;
-
-},{"../../elliptic":74}],86:[function(require,module,exports){
-'use strict';
-
-var BN = require('bn.js');
-var elliptic = require('../../elliptic');
-var utils = elliptic.utils;
-var assert = utils.assert;
-var cachedProperty = utils.cachedProperty;
-var parseBytes = utils.parseBytes;
-
-/**
-* @param {EDDSA} eddsa - eddsa instance
-* @param {Array<Bytes>|Object} sig -
-* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes
-* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes
-* @param {Array<Bytes>} [sig.Rencoded] - R point encoded
-* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded
-*/
-function Signature(eddsa, sig) {
-  this.eddsa = eddsa;
-
-  if (typeof sig !== 'object')
-    sig = parseBytes(sig);
-
-  if (Array.isArray(sig)) {
-    sig = {
-      R: sig.slice(0, eddsa.encodingLength),
-      S: sig.slice(eddsa.encodingLength)
-    };
-  }
-
-  assert(sig.R && sig.S, 'Signature without R or S');
-
-  if (eddsa.isPoint(sig.R))
-    this._R = sig.R;
-  if (sig.S instanceof BN)
-    this._S = sig.S;
-
-  this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
-  this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
-}
-
-cachedProperty(Signature, 'S', function S() {
-  return this.eddsa.decodeInt(this.Sencoded());
-});
-
-cachedProperty(Signature, 'R', function R() {
-  return this.eddsa.decodePoint(this.Rencoded());
-});
-
-cachedProperty(Signature, 'Rencoded', function Rencoded() {
-  return this.eddsa.encodePoint(this.R());
-});
-
-cachedProperty(Signature, 'Sencoded', function Sencoded() {
-  return this.eddsa.encodeInt(this.S());
-});
-
-Signature.prototype.toBytes = function toBytes() {
-  return this.Rencoded().concat(this.Sencoded());
-};
-
-Signature.prototype.toHex = function toHex() {
-  return utils.encode(this.toBytes(), 'hex').toUpperCase();
-};
-
-module.exports = Signature;
-
-},{"../../elliptic":74,"bn.js":24}],87:[function(require,module,exports){
-module.exports = {
-  doubles: {
-    step: 4,
-    points: [
-      [
-        'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a',
-        'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821'
-      ],
-      [
-        '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508',
-        '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf'
-      ],
-      [
-        '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739',
-        'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695'
-      ],
-      [
-        '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640',
-        '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9'
-      ],
-      [
-        '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c',
-        '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36'
-      ],
-      [
-        '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda',
-        '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f'
-      ],
-      [
-        'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa',
-        '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999'
-      ],
-      [
-        '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0',
-        'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09'
-      ],
-      [
-        'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d',
-        '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d'
-      ],
-      [
-        'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d',
-        'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088'
-      ],
-      [
-        'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1',
-        '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d'
-      ],
-      [
-        '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0',
-        '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8'
-      ],
-      [
-        '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047',
-        '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a'
-      ],
-      [
-        '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862',
-        '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453'
-      ],
-      [
-        '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7',
-        '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160'
-      ],
-      [
-        '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd',
-        '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0'
-      ],
-      [
-        '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83',
-        '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6'
-      ],
-      [
-        '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a',
-        '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589'
-      ],
-      [
-        '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8',
-        'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17'
-      ],
-      [
-        'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d',
-        '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda'
-      ],
-      [
-        'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725',
-        '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd'
-      ],
-      [
-        '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754',
-        '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2'
-      ],
-      [
-        '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c',
-        '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6'
-      ],
-      [
-        'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6',
-        '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f'
-      ],
-      [
-        '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39',
-        'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01'
-      ],
-      [
-        'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891',
-        '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3'
-      ],
-      [
-        'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b',
-        'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f'
-      ],
-      [
-        'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03',
-        '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7'
-      ],
-      [
-        'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d',
-        'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78'
-      ],
-      [
-        'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070',
-        '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1'
-      ],
-      [
-        '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4',
-        'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150'
-      ],
-      [
-        '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da',
-        '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82'
-      ],
-      [
-        'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11',
-        '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc'
-      ],
-      [
-        '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e',
-        'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b'
-      ],
-      [
-        'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41',
-        '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51'
-      ],
-      [
-        'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef',
-        '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45'
-      ],
-      [
-        'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8',
-        'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120'
-      ],
-      [
-        '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d',
-        '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84'
-      ],
-      [
-        '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96',
-        '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d'
-      ],
-      [
-        '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd',
-        'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d'
-      ],
-      [
-        '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5',
-        '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8'
-      ],
-      [
-        'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266',
-        '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8'
-      ],
-      [
-        '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71',
-        '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac'
-      ],
-      [
-        '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac',
-        'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f'
-      ],
-      [
-        '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751',
-        '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962'
-      ],
-      [
-        'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e',
-        '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907'
-      ],
-      [
-        '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241',
-        'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec'
-      ],
-      [
-        'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3',
-        'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d'
-      ],
-      [
-        'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f',
-        '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414'
-      ],
-      [
-        '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19',
-        'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd'
-      ],
-      [
-        '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be',
-        'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0'
-      ],
-      [
-        'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9',
-        '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811'
-      ],
-      [
-        'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2',
-        '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1'
-      ],
-      [
-        'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13',
-        '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c'
-      ],
-      [
-        '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c',
-        'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73'
-      ],
-      [
-        '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba',
-        '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd'
-      ],
-      [
-        'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151',
-        'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405'
-      ],
-      [
-        '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073',
-        'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589'
-      ],
-      [
-        '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458',
-        '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e'
-      ],
-      [
-        '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b',
-        '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27'
-      ],
-      [
-        'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366',
-        'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1'
-      ],
-      [
-        '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa',
-        '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482'
-      ],
-      [
-        '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0',
-        '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945'
-      ],
-      [
-        'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787',
-        '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573'
-      ],
-      [
-        'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e',
-        'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82'
-      ]
-    ]
-  },
-  naf: {
-    wnd: 7,
-    points: [
-      [
-        'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',
-        '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672'
-      ],
-      [
-        '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4',
-        'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6'
-      ],
-      [
-        '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc',
-        '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da'
-      ],
-      [
-        'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe',
-        'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37'
-      ],
-      [
-        '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb',
-        'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b'
-      ],
-      [
-        'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8',
-        'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81'
-      ],
-      [
-        'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e',
-        '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58'
-      ],
-      [
-        'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34',
-        '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77'
-      ],
-      [
-        '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c',
-        '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a'
-      ],
-      [
-        '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5',
-        '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c'
-      ],
-      [
-        '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f',
-        '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67'
-      ],
-      [
-        '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714',
-        '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402'
-      ],
-      [
-        'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729',
-        'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55'
-      ],
-      [
-        'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db',
-        '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482'
-      ],
-      [
-        '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4',
-        'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82'
-      ],
-      [
-        '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5',
-        'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396'
-      ],
-      [
-        '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479',
-        '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49'
-      ],
-      [
-        '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d',
-        '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf'
-      ],
-      [
-        '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f',
-        '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a'
-      ],
-      [
-        '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb',
-        'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7'
-      ],
-      [
-        'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9',
-        'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933'
-      ],
-      [
-        '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963',
-        '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a'
-      ],
-      [
-        '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74',
-        '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6'
-      ],
-      [
-        'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530',
-        'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37'
-      ],
-      [
-        '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b',
-        '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e'
-      ],
-      [
-        'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247',
-        'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6'
-      ],
-      [
-        'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1',
-        'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476'
-      ],
-      [
-        '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120',
-        '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40'
-      ],
-      [
-        '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435',
-        '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61'
-      ],
-      [
-        '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18',
-        '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683'
-      ],
-      [
-        'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8',
-        '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5'
-      ],
-      [
-        '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb',
-        '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b'
-      ],
-      [
-        'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f',
-        '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417'
-      ],
-      [
-        '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143',
-        'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868'
-      ],
-      [
-        '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba',
-        'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a'
-      ],
-      [
-        'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45',
-        'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6'
-      ],
-      [
-        '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a',
-        '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996'
-      ],
-      [
-        '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e',
-        'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e'
-      ],
-      [
-        'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8',
-        'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d'
-      ],
-      [
-        '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c',
-        '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2'
-      ],
-      [
-        '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519',
-        'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e'
-      ],
-      [
-        '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab',
-        '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437'
-      ],
-      [
-        '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca',
-        'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311'
-      ],
-      [
-        'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf',
-        '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4'
-      ],
-      [
-        '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610',
-        '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575'
-      ],
-      [
-        '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4',
-        'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d'
-      ],
-      [
-        '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c',
-        'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d'
-      ],
-      [
-        'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940',
-        'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629'
-      ],
-      [
-        'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980',
-        'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06'
-      ],
-      [
-        '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3',
-        '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374'
-      ],
-      [
-        '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf',
-        '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee'
-      ],
-      [
-        'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63',
-        '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1'
-      ],
-      [
-        'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448',
-        'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b'
-      ],
-      [
-        '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf',
-        '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661'
-      ],
-      [
-        '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5',
-        '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6'
-      ],
-      [
-        'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6',
-        '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e'
-      ],
-      [
-        '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5',
-        '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d'
-      ],
-      [
-        'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99',
-        'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc'
-      ],
-      [
-        '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51',
-        'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4'
-      ],
-      [
-        '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5',
-        '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c'
-      ],
-      [
-        'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5',
-        '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b'
-      ],
-      [
-        'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997',
-        '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913'
-      ],
-      [
-        '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881',
-        '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154'
-      ],
-      [
-        '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5',
-        '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865'
-      ],
-      [
-        '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66',
-        'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc'
-      ],
-      [
-        '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726',
-        'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224'
-      ],
-      [
-        '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede',
-        '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e'
-      ],
-      [
-        '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94',
-        '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6'
-      ],
-      [
-        '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31',
-        '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511'
-      ],
-      [
-        '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51',
-        'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b'
-      ],
-      [
-        'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252',
-        'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2'
-      ],
-      [
-        '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5',
-        'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c'
-      ],
-      [
-        'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b',
-        '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3'
-      ],
-      [
-        'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4',
-        '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d'
-      ],
-      [
-        'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f',
-        '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700'
-      ],
-      [
-        'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889',
-        '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4'
-      ],
-      [
-        '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246',
-        'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196'
-      ],
-      [
-        '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984',
-        '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4'
-      ],
-      [
-        '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a',
-        'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257'
-      ],
-      [
-        'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030',
-        'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13'
-      ],
-      [
-        'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197',
-        '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096'
-      ],
-      [
-        'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593',
-        'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38'
-      ],
-      [
-        'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef',
-        '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f'
-      ],
-      [
-        '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38',
-        '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448'
-      ],
-      [
-        'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a',
-        '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a'
-      ],
-      [
-        'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111',
-        '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4'
-      ],
-      [
-        '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502',
-        '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437'
-      ],
-      [
-        '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea',
-        'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7'
-      ],
-      [
-        'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26',
-        '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d'
-      ],
-      [
-        'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986',
-        '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a'
-      ],
-      [
-        'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e',
-        '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54'
-      ],
-      [
-        '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4',
-        '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77'
-      ],
-      [
-        'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda',
-        'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517'
-      ],
-      [
-        '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859',
-        'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10'
-      ],
-      [
-        'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f',
-        'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125'
-      ],
-      [
-        'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c',
-        '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e'
-      ],
-      [
-        '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942',
-        'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1'
-      ],
-      [
-        'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a',
-        '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2'
-      ],
-      [
-        'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80',
-        '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423'
-      ],
-      [
-        'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d',
-        '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8'
-      ],
-      [
-        '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1',
-        'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758'
-      ],
-      [
-        '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63',
-        'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375'
-      ],
-      [
-        'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352',
-        '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d'
-      ],
-      [
-        '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193',
-        'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec'
-      ],
-      [
-        '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00',
-        '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0'
-      ],
-      [
-        '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58',
-        'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c'
-      ],
-      [
-        'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7',
-        'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4'
-      ],
-      [
-        '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8',
-        'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f'
-      ],
-      [
-        '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e',
-        '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649'
-      ],
-      [
-        '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d',
-        'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826'
-      ],
-      [
-        '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b',
-        '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5'
-      ],
-      [
-        'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f',
-        'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87'
-      ],
-      [
-        '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6',
-        '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b'
-      ],
-      [
-        'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297',
-        '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc'
-      ],
-      [
-        '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a',
-        '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c'
-      ],
-      [
-        'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c',
-        'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f'
-      ],
-      [
-        'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52',
-        '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a'
-      ],
-      [
-        'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb',
-        'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46'
-      ],
-      [
-        '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065',
-        'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f'
-      ],
-      [
-        '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917',
-        '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03'
-      ],
-      [
-        '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9',
-        'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08'
-      ],
-      [
-        '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3',
-        '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8'
-      ],
-      [
-        '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57',
-        '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373'
-      ],
-      [
-        '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66',
-        'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3'
-      ],
-      [
-        '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8',
-        '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8'
-      ],
-      [
-        '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721',
-        '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1'
-      ],
-      [
-        '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180',
-        '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9'
-      ]
-    ]
-  }
-};
-
-},{}],88:[function(require,module,exports){
-'use strict';
-
-var utils = exports;
-var BN = require('bn.js');
-var minAssert = require('minimalistic-assert');
-var minUtils = require('minimalistic-crypto-utils');
-
-utils.assert = minAssert;
-utils.toArray = minUtils.toArray;
-utils.zero2 = minUtils.zero2;
-utils.toHex = minUtils.toHex;
-utils.encode = minUtils.encode;
-
-// Represent num in a w-NAF form
-function getNAF(num, w) {
-  var naf = [];
-  var ws = 1 << (w + 1);
-  var k = num.clone();
-  while (k.cmpn(1) >= 0) {
-    var z;
-    if (k.isOdd()) {
-      var mod = k.andln(ws - 1);
-      if (mod > (ws >> 1) - 1)
-        z = (ws >> 1) - mod;
-      else
-        z = mod;
-      k.isubn(z);
-    } else {
-      z = 0;
-    }
-    naf.push(z);
-
-    // Optimization, shift by word if possible
-    var shift = (k.cmpn(0) !== 0 && k.andln(ws - 1) === 0) ? (w + 1) : 1;
-    for (var i = 1; i < shift; i++)
-      naf.push(0);
-    k.iushrn(shift);
-  }
-
-  return naf;
-}
-utils.getNAF = getNAF;
-
-// Represent k1, k2 in a Joint Sparse Form
-function getJSF(k1, k2) {
-  var jsf = [
-    [],
-    []
-  ];
-
-  k1 = k1.clone();
-  k2 = k2.clone();
-  var d1 = 0;
-  var d2 = 0;
-  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
-
-    // First phase
-    var m14 = (k1.andln(3) + d1) & 3;
-    var m24 = (k2.andln(3) + d2) & 3;
-    if (m14 === 3)
-      m14 = -1;
-    if (m24 === 3)
-      m24 = -1;
-    var u1;
-    if ((m14 & 1) === 0) {
-      u1 = 0;
-    } else {
-      var m8 = (k1.andln(7) + d1) & 7;
-      if ((m8 === 3 || m8 === 5) && m24 === 2)
-        u1 = -m14;
-      else
-        u1 = m14;
-    }
-    jsf[0].push(u1);
-
-    var u2;
-    if ((m24 & 1) === 0) {
-      u2 = 0;
-    } else {
-      var m8 = (k2.andln(7) + d2) & 7;
-      if ((m8 === 3 || m8 === 5) && m14 === 2)
-        u2 = -m24;
-      else
-        u2 = m24;
-    }
-    jsf[1].push(u2);
-
-    // Second phase
-    if (2 * d1 === u1 + 1)
-      d1 = 1 - d1;
-    if (2 * d2 === u2 + 1)
-      d2 = 1 - d2;
-    k1.iushrn(1);
-    k2.iushrn(1);
-  }
-
-  return jsf;
-}
-utils.getJSF = getJSF;
-
-function cachedProperty(obj, name, computer) {
-  var key = '_' + name;
-  obj.prototype[name] = function cachedProperty() {
-    return this[key] !== undefined ? this[key] :
-           this[key] = computer.call(this);
-  };
-}
-utils.cachedProperty = cachedProperty;
-
-function parseBytes(bytes) {
-  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :
-                                     bytes;
-}
-utils.parseBytes = parseBytes;
-
-function intFromLE(bytes) {
-  return new BN(bytes, 'hex', 'le');
-}
-utils.intFromLE = intFromLE;
-
-
-},{"bn.js":24,"minimalistic-assert":112,"minimalistic-crypto-utils":113}],89:[function(require,module,exports){
-module.exports={
-  "_from": "elliptic@^6.0.0",
-  "_id": "elliptic@6.4.0",
-  "_inBundle": false,
-  "_integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=",
-  "_location": "/browserify/elliptic",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "elliptic@^6.0.0",
-    "name": "elliptic",
-    "escapedName": "elliptic",
-    "rawSpec": "^6.0.0",
-    "saveSpec": null,
-    "fetchSpec": "^6.0.0"
-  },
-  "_requiredBy": [
-    "/browserify/browserify-sign",
-    "/browserify/create-ecdh"
-  ],
-  "_resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz",
-  "_shasum": "cac9af8762c85836187003c8dfe193e5e2eae5df",
-  "_spec": "elliptic@^6.0.0",
-  "_where": "/usr/local/lib/node_modules/browserify/node_modules/browserify-sign",
-  "author": {
-    "name": "Fedor Indutny",
-    "email": "fedor@indutny.com"
-  },
-  "bugs": {
-    "url": "https://github.com/indutny/elliptic/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "bn.js": "^4.4.0",
-    "brorand": "^1.0.1",
-    "hash.js": "^1.0.0",
-    "hmac-drbg": "^1.0.0",
-    "inherits": "^2.0.1",
-    "minimalistic-assert": "^1.0.0",
-    "minimalistic-crypto-utils": "^1.0.0"
-  },
-  "deprecated": false,
-  "description": "EC cryptography",
-  "devDependencies": {
-    "brfs": "^1.4.3",
-    "coveralls": "^2.11.3",
-    "grunt": "^0.4.5",
-    "grunt-browserify": "^5.0.0",
-    "grunt-cli": "^1.2.0",
-    "grunt-contrib-connect": "^1.0.0",
-    "grunt-contrib-copy": "^1.0.0",
-    "grunt-contrib-uglify": "^1.0.1",
-    "grunt-mocha-istanbul": "^3.0.1",
-    "grunt-saucelabs": "^8.6.2",
-    "istanbul": "^0.4.2",
-    "jscs": "^2.9.0",
-    "jshint": "^2.6.0",
-    "mocha": "^2.1.0"
-  },
-  "files": [
-    "lib"
-  ],
-  "homepage": "https://github.com/indutny/elliptic",
-  "keywords": [
-    "EC",
-    "Elliptic",
-    "curve",
-    "Cryptography"
-  ],
-  "license": "MIT",
-  "main": "lib/elliptic.js",
-  "name": "elliptic",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/indutny/elliptic.git"
-  },
-  "scripts": {
-    "jscs": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js",
-    "jshint": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js",
-    "lint": "npm run jscs && npm run jshint",
-    "test": "npm run lint && npm run unit",
-    "unit": "istanbul test _mocha --reporter=spec test/index.js",
-    "version": "grunt dist && git add dist/"
-  },
-  "version": "6.4.0"
-}
-
-},{}],90:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-var objectCreate = Object.create || objectCreatePolyfill
-var objectKeys = Object.keys || objectKeysPolyfill
-var bind = Function.prototype.bind || functionBindPolyfill
-
-function EventEmitter() {
-  if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
-    this._events = objectCreate(null);
-    this._eventsCount = 0;
-  }
-
-  this._maxListeners = this._maxListeners || undefined;
-}
-module.exports = EventEmitter;
-
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
-
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._maxListeners = undefined;
-
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-var defaultMaxListeners = 10;
-
-var hasDefineProperty;
-try {
-  var o = {};
-  if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
-  hasDefineProperty = o.x === 0;
-} catch (err) { hasDefineProperty = false }
-if (hasDefineProperty) {
-  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
-    enumerable: true,
-    get: function() {
-      return defaultMaxListeners;
-    },
-    set: function(arg) {
-      // check whether the input is a positive number (whose value is zero or
-      // greater and not a NaN).
-      if (typeof arg !== 'number' || arg < 0 || arg !== arg)
-        throw new TypeError('"defaultMaxListeners" must be a positive number');
-      defaultMaxListeners = arg;
-    }
-  });
-} else {
-  EventEmitter.defaultMaxListeners = defaultMaxListeners;
-}
-
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || isNaN(n))
-    throw new TypeError('"n" argument must be a positive number');
-  this._maxListeners = n;
-  return this;
-};
-
-function $getMaxListeners(that) {
-  if (that._maxListeners === undefined)
-    return EventEmitter.defaultMaxListeners;
-  return that._maxListeners;
-}
-
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-  return $getMaxListeners(this);
-};
-
-// These standalone emit* functions are used to optimize calling of event
-// handlers for fast cases because emit() itself often has a variable number of
-// arguments and can be deoptimized because of that. These functions always have
-// the same number of arguments and thus do not get deoptimized, so the code
-// inside them can execute faster.
-function emitNone(handler, isFn, self) {
-  if (isFn)
-    handler.call(self);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self);
-  }
-}
-function emitOne(handler, isFn, self, arg1) {
-  if (isFn)
-    handler.call(self, arg1);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1);
-  }
-}
-function emitTwo(handler, isFn, self, arg1, arg2) {
-  if (isFn)
-    handler.call(self, arg1, arg2);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1, arg2);
-  }
-}
-function emitThree(handler, isFn, self, arg1, arg2, arg3) {
-  if (isFn)
-    handler.call(self, arg1, arg2, arg3);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1, arg2, arg3);
-  }
-}
-
-function emitMany(handler, isFn, self, args) {
-  if (isFn)
-    handler.apply(self, args);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].apply(self, args);
-  }
-}
-
-EventEmitter.prototype.emit = function emit(type) {
-  var er, handler, len, args, i, events;
-  var doError = (type === 'error');
-
-  events = this._events;
-  if (events)
-    doError = (doError && events.error == null);
-  else if (!doError)
-    return false;
-
-  // If there is no 'error' event listener then throw.
-  if (doError) {
-    if (arguments.length > 1)
-      er = arguments[1];
-    if (er instanceof Error) {
-      throw er; // Unhandled 'error' event
-    } else {
-      // At least give some kind of context to the user
-      var err = new Error('Unhandled "error" event. (' + er + ')');
-      err.context = er;
-      throw err;
-    }
-    return false;
-  }
-
-  handler = events[type];
-
-  if (!handler)
-    return false;
-
-  var isFn = typeof handler === 'function';
-  len = arguments.length;
-  switch (len) {
-      // fast cases
-    case 1:
-      emitNone(handler, isFn, this);
-      break;
-    case 2:
-      emitOne(handler, isFn, this, arguments[1]);
-      break;
-    case 3:
-      emitTwo(handler, isFn, this, arguments[1], arguments[2]);
-      break;
-    case 4:
-      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
-      break;
-      // slower
-    default:
-      args = new Array(len - 1);
-      for (i = 1; i < len; i++)
-        args[i - 1] = arguments[i];
-      emitMany(handler, isFn, this, args);
-  }
-
-  return true;
-};
-
-function _addListener(target, type, listener, prepend) {
-  var m;
-  var events;
-  var existing;
-
-  if (typeof listener !== 'function')
-    throw new TypeError('"listener" argument must be a function');
-
-  events = target._events;
-  if (!events) {
-    events = target._events = objectCreate(null);
-    target._eventsCount = 0;
-  } else {
-    // To avoid recursion in the case that type === "newListener"! Before
-    // adding it to the listeners, first emit "newListener".
-    if (events.newListener) {
-      target.emit('newListener', type,
-          listener.listener ? listener.listener : listener);
-
-      // Re-assign `events` because a newListener handler could have caused the
-      // this._events to be assigned to a new object
-      events = target._events;
-    }
-    existing = events[type];
-  }
-
-  if (!existing) {
-    // Optimize the case of one listener. Don't need the extra array object.
-    existing = events[type] = listener;
-    ++target._eventsCount;
-  } else {
-    if (typeof existing === 'function') {
-      // Adding the second element, need to change to array.
-      existing = events[type] =
-          prepend ? [listener, existing] : [existing, listener];
-    } else {
-      // If we've already got an array, just append.
-      if (prepend) {
-        existing.unshift(listener);
-      } else {
-        existing.push(listener);
-      }
-    }
-
-    // Check for listener leak
-    if (!existing.warned) {
-      m = $getMaxListeners(target);
-      if (m && m > 0 && existing.length > m) {
-        existing.warned = true;
-        var w = new Error('Possible EventEmitter memory leak detected. ' +
-            existing.length + ' "' + String(type) + '" listeners ' +
-            'added. Use emitter.setMaxListeners() to ' +
-            'increase limit.');
-        w.name = 'MaxListenersExceededWarning';
-        w.emitter = target;
-        w.type = type;
-        w.count = existing.length;
-        if (typeof console === 'object' && console.warn) {
-          console.warn('%s: %s', w.name, w.message);
-        }
-      }
-    }
-  }
-
-  return target;
-}
-
-EventEmitter.prototype.addListener = function addListener(type, listener) {
-  return _addListener(this, type, listener, false);
-};
-
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-EventEmitter.prototype.prependListener =
-    function prependListener(type, listener) {
-      return _addListener(this, type, listener, true);
-    };
-
-function onceWrapper() {
-  if (!this.fired) {
-    this.target.removeListener(this.type, this.wrapFn);
-    this.fired = true;
-    switch (arguments.length) {
-      case 0:
-        return this.listener.call(this.target);
-      case 1:
-        return this.listener.call(this.target, arguments[0]);
-      case 2:
-        return this.listener.call(this.target, arguments[0], arguments[1]);
-      case 3:
-        return this.listener.call(this.target, arguments[0], arguments[1],
-            arguments[2]);
-      default:
-        var args = new Array(arguments.length);
-        for (var i = 0; i < args.length; ++i)
-          args[i] = arguments[i];
-        this.listener.apply(this.target, args);
-    }
-  }
-}
-
-function _onceWrap(target, type, listener) {
-  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
-  var wrapped = bind.call(onceWrapper, state);
-  wrapped.listener = listener;
-  state.wrapFn = wrapped;
-  return wrapped;
-}
-
-EventEmitter.prototype.once = function once(type, listener) {
-  if (typeof listener !== 'function')
-    throw new TypeError('"listener" argument must be a function');
-  this.on(type, _onceWrap(this, type, listener));
-  return this;
-};
-
-EventEmitter.prototype.prependOnceListener =
-    function prependOnceListener(type, listener) {
-      if (typeof listener !== 'function')
-        throw new TypeError('"listener" argument must be a function');
-      this.prependListener(type, _onceWrap(this, type, listener));
-      return this;
-    };
-
-// Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
-    function removeListener(type, listener) {
-      var list, events, position, i, originalListener;
-
-      if (typeof listener !== 'function')
-        throw new TypeError('"listener" argument must be a function');
-
-      events = this._events;
-      if (!events)
-        return this;
-
-      list = events[type];
-      if (!list)
-        return this;
-
-      if (list === listener || list.listener === listener) {
-        if (--this._eventsCount === 0)
-          this._events = objectCreate(null);
-        else {
-          delete events[type];
-          if (events.removeListener)
-            this.emit('removeListener', type, list.listener || listener);
-        }
-      } else if (typeof list !== 'function') {
-        position = -1;
-
-        for (i = list.length - 1; i >= 0; i--) {
-          if (list[i] === listener || list[i].listener === listener) {
-            originalListener = list[i].listener;
-            position = i;
-            break;
-          }
-        }
-
-        if (position < 0)
-          return this;
-
-        if (position === 0)
-          list.shift();
-        else
-          spliceOne(list, position);
-
-        if (list.length === 1)
-          events[type] = list[0];
-
-        if (events.removeListener)
-          this.emit('removeListener', type, originalListener || listener);
-      }
-
-      return this;
-    };
-
-EventEmitter.prototype.removeAllListeners =
-    function removeAllListeners(type) {
-      var listeners, events, i;
-
-      events = this._events;
-      if (!events)
-        return this;
-
-      // not listening for removeListener, no need to emit
-      if (!events.removeListener) {
-        if (arguments.length === 0) {
-          this._events = objectCreate(null);
-          this._eventsCount = 0;
-        } else if (events[type]) {
-          if (--this._eventsCount === 0)
-            this._events = objectCreate(null);
-          else
-            delete events[type];
-        }
-        return this;
-      }
-
-      // emit removeListener for all listeners on all events
-      if (arguments.length === 0) {
-        var keys = objectKeys(events);
-        var key;
-        for (i = 0; i < keys.length; ++i) {
-          key = keys[i];
-          if (key === 'removeListener') continue;
-          this.removeAllListeners(key);
-        }
-        this.removeAllListeners('removeListener');
-        this._events = objectCreate(null);
-        this._eventsCount = 0;
-        return this;
-      }
-
-      listeners = events[type];
-
-      if (typeof listeners === 'function') {
-        this.removeListener(type, listeners);
-      } else if (listeners) {
-        // LIFO order
-        for (i = listeners.length - 1; i >= 0; i--) {
-          this.removeListener(type, listeners[i]);
-        }
-      }
-
-      return this;
-    };
-
-function _listeners(target, type, unwrap) {
-  var events = target._events;
-
-  if (!events)
-    return [];
-
-  var evlistener = events[type];
-  if (!evlistener)
-    return [];
-
-  if (typeof evlistener === 'function')
-    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
-
-  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-}
-
-EventEmitter.prototype.listeners = function listeners(type) {
-  return _listeners(this, type, true);
-};
-
-EventEmitter.prototype.rawListeners = function rawListeners(type) {
-  return _listeners(this, type, false);
-};
-
-EventEmitter.listenerCount = function(emitter, type) {
-  if (typeof emitter.listenerCount === 'function') {
-    return emitter.listenerCount(type);
-  } else {
-    return listenerCount.call(emitter, type);
-  }
-};
-
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
-  var events = this._events;
-
-  if (events) {
-    var evlistener = events[type];
-
-    if (typeof evlistener === 'function') {
-      return 1;
-    } else if (evlistener) {
-      return evlistener.length;
-    }
-  }
-
-  return 0;
-}
-
-EventEmitter.prototype.eventNames = function eventNames() {
-  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
-};
-
-// About 1.5x faster than the two-arg version of Array#splice().
-function spliceOne(list, index) {
-  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
-    list[i] = list[k];
-  list.pop();
-}
-
-function arrayClone(arr, n) {
-  var copy = new Array(n);
-  for (var i = 0; i < n; ++i)
-    copy[i] = arr[i];
-  return copy;
-}
-
-function unwrapListeners(arr) {
-  var ret = new Array(arr.length);
-  for (var i = 0; i < ret.length; ++i) {
-    ret[i] = arr[i].listener || arr[i];
-  }
-  return ret;
-}
-
-function objectCreatePolyfill(proto) {
-  var F = function() {};
-  F.prototype = proto;
-  return new F;
-}
-function objectKeysPolyfill(obj) {
-  var keys = [];
-  for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
-    keys.push(k);
-  }
-  return k;
-}
-function functionBindPolyfill(context) {
-  var fn = this;
-  return function () {
-    return fn.apply(context, arguments);
-  };
-}
-
-},{}],91:[function(require,module,exports){
-var Buffer = require('safe-buffer').Buffer
-var MD5 = require('md5.js')
-
-/* eslint-disable camelcase */
-function EVP_BytesToKey (password, salt, keyBits, ivLen) {
-  if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary')
-  if (salt) {
-    if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary')
-    if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length')
-  }
-
-  var keyLen = keyBits / 8
-  var key = Buffer.alloc(keyLen)
-  var iv = Buffer.alloc(ivLen || 0)
-  var tmp = Buffer.alloc(0)
-
-  while (keyLen > 0 || ivLen > 0) {
-    var hash = new MD5()
-    hash.update(tmp)
-    hash.update(password)
-    if (salt) hash.update(salt)
-    tmp = hash.digest()
-
-    var used = 0
-
-    if (keyLen > 0) {
-      var keyStart = key.length - keyLen
-      used = Math.min(keyLen, tmp.length)
-      tmp.copy(key, keyStart, 0, used)
-      keyLen -= used
-    }
-
-    if (used < tmp.length && ivLen > 0) {
-      var ivStart = iv.length - ivLen
-      var length = Math.min(ivLen, tmp.length - used)
-      tmp.copy(iv, ivStart, used, used + length)
-      ivLen -= length
-    }
-  }
-
-  tmp.fill(0)
-  return { key: key, iv: iv }
-}
-
-module.exports = EVP_BytesToKey
-
-},{"md5.js":110,"safe-buffer":148}],92:[function(require,module,exports){
-'use strict'
-var Buffer = require('safe-buffer').Buffer
-var Transform = require('stream').Transform
-var inherits = require('inherits')
-
-function throwIfNotStringOrBuffer (val, prefix) {
-  if (!Buffer.isBuffer(val) && typeof val !== 'string') {
-    throw new TypeError(prefix + ' must be a string or a buffer')
-  }
-}
-
-function HashBase (blockSize) {
-  Transform.call(this)
-
-  this._block = Buffer.allocUnsafe(blockSize)
-  this._blockSize = blockSize
-  this._blockOffset = 0
-  this._length = [0, 0, 0, 0]
-
-  this._finalized = false
-}
-
-inherits(HashBase, Transform)
-
-HashBase.prototype._transform = function (chunk, encoding, callback) {
-  var error = null
-  try {
-    this.update(chunk, encoding)
-  } catch (err) {
-    error = err
-  }
-
-  callback(error)
-}
-
-HashBase.prototype._flush = function (callback) {
-  var error = null
-  try {
-    this.push(this.digest())
-  } catch (err) {
-    error = err
-  }
-
-  callback(error)
-}
-
-HashBase.prototype.update = function (data, encoding) {
-  throwIfNotStringOrBuffer(data, 'Data')
-  if (this._finalized) throw new Error('Digest already called')
-  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)
-
-  // consume data
-  var block = this._block
-  var offset = 0
-  while (this._blockOffset + data.length - offset >= this._blockSize) {
-    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]
-    this._update()
-    this._blockOffset = 0
-  }
-  while (offset < data.length) block[this._blockOffset++] = data[offset++]
-
-  // update length
-  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
-    this._length[j] += carry
-    carry = (this._length[j] / 0x0100000000) | 0
-    if (carry > 0) this._length[j] -= 0x0100000000 * carry
-  }
-
-  return this
-}
-
-HashBase.prototype._update = function () {
-  throw new Error('_update is not implemented')
-}
-
-HashBase.prototype.digest = function (encoding) {
-  if (this._finalized) throw new Error('Digest already called')
-  this._finalized = true
-
-  var digest = this._digest()
-  if (encoding !== undefined) digest = digest.toString(encoding)
-
-  // reset state
-  this._block.fill(0)
-  this._blockOffset = 0
-  for (var i = 0; i < 4; ++i) this._length[i] = 0
-
-  return digest
-}
-
-HashBase.prototype._digest = function () {
-  throw new Error('_digest is not implemented')
-}
-
-module.exports = HashBase
-
-},{"inherits":107,"safe-buffer":148,"stream":157}],93:[function(require,module,exports){
-var hash = exports;
-
-hash.utils = require('./hash/utils');
-hash.common = require('./hash/common');
-hash.sha = require('./hash/sha');
-hash.ripemd = require('./hash/ripemd');
-hash.hmac = require('./hash/hmac');
-
-// Proxy hash functions to the main object
-hash.sha1 = hash.sha.sha1;
-hash.sha256 = hash.sha.sha256;
-hash.sha224 = hash.sha.sha224;
-hash.sha384 = hash.sha.sha384;
-hash.sha512 = hash.sha.sha512;
-hash.ripemd160 = hash.ripemd.ripemd160;
-
-},{"./hash/common":94,"./hash/hmac":95,"./hash/ripemd":96,"./hash/sha":97,"./hash/utils":104}],94:[function(require,module,exports){
-'use strict';
-
-var utils = require('./utils');
-var assert = require('minimalistic-assert');
-
-function BlockHash() {
-  this.pending = null;
-  this.pendingTotal = 0;
-  this.blockSize = this.constructor.blockSize;
-  this.outSize = this.constructor.outSize;
-  this.hmacStrength = this.constructor.hmacStrength;
-  this.padLength = this.constructor.padLength / 8;
-  this.endian = 'big';
-
-  this._delta8 = this.blockSize / 8;
-  this._delta32 = this.blockSize / 32;
-}
-exports.BlockHash = BlockHash;
-
-BlockHash.prototype.update = function update(msg, enc) {
-  // Convert message to array, pad it, and join into 32bit blocks
-  msg = utils.toArray(msg, enc);
-  if (!this.pending)
-    this.pending = msg;
-  else
-    this.pending = this.pending.concat(msg);
-  this.pendingTotal += msg.length;
-
-  // Enough data, try updating
-  if (this.pending.length >= this._delta8) {
-    msg = this.pending;
-
-    // Process pending data in blocks
-    var r = msg.length % this._delta8;
-    this.pending = msg.slice(msg.length - r, msg.length);
-    if (this.pending.length === 0)
-      this.pending = null;
-
-    msg = utils.join32(msg, 0, msg.length - r, this.endian);
-    for (var i = 0; i < msg.length; i += this._delta32)
-      this._update(msg, i, i + this._delta32);
-  }
-
-  return this;
-};
-
-BlockHash.prototype.digest = function digest(enc) {
-  this.update(this._pad());
-  assert(this.pending === null);
-
-  return this._digest(enc);
-};
-
-BlockHash.prototype._pad = function pad() {
-  var len = this.pendingTotal;
-  var bytes = this._delta8;
-  var k = bytes - ((len + this.padLength) % bytes);
-  var res = new Array(k + this.padLength);
-  res[0] = 0x80;
-  for (var i = 1; i < k; i++)
-    res[i] = 0;
-
-  // Append length
-  len <<= 3;
-  if (this.endian === 'big') {
-    for (var t = 8; t < this.padLength; t++)
-      res[i++] = 0;
-
-    res[i++] = 0;
-    res[i++] = 0;
-    res[i++] = 0;
-    res[i++] = 0;
-    res[i++] = (len >>> 24) & 0xff;
-    res[i++] = (len >>> 16) & 0xff;
-    res[i++] = (len >>> 8) & 0xff;
-    res[i++] = len & 0xff;
-  } else {
-    res[i++] = len & 0xff;
-    res[i++] = (len >>> 8) & 0xff;
-    res[i++] = (len >>> 16) & 0xff;
-    res[i++] = (len >>> 24) & 0xff;
-    res[i++] = 0;
-    res[i++] = 0;
-    res[i++] = 0;
-    res[i++] = 0;
-
-    for (t = 8; t < this.padLength; t++)
-      res[i++] = 0;
-  }
-
-  return res;
-};
-
-},{"./utils":104,"minimalistic-assert":112}],95:[function(require,module,exports){
-'use strict';
-
-var utils = require('./utils');
-var assert = require('minimalistic-assert');
-
-function Hmac(hash, key, enc) {
-  if (!(this instanceof Hmac))
-    return new Hmac(hash, key, enc);
-  this.Hash = hash;
-  this.blockSize = hash.blockSize / 8;
-  this.outSize = hash.outSize / 8;
-  this.inner = null;
-  this.outer = null;
-
-  this._init(utils.toArray(key, enc));
-}
-module.exports = Hmac;
-
-Hmac.prototype._init = function init(key) {
-  // Shorten key, if needed
-  if (key.length > this.blockSize)
-    key = new this.Hash().update(key).digest();
-  assert(key.length <= this.blockSize);
-
-  // Add padding to key
-  for (var i = key.length; i < this.blockSize; i++)
-    key.push(0);
-
-  for (i = 0; i < key.length; i++)
-    key[i] ^= 0x36;
-  this.inner = new this.Hash().update(key);
-
-  // 0x36 ^ 0x5c = 0x6a
-  for (i = 0; i < key.length; i++)
-    key[i] ^= 0x6a;
-  this.outer = new this.Hash().update(key);
-};
-
-Hmac.prototype.update = function update(msg, enc) {
-  this.inner.update(msg, enc);
-  return this;
-};
-
-Hmac.prototype.digest = function digest(enc) {
-  this.outer.update(this.inner.digest());
-  return this.outer.digest(enc);
-};
-
-},{"./utils":104,"minimalistic-assert":112}],96:[function(require,module,exports){
-'use strict';
-
-var utils = require('./utils');
-var common = require('./common');
-
-var rotl32 = utils.rotl32;
-var sum32 = utils.sum32;
-var sum32_3 = utils.sum32_3;
-var sum32_4 = utils.sum32_4;
-var BlockHash = common.BlockHash;
-
-function RIPEMD160() {
-  if (!(this instanceof RIPEMD160))
-    return new RIPEMD160();
-
-  BlockHash.call(this);
-
-  this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];
-  this.endian = 'little';
-}
-utils.inherits(RIPEMD160, BlockHash);
-exports.ripemd160 = RIPEMD160;
-
-RIPEMD160.blockSize = 512;
-RIPEMD160.outSize = 160;
-RIPEMD160.hmacStrength = 192;
-RIPEMD160.padLength = 64;
-
-RIPEMD160.prototype._update = function update(msg, start) {
-  var A = this.h[0];
-  var B = this.h[1];
-  var C = this.h[2];
-  var D = this.h[3];
-  var E = this.h[4];
-  var Ah = A;
-  var Bh = B;
-  var Ch = C;
-  var Dh = D;
-  var Eh = E;
-  for (var j = 0; j < 80; j++) {
-    var T = sum32(
-      rotl32(
-        sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
-        s[j]),
-      E);
-    A = E;
-    E = D;
-    D = rotl32(C, 10);
-    C = B;
-    B = T;
-    T = sum32(
-      rotl32(
-        sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
-        sh[j]),
-      Eh);
-    Ah = Eh;
-    Eh = Dh;
-    Dh = rotl32(Ch, 10);
-    Ch = Bh;
-    Bh = T;
-  }
-  T = sum32_3(this.h[1], C, Dh);
-  this.h[1] = sum32_3(this.h[2], D, Eh);
-  this.h[2] = sum32_3(this.h[3], E, Ah);
-  this.h[3] = sum32_3(this.h[4], A, Bh);
-  this.h[4] = sum32_3(this.h[0], B, Ch);
-  this.h[0] = T;
-};
-
-RIPEMD160.prototype._digest = function digest(enc) {
-  if (enc === 'hex')
-    return utils.toHex32(this.h, 'little');
-  else
-    return utils.split32(this.h, 'little');
-};
-
-function f(j, x, y, z) {
-  if (j <= 15)
-    return x ^ y ^ z;
-  else if (j <= 31)
-    return (x & y) | ((~x) & z);
-  else if (j <= 47)
-    return (x | (~y)) ^ z;
-  else if (j <= 63)
-    return (x & z) | (y & (~z));
-  else
-    return x ^ (y | (~z));
-}
-
-function K(j) {
-  if (j <= 15)
-    return 0x00000000;
-  else if (j <= 31)
-    return 0x5a827999;
-  else if (j <= 47)
-    return 0x6ed9eba1;
-  else if (j <= 63)
-    return 0x8f1bbcdc;
-  else
-    return 0xa953fd4e;
-}
-
-function Kh(j) {
-  if (j <= 15)
-    return 0x50a28be6;
-  else if (j <= 31)
-    return 0x5c4dd124;
-  else if (j <= 47)
-    return 0x6d703ef3;
-  else if (j <= 63)
-    return 0x7a6d76e9;
-  else
-    return 0x00000000;
-}
-
-var r = [
-  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
-  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
-  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
-  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
-];
-
-var rh = [
-  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
-  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
-  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
-  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
-  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
-];
-
-var s = [
-  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
-  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
-  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
-  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
-  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
-];
-
-var sh = [
-  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
-  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
-  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
-  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
-  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
-];
-
-},{"./common":94,"./utils":104}],97:[function(require,module,exports){
-'use strict';
-
-exports.sha1 = require('./sha/1');
-exports.sha224 = require('./sha/224');
-exports.sha256 = require('./sha/256');
-exports.sha384 = require('./sha/384');
-exports.sha512 = require('./sha/512');
-
-},{"./sha/1":98,"./sha/224":99,"./sha/256":100,"./sha/384":101,"./sha/512":102}],98:[function(require,module,exports){
-'use strict';
-
-var utils = require('../utils');
-var common = require('../common');
-var shaCommon = require('./common');
-
-var rotl32 = utils.rotl32;
-var sum32 = utils.sum32;
-var sum32_5 = utils.sum32_5;
-var ft_1 = shaCommon.ft_1;
-var BlockHash = common.BlockHash;
-
-var sha1_K = [
-  0x5A827999, 0x6ED9EBA1,
-  0x8F1BBCDC, 0xCA62C1D6
-];
-
-function SHA1() {
-  if (!(this instanceof SHA1))
-    return new SHA1();
-
-  BlockHash.call(this);
-  this.h = [
-    0x67452301, 0xefcdab89, 0x98badcfe,
-    0x10325476, 0xc3d2e1f0 ];
-  this.W = new Array(80);
-}
-
-utils.inherits(SHA1, BlockHash);
-module.exports = SHA1;
-
-SHA1.blockSize = 512;
-SHA1.outSize = 160;
-SHA1.hmacStrength = 80;
-SHA1.padLength = 64;
-
-SHA1.prototype._update = function _update(msg, start) {
-  var W = this.W;
-
-  for (var i = 0; i < 16; i++)
-    W[i] = msg[start + i];
-
-  for(; i < W.length; i++)
-    W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
-
-  var a = this.h[0];
-  var b = this.h[1];
-  var c = this.h[2];
-  var d = this.h[3];
-  var e = this.h[4];
-
-  for (i = 0; i < W.length; i++) {
-    var s = ~~(i / 20);
-    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
-    e = d;
-    d = c;
-    c = rotl32(b, 30);
-    b = a;
-    a = t;
-  }
-
-  this.h[0] = sum32(this.h[0], a);
-  this.h[1] = sum32(this.h[1], b);
-  this.h[2] = sum32(this.h[2], c);
-  this.h[3] = sum32(this.h[3], d);
-  this.h[4] = sum32(this.h[4], e);
-};
-
-SHA1.prototype._digest = function digest(enc) {
-  if (enc === 'hex')
-    return utils.toHex32(this.h, 'big');
-  else
-    return utils.split32(this.h, 'big');
-};
-
-},{"../common":94,"../utils":104,"./common":103}],99:[function(require,module,exports){
-'use strict';
-
-var utils = require('../utils');
-var SHA256 = require('./256');
-
-function SHA224() {
-  if (!(this instanceof SHA224))
-    return new SHA224();
-
-  SHA256.call(this);
-  this.h = [
-    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
-    0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ];
-}
-utils.inherits(SHA224, SHA256);
-module.exports = SHA224;
-
-SHA224.blockSize = 512;
-SHA224.outSize = 224;
-SHA224.hmacStrength = 192;
-SHA224.padLength = 64;
-
-SHA224.prototype._digest = function digest(enc) {
-  // Just truncate output
-  if (enc === 'hex')
-    return utils.toHex32(this.h.slice(0, 7), 'big');
-  else
-    return utils.split32(this.h.slice(0, 7), 'big');
-};
-
-
-},{"../utils":104,"./256":100}],100:[function(require,module,exports){
-'use strict';
-
-var utils = require('../utils');
-var common = require('../common');
-var shaCommon = require('./common');
-var assert = require('minimalistic-assert');
-
-var sum32 = utils.sum32;
-var sum32_4 = utils.sum32_4;
-var sum32_5 = utils.sum32_5;
-var ch32 = shaCommon.ch32;
-var maj32 = shaCommon.maj32;
-var s0_256 = shaCommon.s0_256;
-var s1_256 = shaCommon.s1_256;
-var g0_256 = shaCommon.g0_256;
-var g1_256 = shaCommon.g1_256;
-
-var BlockHash = common.BlockHash;
-
-var sha256_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
-];
-
-function SHA256() {
-  if (!(this instanceof SHA256))
-    return new SHA256();
-
-  BlockHash.call(this);
-  this.h = [
-    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
-    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
-  ];
-  this.k = sha256_K;
-  this.W = new Array(64);
-}
-utils.inherits(SHA256, BlockHash);
-module.exports = SHA256;
-
-SHA256.blockSize = 512;
-SHA256.outSize = 256;
-SHA256.hmacStrength = 192;
-SHA256.padLength = 64;
-
-SHA256.prototype._update = function _update(msg, start) {
-  var W = this.W;
-
-  for (var i = 0; i < 16; i++)
-    W[i] = msg[start + i];
-  for (; i < W.length; i++)
-    W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
-
-  var a = this.h[0];
-  var b = this.h[1];
-  var c = this.h[2];
-  var d = this.h[3];
-  var e = this.h[4];
-  var f = this.h[5];
-  var g = this.h[6];
-  var h = this.h[7];
-
-  assert(this.k.length === W.length);
-  for (i = 0; i < W.length; i++) {
-    var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
-    var T2 = sum32(s0_256(a), maj32(a, b, c));
-    h = g;
-    g = f;
-    f = e;
-    e = sum32(d, T1);
-    d = c;
-    c = b;
-    b = a;
-    a = sum32(T1, T2);
-  }
-
-  this.h[0] = sum32(this.h[0], a);
-  this.h[1] = sum32(this.h[1], b);
-  this.h[2] = sum32(this.h[2], c);
-  this.h[3] = sum32(this.h[3], d);
-  this.h[4] = sum32(this.h[4], e);
-  this.h[5] = sum32(this.h[5], f);
-  this.h[6] = sum32(this.h[6], g);
-  this.h[7] = sum32(this.h[7], h);
-};
-
-SHA256.prototype._digest = function digest(enc) {
-  if (enc === 'hex')
-    return utils.toHex32(this.h, 'big');
-  else
-    return utils.split32(this.h, 'big');
-};
-
-},{"../common":94,"../utils":104,"./common":103,"minimalistic-assert":112}],101:[function(require,module,exports){
-'use strict';
-
-var utils = require('../utils');
-
-var SHA512 = require('./512');
-
-function SHA384() {
-  if (!(this instanceof SHA384))
-    return new SHA384();
-
-  SHA512.call(this);
-  this.h = [
-    0xcbbb9d5d, 0xc1059ed8,
-    0x629a292a, 0x367cd507,
-    0x9159015a, 0x3070dd17,
-    0x152fecd8, 0xf70e5939,
-    0x67332667, 0xffc00b31,
-    0x8eb44a87, 0x68581511,
-    0xdb0c2e0d, 0x64f98fa7,
-    0x47b5481d, 0xbefa4fa4 ];
-}
-utils.inherits(SHA384, SHA512);
-module.exports = SHA384;
-
-SHA384.blockSize = 1024;
-SHA384.outSize = 384;
-SHA384.hmacStrength = 192;
-SHA384.padLength = 128;
-
-SHA384.prototype._digest = function digest(enc) {
-  if (enc === 'hex')
-    return utils.toHex32(this.h.slice(0, 12), 'big');
-  else
-    return utils.split32(this.h.slice(0, 12), 'big');
-};
-
-},{"../utils":104,"./512":102}],102:[function(require,module,exports){
-'use strict';
-
-var utils = require('../utils');
-var common = require('../common');
-var assert = require('minimalistic-assert');
-
-var rotr64_hi = utils.rotr64_hi;
-var rotr64_lo = utils.rotr64_lo;
-var shr64_hi = utils.shr64_hi;
-var shr64_lo = utils.shr64_lo;
-var sum64 = utils.sum64;
-var sum64_hi = utils.sum64_hi;
-var sum64_lo = utils.sum64_lo;
-var sum64_4_hi = utils.sum64_4_hi;
-var sum64_4_lo = utils.sum64_4_lo;
-var sum64_5_hi = utils.sum64_5_hi;
-var sum64_5_lo = utils.sum64_5_lo;
-
-var BlockHash = common.BlockHash;
-
-var sha512_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 SHA512() {
-  if (!(this instanceof SHA512))
-    return new SHA512();
-
-  BlockHash.call(this);
-  this.h = [
-    0x6a09e667, 0xf3bcc908,
-    0xbb67ae85, 0x84caa73b,
-    0x3c6ef372, 0xfe94f82b,
-    0xa54ff53a, 0x5f1d36f1,
-    0x510e527f, 0xade682d1,
-    0x9b05688c, 0x2b3e6c1f,
-    0x1f83d9ab, 0xfb41bd6b,
-    0x5be0cd19, 0x137e2179 ];
-  this.k = sha512_K;
-  this.W = new Array(160);
-}
-utils.inherits(SHA512, BlockHash);
-module.exports = SHA512;
-
-SHA512.blockSize = 1024;
-SHA512.outSize = 512;
-SHA512.hmacStrength = 192;
-SHA512.padLength = 128;
-
-SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
-  var W = this.W;
-
-  // 32 x 32bit words
-  for (var i = 0; i < 32; i++)
-    W[i] = msg[start + i];
-  for (; i < W.length; i += 2) {
-    var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);  // i - 2
-    var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
-    var c1_hi = W[i - 14];  // i - 7
-    var c1_lo = W[i - 13];
-    var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);  // i - 15
-    var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
-    var c3_hi = W[i - 32];  // i - 16
-    var c3_lo = W[i - 31];
-
-    W[i] = sum64_4_hi(
-      c0_hi, c0_lo,
-      c1_hi, c1_lo,
-      c2_hi, c2_lo,
-      c3_hi, c3_lo);
-    W[i + 1] = sum64_4_lo(
-      c0_hi, c0_lo,
-      c1_hi, c1_lo,
-      c2_hi, c2_lo,
-      c3_hi, c3_lo);
-  }
-};
-
-SHA512.prototype._update = function _update(msg, start) {
-  this._prepareBlock(msg, start);
-
-  var W = this.W;
-
-  var ah = this.h[0];
-  var al = this.h[1];
-  var bh = this.h[2];
-  var bl = this.h[3];
-  var ch = this.h[4];
-  var cl = this.h[5];
-  var dh = this.h[6];
-  var dl = this.h[7];
-  var eh = this.h[8];
-  var el = this.h[9];
-  var fh = this.h[10];
-  var fl = this.h[11];
-  var gh = this.h[12];
-  var gl = this.h[13];
-  var hh = this.h[14];
-  var hl = this.h[15];
-
-  assert(this.k.length === W.length);
-  for (var i = 0; i < W.length; i += 2) {
-    var c0_hi = hh;
-    var c0_lo = hl;
-    var c1_hi = s1_512_hi(eh, el);
-    var c1_lo = s1_512_lo(eh, el);
-    var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
-    var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
-    var c3_hi = this.k[i];
-    var c3_lo = this.k[i + 1];
-    var c4_hi = W[i];
-    var c4_lo = W[i + 1];
-
-    var T1_hi = sum64_5_hi(
-      c0_hi, c0_lo,
-      c1_hi, c1_lo,
-      c2_hi, c2_lo,
-      c3_hi, c3_lo,
-      c4_hi, c4_lo);
-    var T1_lo = sum64_5_lo(
-      c0_hi, c0_lo,
-      c1_hi, c1_lo,
-      c2_hi, c2_lo,
-      c3_hi, c3_lo,
-      c4_hi, c4_lo);
-
-    c0_hi = s0_512_hi(ah, al);
-    c0_lo = s0_512_lo(ah, al);
-    c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
-    c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
-
-    var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
-    var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
-
-    hh = gh;
-    hl = gl;
-
-    gh = fh;
-    gl = fl;
-
-    fh = eh;
-    fl = el;
-
-    eh = sum64_hi(dh, dl, T1_hi, T1_lo);
-    el = sum64_lo(dl, dl, T1_hi, T1_lo);
-
-    dh = ch;
-    dl = cl;
-
-    ch = bh;
-    cl = bl;
-
-    bh = ah;
-    bl = al;
-
-    ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
-    al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
-  }
-
-  sum64(this.h, 0, ah, al);
-  sum64(this.h, 2, bh, bl);
-  sum64(this.h, 4, ch, cl);
-  sum64(this.h, 6, dh, dl);
-  sum64(this.h, 8, eh, el);
-  sum64(this.h, 10, fh, fl);
-  sum64(this.h, 12, gh, gl);
-  sum64(this.h, 14, hh, hl);
-};
-
-SHA512.prototype._digest = function digest(enc) {
-  if (enc === 'hex')
-    return utils.toHex32(this.h, 'big');
-  else
-    return utils.split32(this.h, 'big');
-};
-
-function ch64_hi(xh, xl, yh, yl, zh) {
-  var r = (xh & yh) ^ ((~xh) & zh);
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function ch64_lo(xh, xl, yh, yl, zh, zl) {
-  var r = (xl & yl) ^ ((~xl) & zl);
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function maj64_hi(xh, xl, yh, yl, zh) {
-  var r = (xh & yh) ^ (xh & zh) ^ (yh & zh);
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function maj64_lo(xh, xl, yh, yl, zh, zl) {
-  var r = (xl & yl) ^ (xl & zl) ^ (yl & zl);
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function s0_512_hi(xh, xl) {
-  var c0_hi = rotr64_hi(xh, xl, 28);
-  var c1_hi = rotr64_hi(xl, xh, 2);  // 34
-  var c2_hi = rotr64_hi(xl, xh, 7);  // 39
-
-  var r = c0_hi ^ c1_hi ^ c2_hi;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function s0_512_lo(xh, xl) {
-  var c0_lo = rotr64_lo(xh, xl, 28);
-  var c1_lo = rotr64_lo(xl, xh, 2);  // 34
-  var c2_lo = rotr64_lo(xl, xh, 7);  // 39
-
-  var r = c0_lo ^ c1_lo ^ c2_lo;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function s1_512_hi(xh, xl) {
-  var c0_hi = rotr64_hi(xh, xl, 14);
-  var c1_hi = rotr64_hi(xh, xl, 18);
-  var c2_hi = rotr64_hi(xl, xh, 9);  // 41
-
-  var r = c0_hi ^ c1_hi ^ c2_hi;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function s1_512_lo(xh, xl) {
-  var c0_lo = rotr64_lo(xh, xl, 14);
-  var c1_lo = rotr64_lo(xh, xl, 18);
-  var c2_lo = rotr64_lo(xl, xh, 9);  // 41
-
-  var r = c0_lo ^ c1_lo ^ c2_lo;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function g0_512_hi(xh, xl) {
-  var c0_hi = rotr64_hi(xh, xl, 1);
-  var c1_hi = rotr64_hi(xh, xl, 8);
-  var c2_hi = shr64_hi(xh, xl, 7);
-
-  var r = c0_hi ^ c1_hi ^ c2_hi;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function g0_512_lo(xh, xl) {
-  var c0_lo = rotr64_lo(xh, xl, 1);
-  var c1_lo = rotr64_lo(xh, xl, 8);
-  var c2_lo = shr64_lo(xh, xl, 7);
-
-  var r = c0_lo ^ c1_lo ^ c2_lo;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function g1_512_hi(xh, xl) {
-  var c0_hi = rotr64_hi(xh, xl, 19);
-  var c1_hi = rotr64_hi(xl, xh, 29);  // 61
-  var c2_hi = shr64_hi(xh, xl, 6);
-
-  var r = c0_hi ^ c1_hi ^ c2_hi;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-function g1_512_lo(xh, xl) {
-  var c0_lo = rotr64_lo(xh, xl, 19);
-  var c1_lo = rotr64_lo(xl, xh, 29);  // 61
-  var c2_lo = shr64_lo(xh, xl, 6);
-
-  var r = c0_lo ^ c1_lo ^ c2_lo;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
-}
-
-},{"../common":94,"../utils":104,"minimalistic-assert":112}],103:[function(require,module,exports){
-'use strict';
-
-var utils = require('../utils');
-var rotr32 = utils.rotr32;
-
-function ft_1(s, x, y, z) {
-  if (s === 0)
-    return ch32(x, y, z);
-  if (s === 1 || s === 3)
-    return p32(x, y, z);
-  if (s === 2)
-    return maj32(x, y, z);
-}
-exports.ft_1 = ft_1;
-
-function ch32(x, y, z) {
-  return (x & y) ^ ((~x) & z);
-}
-exports.ch32 = ch32;
-
-function maj32(x, y, z) {
-  return (x & y) ^ (x & z) ^ (y & z);
-}
-exports.maj32 = maj32;
-
-function p32(x, y, z) {
-  return x ^ y ^ z;
-}
-exports.p32 = p32;
-
-function s0_256(x) {
-  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
-}
-exports.s0_256 = s0_256;
-
-function s1_256(x) {
-  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
-}
-exports.s1_256 = s1_256;
-
-function g0_256(x) {
-  return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);
-}
-exports.g0_256 = g0_256;
-
-function g1_256(x) {
-  return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);
-}
-exports.g1_256 = g1_256;
-
-},{"../utils":104}],104:[function(require,module,exports){
-'use strict';
-
-var assert = require('minimalistic-assert');
-var inherits = require('inherits');
-
-exports.inherits = inherits;
-
-function toArray(msg, enc) {
-  if (Array.isArray(msg))
-    return msg.slice();
-  if (!msg)
-    return [];
-  var res = [];
-  if (typeof msg === 'string') {
-    if (!enc) {
-      for (var i = 0; i < msg.length; i++) {
-        var c = msg.charCodeAt(i);
-        var hi = c >> 8;
-        var lo = c & 0xff;
-        if (hi)
-          res.push(hi, lo);
-        else
-          res.push(lo);
-      }
-    } else if (enc === 'hex') {
-      msg = msg.replace(/[^a-z0-9]+/ig, '');
-      if (msg.length % 2 !== 0)
-        msg = '0' + msg;
-      for (i = 0; i < msg.length; i += 2)
-        res.push(parseInt(msg[i] + msg[i + 1], 16));
-    }
-  } else {
-    for (i = 0; i < msg.length; i++)
-      res[i] = msg[i] | 0;
-  }
-  return res;
-}
-exports.toArray = toArray;
-
-function toHex(msg) {
-  var res = '';
-  for (var i = 0; i < msg.length; i++)
-    res += zero2(msg[i].toString(16));
-  return res;
-}
-exports.toHex = toHex;
-
-function htonl(w) {
-  var res = (w >>> 24) |
-            ((w >>> 8) & 0xff00) |
-            ((w << 8) & 0xff0000) |
-            ((w & 0xff) << 24);
-  return res >>> 0;
-}
-exports.htonl = htonl;
-
-function toHex32(msg, endian) {
-  var res = '';
-  for (var i = 0; i < msg.length; i++) {
-    var w = msg[i];
-    if (endian === 'little')
-      w = htonl(w);
-    res += zero8(w.toString(16));
-  }
-  return res;
-}
-exports.toHex32 = toHex32;
-
-function zero2(word) {
-  if (word.length === 1)
-    return '0' + word;
-  else
-    return word;
-}
-exports.zero2 = zero2;
-
-function zero8(word) {
-  if (word.length === 7)
-    return '0' + word;
-  else if (word.length === 6)
-    return '00' + word;
-  else if (word.length === 5)
-    return '000' + word;
-  else if (word.length === 4)
-    return '0000' + word;
-  else if (word.length === 3)
-    return '00000' + word;
-  else if (word.length === 2)
-    return '000000' + word;
-  else if (word.length === 1)
-    return '0000000' + word;
-  else
-    return word;
-}
-exports.zero8 = zero8;
-
-function join32(msg, start, end, endian) {
-  var len = end - start;
-  assert(len % 4 === 0);
-  var res = new Array(len / 4);
-  for (var i = 0, k = start; i < res.length; i++, k += 4) {
-    var w;
-    if (endian === 'big')
-      w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];
-    else
-      w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];
-    res[i] = w >>> 0;
-  }
-  return res;
-}
-exports.join32 = join32;
-
-function split32(msg, endian) {
-  var res = new Array(msg.length * 4);
-  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
-    var m = msg[i];
-    if (endian === 'big') {
-      res[k] = m >>> 24;
-      res[k + 1] = (m >>> 16) & 0xff;
-      res[k + 2] = (m >>> 8) & 0xff;
-      res[k + 3] = m & 0xff;
-    } else {
-      res[k + 3] = m >>> 24;
-      res[k + 2] = (m >>> 16) & 0xff;
-      res[k + 1] = (m >>> 8) & 0xff;
-      res[k] = m & 0xff;
-    }
-  }
-  return res;
-}
-exports.split32 = split32;
-
-function rotr32(w, b) {
-  return (w >>> b) | (w << (32 - b));
-}
-exports.rotr32 = rotr32;
-
-function rotl32(w, b) {
-  return (w << b) | (w >>> (32 - b));
-}
-exports.rotl32 = rotl32;
-
-function sum32(a, b) {
-  return (a + b) >>> 0;
-}
-exports.sum32 = sum32;
-
-function sum32_3(a, b, c) {
-  return (a + b + c) >>> 0;
-}
-exports.sum32_3 = sum32_3;
-
-function sum32_4(a, b, c, d) {
-  return (a + b + c + d) >>> 0;
-}
-exports.sum32_4 = sum32_4;
-
-function sum32_5(a, b, c, d, e) {
-  return (a + b + c + d + e) >>> 0;
-}
-exports.sum32_5 = sum32_5;
-
-function sum64(buf, pos, ah, al) {
-  var bh = buf[pos];
-  var bl = buf[pos + 1];
-
-  var lo = (al + bl) >>> 0;
-  var hi = (lo < al ? 1 : 0) + ah + bh;
-  buf[pos] = hi >>> 0;
-  buf[pos + 1] = lo;
-}
-exports.sum64 = sum64;
-
-function sum64_hi(ah, al, bh, bl) {
-  var lo = (al + bl) >>> 0;
-  var hi = (lo < al ? 1 : 0) + ah + bh;
-  return hi >>> 0;
-}
-exports.sum64_hi = sum64_hi;
-
-function sum64_lo(ah, al, bh, bl) {
-  var lo = al + bl;
-  return lo >>> 0;
-}
-exports.sum64_lo = sum64_lo;
-
-function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
-  var carry = 0;
-  var lo = al;
-  lo = (lo + bl) >>> 0;
-  carry += lo < al ? 1 : 0;
-  lo = (lo + cl) >>> 0;
-  carry += lo < cl ? 1 : 0;
-  lo = (lo + dl) >>> 0;
-  carry += lo < dl ? 1 : 0;
-
-  var hi = ah + bh + ch + dh + carry;
-  return hi >>> 0;
-}
-exports.sum64_4_hi = sum64_4_hi;
-
-function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
-  var lo = al + bl + cl + dl;
-  return lo >>> 0;
-}
-exports.sum64_4_lo = sum64_4_lo;
-
-function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
-  var carry = 0;
-  var lo = al;
-  lo = (lo + bl) >>> 0;
-  carry += lo < al ? 1 : 0;
-  lo = (lo + cl) >>> 0;
-  carry += lo < cl ? 1 : 0;
-  lo = (lo + dl) >>> 0;
-  carry += lo < dl ? 1 : 0;
-  lo = (lo + el) >>> 0;
-  carry += lo < el ? 1 : 0;
-
-  var hi = ah + bh + ch + dh + eh + carry;
-  return hi >>> 0;
-}
-exports.sum64_5_hi = sum64_5_hi;
-
-function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
-  var lo = al + bl + cl + dl + el;
-
-  return lo >>> 0;
-}
-exports.sum64_5_lo = sum64_5_lo;
-
-function rotr64_hi(ah, al, num) {
-  var r = (al << (32 - num)) | (ah >>> num);
-  return r >>> 0;
-}
-exports.rotr64_hi = rotr64_hi;
-
-function rotr64_lo(ah, al, num) {
-  var r = (ah << (32 - num)) | (al >>> num);
-  return r >>> 0;
-}
-exports.rotr64_lo = rotr64_lo;
-
-function shr64_hi(ah, al, num) {
-  return ah >>> num;
-}
-exports.shr64_hi = shr64_hi;
-
-function shr64_lo(ah, al, num) {
-  var r = (ah << (32 - num)) | (al >>> num);
-  return r >>> 0;
-}
-exports.shr64_lo = shr64_lo;
-
-},{"inherits":107,"minimalistic-assert":112}],105:[function(require,module,exports){
-'use strict';
-
-var hash = require('hash.js');
-var utils = require('minimalistic-crypto-utils');
-var assert = require('minimalistic-assert');
-
-function HmacDRBG(options) {
-  if (!(this instanceof HmacDRBG))
-    return new HmacDRBG(options);
-  this.hash = options.hash;
-  this.predResist = !!options.predResist;
-
-  this.outLen = this.hash.outSize;
-  this.minEntropy = options.minEntropy || this.hash.hmacStrength;
-
-  this._reseed = null;
-  this.reseedInterval = null;
-  this.K = null;
-  this.V = null;
-
-  var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');
-  var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');
-  var pers = utils.toArray(options.pers, options.persEnc || 'hex');
-  assert(entropy.length >= (this.minEntropy / 8),
-         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
-  this._init(entropy, nonce, pers);
-}
-module.exports = HmacDRBG;
-
-HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
-  var seed = entropy.concat(nonce).concat(pers);
-
-  this.K = new Array(this.outLen / 8);
-  this.V = new Array(this.outLen / 8);
-  for (var i = 0; i < this.V.length; i++) {
-    this.K[i] = 0x00;
-    this.V[i] = 0x01;
-  }
-
-  this._update(seed);
-  this._reseed = 1;
-  this.reseedInterval = 0x1000000000000;  // 2^48
-};
-
-HmacDRBG.prototype._hmac = function hmac() {
-  return new hash.hmac(this.hash, this.K);
-};
-
-HmacDRBG.prototype._update = function update(seed) {
-  var kmac = this._hmac()
-                 .update(this.V)
-                 .update([ 0x00 ]);
-  if (seed)
-    kmac = kmac.update(seed);
-  this.K = kmac.digest();
-  this.V = this._hmac().update(this.V).digest();
-  if (!seed)
-    return;
-
-  this.K = this._hmac()
-               .update(this.V)
-               .update([ 0x01 ])
-               .update(seed)
-               .digest();
-  this.V = this._hmac().update(this.V).digest();
-};
-
-HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
-  // Optional entropy enc
-  if (typeof entropyEnc !== 'string') {
-    addEnc = add;
-    add = entropyEnc;
-    entropyEnc = null;
-  }
-
-  entropy = utils.toArray(entropy, entropyEnc);
-  add = utils.toArray(add, addEnc);
-
-  assert(entropy.length >= (this.minEntropy / 8),
-         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
-
-  this._update(entropy.concat(add || []));
-  this._reseed = 1;
-};
-
-HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
-  if (this._reseed > this.reseedInterval)
-    throw new Error('Reseed is required');
-
-  // Optional encoding
-  if (typeof enc !== 'string') {
-    addEnc = add;
-    add = enc;
-    enc = null;
-  }
-
-  // Optional additional data
-  if (add) {
-    add = utils.toArray(add, addEnc || 'hex');
-    this._update(add);
-  }
-
-  var temp = [];
-  while (temp.length < len) {
-    this.V = this._hmac().update(this.V).digest();
-    temp = temp.concat(this.V);
-  }
-
-  var res = temp.slice(0, len);
-  this._update(add);
-  this._reseed++;
-  return utils.encode(res, enc);
-};
-
-},{"hash.js":93,"minimalistic-assert":112,"minimalistic-crypto-utils":113}],106:[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
-}
-
-},{}],107:[function(require,module,exports){
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  module.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor
-    ctor.prototype = Object.create(superCtor.prototype, {
-      constructor: {
-        value: ctor,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-  };
-} else {
-  // old school shim for old browsers
-  module.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor
-    var TempCtor = function () {}
-    TempCtor.prototype = superCtor.prototype
-    ctor.prototype = new TempCtor()
-    ctor.prototype.constructor = ctor
-  }
-}
-
-},{}],108:[function(require,module,exports){
-/*!
- * Determine if an object is a Buffer
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
-
-// The _isBuffer check is for Safari 5-7 support, because it's missing
-// Object.prototype.constructor. Remove this eventually
-module.exports = function (obj) {
-  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
-}
-
-function isBuffer (obj) {
-  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
-}
-
-// For Node v0.10 support. Remove this eventually.
-function isSlowBuffer (obj) {
-  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
-}
-
-},{}],109:[function(require,module,exports){
-var toString = {}.toString;
-
-module.exports = Array.isArray || function (arr) {
-  return toString.call(arr) == '[object Array]';
-};
-
-},{}],110:[function(require,module,exports){
-(function (Buffer){
-'use strict'
-var inherits = require('inherits')
-var HashBase = require('hash-base')
-
-var ARRAY16 = new Array(16)
-
-function MD5 () {
-  HashBase.call(this, 64)
-
-  // state
-  this._a = 0x67452301
-  this._b = 0xefcdab89
-  this._c = 0x98badcfe
-  this._d = 0x10325476
-}
-
-inherits(MD5, HashBase)
-
-MD5.prototype._update = function () {
-  var M = ARRAY16
-  for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)
-
-  var a = this._a
-  var b = this._b
-  var c = this._c
-  var d = this._d
-
-  a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)
-  d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)
-  c = fnF(c, d, a, b, M[2], 0x242070db, 17)
-  b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)
-  a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)
-  d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)
-  c = fnF(c, d, a, b, M[6], 0xa8304613, 17)
-  b = fnF(b, c, d, a, M[7], 0xfd469501, 22)
-  a = fnF(a, b, c, d, M[8], 0x698098d8, 7)
-  d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)
-  c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)
-  b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)
-  a = fnF(a, b, c, d, M[12], 0x6b901122, 7)
-  d = fnF(d, a, b, c, M[13], 0xfd987193, 12)
-  c = fnF(c, d, a, b, M[14], 0xa679438e, 17)
-  b = fnF(b, c, d, a, M[15], 0x49b40821, 22)
-
-  a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)
-  d = fnG(d, a, b, c, M[6], 0xc040b340, 9)
-  c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)
-  b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)
-  a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)
-  d = fnG(d, a, b, c, M[10], 0x02441453, 9)
-  c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)
-  b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)
-  a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)
-  d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)
-  c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)
-  b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)
-  a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)
-  d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)
-  c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)
-  b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)
-
-  a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)
-  d = fnH(d, a, b, c, M[8], 0x8771f681, 11)
-  c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)
-  b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)
-  a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)
-  d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)
-  c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)
-  b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)
-  a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)
-  d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)
-  c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)
-  b = fnH(b, c, d, a, M[6], 0x04881d05, 23)
-  a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)
-  d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)
-  c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)
-  b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)
-
-  a = fnI(a, b, c, d, M[0], 0xf4292244, 6)
-  d = fnI(d, a, b, c, M[7], 0x432aff97, 10)
-  c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)
-  b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)
-  a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)
-  d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)
-  c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)
-  b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)
-  a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)
-  d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)
-  c = fnI(c, d, a, b, M[6], 0xa3014314, 15)
-  b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)
-  a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)
-  d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)
-  c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)
-  b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)
-
-  this._a = (this._a + a) | 0
-  this._b = (this._b + b) | 0
-  this._c = (this._c + c) | 0
-  this._d = (this._d + d) | 0
-}
-
-MD5.prototype._digest = function () {
-  // create padding and handle blocks
-  this._block[this._blockOffset++] = 0x80
-  if (this._blockOffset > 56) {
-    this._block.fill(0, this._blockOffset, 64)
-    this._update()
-    this._blockOffset = 0
-  }
-
-  this._block.fill(0, this._blockOffset, 56)
-  this._block.writeUInt32LE(this._length[0], 56)
-  this._block.writeUInt32LE(this._length[1], 60)
-  this._update()
-
-  // produce result
-  var buffer = new Buffer(16)
-  buffer.writeInt32LE(this._a, 0)
-  buffer.writeInt32LE(this._b, 4)
-  buffer.writeInt32LE(this._c, 8)
-  buffer.writeInt32LE(this._d, 12)
-  return buffer
-}
-
-function rotl (x, n) {
-  return (x << n) | (x >>> (32 - n))
-}
-
-function fnF (a, b, c, d, m, k, s) {
-  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0
-}
-
-function fnG (a, b, c, d, m, k, s) {
-  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0
-}
-
-function fnH (a, b, c, d, m, k, s) {
-  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0
-}
-
-function fnI (a, b, c, d, m, k, s) {
-  return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0
-}
-
-module.exports = MD5
-
-}).call(this,require("buffer").Buffer)
-},{"buffer":55,"hash-base":92,"inherits":107}],111:[function(require,module,exports){
-var bn = require('bn.js');
-var brorand = require('brorand');
-
-function MillerRabin(rand) {
-  this.rand = rand || new brorand.Rand();
-}
-module.exports = MillerRabin;
-
-MillerRabin.create = function create(rand) {
-  return new MillerRabin(rand);
-};
-
-MillerRabin.prototype._randbelow = function _randbelow(n) {
-  var len = n.bitLength();
-  var min_bytes = Math.ceil(len / 8);
-
-  // Generage random bytes until a number less than n is found.
-  // This ensures that 0..n-1 have an equal probability of being selected.
-  do
-    var a = new bn(this.rand.generate(min_bytes));
-  while (a.cmp(n) >= 0);
-
-  return a;
-};
-
-MillerRabin.prototype._randrange = function _randrange(start, stop) {
-  // Generate a random number greater than or equal to start and less than stop.
-  var size = stop.sub(start);
-  return start.add(this._randbelow(size));
-};
-
-MillerRabin.prototype.test = function test(n, k, cb) {
-  var len = n.bitLength();
-  var red = bn.mont(n);
-  var rone = new bn(1).toRed(red);
-
-  if (!k)
-    k = Math.max(1, (len / 48) | 0);
-
-  // Find d and s, (n - 1) = (2 ^ s) * d;
-  var n1 = n.subn(1);
-  for (var s = 0; !n1.testn(s); s++) {}
-  var d = n.shrn(s);
-
-  var rn1 = n1.toRed(red);
-
-  var prime = true;
-  for (; k > 0; k--) {
-    var a = this._randrange(new bn(2), n1);
-    if (cb)
-      cb(a);
-
-    var x = a.toRed(red).redPow(d);
-    if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
-      continue;
-
-    for (var i = 1; i < s; i++) {
-      x = x.redSqr();
-
-      if (x.cmp(rone) === 0)
-        return false;
-      if (x.cmp(rn1) === 0)
-        break;
-    }
-
-    if (i === s)
-      return false;
-  }
-
-  return prime;
-};
-
-MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
-  var len = n.bitLength();
-  var red = bn.mont(n);
-  var rone = new bn(1).toRed(red);
-
-  if (!k)
-    k = Math.max(1, (len / 48) | 0);
-
-  // Find d and s, (n - 1) = (2 ^ s) * d;
-  var n1 = n.subn(1);
-  for (var s = 0; !n1.testn(s); s++) {}
-  var d = n.shrn(s);
-
-  var rn1 = n1.toRed(red);
-
-  for (; k > 0; k--) {
-    var a = this._randrange(new bn(2), n1);
-
-    var g = n.gcd(a);
-    if (g.cmpn(1) !== 0)
-      return g;
-
-    var x = a.toRed(red).redPow(d);
-    if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
-      continue;
-
-    for (var i = 1; i < s; i++) {
-      x = x.redSqr();
-
-      if (x.cmp(rone) === 0)
-        return x.fromRed().subn(1).gcd(n);
-      if (x.cmp(rn1) === 0)
-        break;
-    }
-
-    if (i === s) {
-      x = x.redSqr();
-      return x.fromRed().subn(1).gcd(n);
-    }
-  }
-
-  return false;
-};
-
-},{"bn.js":24,"brorand":25}],112:[function(require,module,exports){
-module.exports = assert;
-
-function assert(val, msg) {
-  if (!val)
-    throw new Error(msg || 'Assertion failed');
-}
-
-assert.equal = function assertEqual(l, r, msg) {
-  if (l != r)
-    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
-};
-
-},{}],113:[function(require,module,exports){
-'use strict';
-
-var utils = exports;
-
-function toArray(msg, enc) {
-  if (Array.isArray(msg))
-    return msg.slice();
-  if (!msg)
-    return [];
-  var res = [];
-  if (typeof msg !== 'string') {
-    for (var i = 0; i < msg.length; i++)
-      res[i] = msg[i] | 0;
-    return res;
-  }
-  if (enc === 'hex') {
-    msg = msg.replace(/[^a-z0-9]+/ig, '');
-    if (msg.length % 2 !== 0)
-      msg = '0' + msg;
-    for (var i = 0; i < msg.length; i += 2)
-      res.push(parseInt(msg[i] + msg[i + 1], 16));
-  } else {
-    for (var i = 0; i < msg.length; i++) {
-      var c = msg.charCodeAt(i);
-      var hi = c >> 8;
-      var lo = c & 0xff;
-      if (hi)
-        res.push(hi, lo);
-      else
-        res.push(lo);
-    }
-  }
-  return res;
-}
-utils.toArray = toArray;
-
-function zero2(word) {
-  if (word.length === 1)
-    return '0' + word;
-  else
-    return word;
-}
-utils.zero2 = zero2;
-
-function toHex(msg) {
-  var res = '';
-  for (var i = 0; i < msg.length; i++)
-    res += zero2(msg[i].toString(16));
-  return res;
-}
-utils.toHex = toHex;
-
-utils.encode = function encode(arr, enc) {
-  if (enc === 'hex')
-    return toHex(arr);
-  else
-    return arr;
-};
-
-},{}],114:[function(require,module,exports){
-module.exports={"2.16.840.1.101.3.4.1.1": "aes-128-ecb",
-"2.16.840.1.101.3.4.1.2": "aes-128-cbc",
-"2.16.840.1.101.3.4.1.3": "aes-128-ofb",
-"2.16.840.1.101.3.4.1.4": "aes-128-cfb",
-"2.16.840.1.101.3.4.1.21": "aes-192-ecb",
-"2.16.840.1.101.3.4.1.22": "aes-192-cbc",
-"2.16.840.1.101.3.4.1.23": "aes-192-ofb",
-"2.16.840.1.101.3.4.1.24": "aes-192-cfb",
-"2.16.840.1.101.3.4.1.41": "aes-256-ecb",
-"2.16.840.1.101.3.4.1.42": "aes-256-cbc",
-"2.16.840.1.101.3.4.1.43": "aes-256-ofb",
-"2.16.840.1.101.3.4.1.44": "aes-256-cfb"
-}
-},{}],115:[function(require,module,exports){
-// from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js
-// Fedor, you are amazing.
-'use strict'
-
-var asn1 = require('asn1.js')
-
-exports.certificate = require('./certificate')
-
-var RSAPrivateKey = asn1.define('RSAPrivateKey', function () {
-  this.seq().obj(
-    this.key('version').int(),
-    this.key('modulus').int(),
-    this.key('publicExponent').int(),
-    this.key('privateExponent').int(),
-    this.key('prime1').int(),
-    this.key('prime2').int(),
-    this.key('exponent1').int(),
-    this.key('exponent2').int(),
-    this.key('coefficient').int()
-  )
-})
-exports.RSAPrivateKey = RSAPrivateKey
-
-var RSAPublicKey = asn1.define('RSAPublicKey', function () {
-  this.seq().obj(
-    this.key('modulus').int(),
-    this.key('publicExponent').int()
-  )
-})
-exports.RSAPublicKey = RSAPublicKey
-
-var PublicKey = asn1.define('SubjectPublicKeyInfo', function () {
-  this.seq().obj(
-    this.key('algorithm').use(AlgorithmIdentifier),
-    this.key('subjectPublicKey').bitstr()
-  )
-})
-exports.PublicKey = PublicKey
-
-var AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () {
-  this.seq().obj(
-    this.key('algorithm').objid(),
-    this.key('none').null_().optional(),
-    this.key('curve').objid().optional(),
-    this.key('params').seq().obj(
-      this.key('p').int(),
-      this.key('q').int(),
-      this.key('g').int()
-    ).optional()
-  )
-})
-
-var PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () {
-  this.seq().obj(
-    this.key('version').int(),
-    this.key('algorithm').use(AlgorithmIdentifier),
-    this.key('subjectPrivateKey').octstr()
-  )
-})
-exports.PrivateKey = PrivateKeyInfo
-var EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () {
-  this.seq().obj(
-    this.key('algorithm').seq().obj(
-      this.key('id').objid(),
-      this.key('decrypt').seq().obj(
-        this.key('kde').seq().obj(
-          this.key('id').objid(),
-          this.key('kdeparams').seq().obj(
-            this.key('salt').octstr(),
-            this.key('iters').int()
-          )
-        ),
-        this.key('cipher').seq().obj(
-          this.key('algo').objid(),
-          this.key('iv').octstr()
-        )
-      )
-    ),
-    this.key('subjectPrivateKey').octstr()
-  )
-})
-
-exports.EncryptedPrivateKey = EncryptedPrivateKeyInfo
-
-var DSAPrivateKey = asn1.define('DSAPrivateKey', function () {
-  this.seq().obj(
-    this.key('version').int(),
-    this.key('p').int(),
-    this.key('q').int(),
-    this.key('g').int(),
-    this.key('pub_key').int(),
-    this.key('priv_key').int()
-  )
-})
-exports.DSAPrivateKey = DSAPrivateKey
-
-exports.DSAparam = asn1.define('DSAparam', function () {
-  this.int()
-})
-
-var ECPrivateKey = asn1.define('ECPrivateKey', function () {
-  this.seq().obj(
-    this.key('version').int(),
-    this.key('privateKey').octstr(),
-    this.key('parameters').optional().explicit(0).use(ECParameters),
-    this.key('publicKey').optional().explicit(1).bitstr()
-  )
-})
-exports.ECPrivateKey = ECPrivateKey
-
-var ECParameters = asn1.define('ECParameters', function () {
-  this.choice({
-    namedCurve: this.objid()
-  })
-})
-
-exports.signature = asn1.define('signature', function () {
-  this.seq().obj(
-    this.key('r').int(),
-    this.key('s').int()
-  )
-})
-
-},{"./certificate":116,"asn1.js":9}],116:[function(require,module,exports){
-// from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js
-// thanks to @Rantanen
-
-'use strict'
-
-var asn = require('asn1.js')
-
-var Time = asn.define('Time', function () {
-  this.choice({
-    utcTime: this.utctime(),
-    generalTime: this.gentime()
-  })
-})
-
-var AttributeTypeValue = asn.define('AttributeTypeValue', function () {
-  this.seq().obj(
-    this.key('type').objid(),
-    this.key('value').any()
-  )
-})
-
-var AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () {
-  this.seq().obj(
-    this.key('algorithm').objid(),
-    this.key('parameters').optional()
-  )
-})
-
-var SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () {
-  this.seq().obj(
-    this.key('algorithm').use(AlgorithmIdentifier),
-    this.key('subjectPublicKey').bitstr()
-  )
-})
-
-var RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () {
-  this.setof(AttributeTypeValue)
-})
-
-var RDNSequence = asn.define('RDNSequence', function () {
-  this.seqof(RelativeDistinguishedName)
-})
-
-var Name = asn.define('Name', function () {
-  this.choice({
-    rdnSequence: this.use(RDNSequence)
-  })
-})
-
-var Validity = asn.define('Validity', function () {
-  this.seq().obj(
-    this.key('notBefore').use(Time),
-    this.key('notAfter').use(Time)
-  )
-})
-
-var Extension = asn.define('Extension', function () {
-  this.seq().obj(
-    this.key('extnID').objid(),
-    this.key('critical').bool().def(false),
-    this.key('extnValue').octstr()
-  )
-})
-
-var TBSCertificate = asn.define('TBSCertificate', function () {
-  this.seq().obj(
-    this.key('version').explicit(0).int(),
-    this.key('serialNumber').int(),
-    this.key('signature').use(AlgorithmIdentifier),
-    this.key('issuer').use(Name),
-    this.key('validity').use(Validity),
-    this.key('subject').use(Name),
-    this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo),
-    this.key('issuerUniqueID').implicit(1).bitstr().optional(),
-    this.key('subjectUniqueID').implicit(2).bitstr().optional(),
-    this.key('extensions').explicit(3).seqof(Extension).optional()
-  )
-})
-
-var X509Certificate = asn.define('X509Certificate', function () {
-  this.seq().obj(
-    this.key('tbsCertificate').use(TBSCertificate),
-    this.key('signatureAlgorithm').use(AlgorithmIdentifier),
-    this.key('signatureValue').bitstr()
-  )
-})
-
-module.exports = X509Certificate
-
-},{"asn1.js":9}],117:[function(require,module,exports){
-(function (Buffer){
-// adapted from https://github.com/apatil/pemstrip
-var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r\+\/\=]+)[\n\r]+/m
-var startRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----/m
-var fullRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----([0-9A-z\n\r\+\/\=]+)-----END \1-----$/m
-var evp = require('evp_bytestokey')
-var ciphers = require('browserify-aes')
-module.exports = function (okey, password) {
-  var key = okey.toString()
-  var match = key.match(findProc)
-  var decrypted
-  if (!match) {
-    var match2 = key.match(fullRegex)
-    decrypted = new Buffer(match2[2].replace(/[\r\n]/g, ''), 'base64')
-  } else {
-    var suite = 'aes' + match[1]
-    var iv = new Buffer(match[2], 'hex')
-    var cipherText = new Buffer(match[3].replace(/[\r\n]/g, ''), 'base64')
-    var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key
-    var out = []
-    var cipher = ciphers.createDecipheriv(suite, cipherKey, iv)
-    out.push(cipher.update(cipherText))
-    out.push(cipher.final())
-    decrypted = Buffer.concat(out)
-  }
-  var tag = key.match(startRegex)[1]
-  return {
-    tag: tag,
-    data: decrypted
-  }
-}
-
-}).call(this,require("buffer").Buffer)
-},{"browserify-aes":29,"buffer":55,"evp_bytestokey":91}],118:[function(require,module,exports){
-(function (Buffer){
-var asn1 = require('./asn1')
-var aesid = require('./aesid.json')
-var fixProc = require('./fixProc')
-var ciphers = require('browserify-aes')
-var compat = require('pbkdf2')
-module.exports = parseKeys
-
-function parseKeys (buffer) {
-  var password
-  if (typeof buffer === 'object' && !Buffer.isBuffer(buffer)) {
-    password = buffer.passphrase
-    buffer = buffer.key
-  }
-  if (typeof buffer === 'string') {
-    buffer = new Buffer(buffer)
-  }
-
-  var stripped = fixProc(buffer, password)
-
-  var type = stripped.tag
-  var data = stripped.data
-  var subtype, ndata
-  switch (type) {
-    case 'CERTIFICATE':
-      ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo
-      // falls through
-    case 'PUBLIC KEY':
-      if (!ndata) {
-        ndata = asn1.PublicKey.decode(data, 'der')
-      }
-      subtype = ndata.algorithm.algorithm.join('.')
-      switch (subtype) {
-        case '1.2.840.113549.1.1.1':
-          return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der')
-        case '1.2.840.10045.2.1':
-          ndata.subjectPrivateKey = ndata.subjectPublicKey
-          return {
-            type: 'ec',
-            data: ndata
-          }
-        case '1.2.840.10040.4.1':
-          ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der')
-          return {
-            type: 'dsa',
-            data: ndata.algorithm.params
-          }
-        default: throw new Error('unknown key id ' + subtype)
-      }
-      throw new Error('unknown key type ' + type)
-    case 'ENCRYPTED PRIVATE KEY':
-      data = asn1.EncryptedPrivateKey.decode(data, 'der')
-      data = decrypt(data, password)
-      // falls through
-    case 'PRIVATE KEY':
-      ndata = asn1.PrivateKey.decode(data, 'der')
-      subtype = ndata.algorithm.algorithm.join('.')
-      switch (subtype) {
-        case '1.2.840.113549.1.1.1':
-          return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der')
-        case '1.2.840.10045.2.1':
-          return {
-            curve: ndata.algorithm.curve,
-            privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, 'der').privateKey
-          }
-        case '1.2.840.10040.4.1':
-          ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, 'der')
-          return {
-            type: 'dsa',
-            params: ndata.algorithm.params
-          }
-        default: throw new Error('unknown key id ' + subtype)
-      }
-      throw new Error('unknown key type ' + type)
-    case 'RSA PUBLIC KEY':
-      return asn1.RSAPublicKey.decode(data, 'der')
-    case 'RSA PRIVATE KEY':
-      return asn1.RSAPrivateKey.decode(data, 'der')
-    case 'DSA PRIVATE KEY':
-      return {
-        type: 'dsa',
-        params: asn1.DSAPrivateKey.decode(data, 'der')
-      }
-    case 'EC PRIVATE KEY':
-      data = asn1.ECPrivateKey.decode(data, 'der')
-      return {
-        curve: data.parameters.value,
-        privateKey: data.privateKey
-      }
-    default: throw new Error('unknown key type ' + type)
-  }
-}
-parseKeys.signature = asn1.signature
-function decrypt (data, password) {
-  var salt = data.algorithm.decrypt.kde.kdeparams.salt
-  var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10)
-  var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')]
-  var iv = data.algorithm.decrypt.cipher.iv
-  var cipherText = data.subjectPrivateKey
-  var keylen = parseInt(algo.split('-')[1], 10) / 8
-  var key = compat.pbkdf2Sync(password, salt, iters, keylen)
-  var cipher = ciphers.createDecipheriv(algo, key, iv)
-  var out = []
-  out.push(cipher.update(cipherText))
-  out.push(cipher.final())
-  return Buffer.concat(out)
-}
-
-}).call(this,require("buffer").Buffer)
-},{"./aesid.json":114,"./asn1":115,"./fixProc":117,"browserify-aes":29,"buffer":55,"pbkdf2":119}],119:[function(require,module,exports){
-exports.pbkdf2 = require('./lib/async')
-exports.pbkdf2Sync = require('./lib/sync')
-
-},{"./lib/async":120,"./lib/sync":123}],120:[function(require,module,exports){
-(function (process,global){
-var checkParameters = require('./precondition')
-var defaultEncoding = require('./default-encoding')
-var sync = require('./sync')
-var Buffer = require('safe-buffer').Buffer
-
-var ZERO_BUF
-var subtle = global.crypto && global.crypto.subtle
-var toBrowser = {
-  'sha': 'SHA-1',
-  'sha-1': 'SHA-1',
-  'sha1': 'SHA-1',
-  'sha256': 'SHA-256',
-  'sha-256': 'SHA-256',
-  'sha384': 'SHA-384',
-  'sha-384': 'SHA-384',
-  'sha-512': 'SHA-512',
-  'sha512': 'SHA-512'
-}
-var checks = []
-function checkNative (algo) {
-  if (global.process && !global.process.browser) {
-    return Promise.resolve(false)
-  }
-  if (!subtle || !subtle.importKey || !subtle.deriveBits) {
-    return Promise.resolve(false)
-  }
-  if (checks[algo] !== undefined) {
-    return checks[algo]
-  }
-  ZERO_BUF = ZERO_BUF || Buffer.alloc(8)
-  var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo)
-    .then(function () {
-      return true
-    }).catch(function () {
-      return false
-    })
-  checks[algo] = prom
-  return prom
-}
-
-function browserPbkdf2 (password, salt, iterations, length, algo) {
-  return subtle.importKey(
-    'raw', password, {name: 'PBKDF2'}, false, ['deriveBits']
-  ).then(function (key) {
-    return subtle.deriveBits({
-      name: 'PBKDF2',
-      salt: salt,
-      iterations: iterations,
-      hash: {
-        name: algo
-      }
-    }, key, length << 3)
-  }).then(function (res) {
-    return Buffer.from(res)
-  })
-}
-
-function resolvePromise (promise, callback) {
-  promise.then(function (out) {
-    process.nextTick(function () {
-      callback(null, out)
-    })
-  }, function (e) {
-    process.nextTick(function () {
-      callback(e)
-    })
-  })
-}
-module.exports = function (password, salt, iterations, keylen, digest, callback) {
-  if (typeof digest === 'function') {
-    callback = digest
-    digest = undefined
-  }
-
-  digest = digest || 'sha1'
-  var algo = toBrowser[digest.toLowerCase()]
-
-  if (!algo || typeof global.Promise !== 'function') {
-    return process.nextTick(function () {
-      var out
-      try {
-        out = sync(password, salt, iterations, keylen, digest)
-      } catch (e) {
-        return callback(e)
-      }
-      callback(null, out)
-    })
-  }
-
-  checkParameters(password, salt, iterations, keylen)
-  if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2')
-  if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding)
-  if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding)
-
-  resolvePromise(checkNative(algo).then(function (resp) {
-    if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo)
-
-    return sync(password, salt, iterations, keylen, digest)
-  }), callback)
-}
-
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./default-encoding":121,"./precondition":122,"./sync":123,"_process":125,"safe-buffer":148}],121:[function(require,module,exports){
-(function (process){
-var defaultEncoding
-/* istanbul ignore next */
-if (process.browser) {
-  defaultEncoding = 'utf-8'
-} else {
-  var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10)
-
-  defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary'
-}
-module.exports = defaultEncoding
-
-}).call(this,require('_process'))
-},{"_process":125}],122:[function(require,module,exports){
-(function (Buffer){
-var MAX_ALLOC = Math.pow(2, 30) - 1 // default in iojs
-
-function checkBuffer (buf, name) {
-  if (typeof buf !== 'string' && !Buffer.isBuffer(buf)) {
-    throw new TypeError(name + ' must be a buffer or string')
-  }
-}
-
-module.exports = function (password, salt, iterations, keylen) {
-  checkBuffer(password, 'Password')
-  checkBuffer(salt, 'Salt')
-
-  if (typeof iterations !== 'number') {
-    throw new TypeError('Iterations not a number')
-  }
-
-  if (iterations < 0) {
-    throw new TypeError('Bad iterations')
-  }
-
-  if (typeof keylen !== 'number') {
-    throw new TypeError('Key length not a number')
-  }
-
-  if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { /* eslint no-self-compare: 0 */
-    throw new TypeError('Bad key length')
-  }
-}
-
-}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
-},{"../../is-buffer/index.js":108}],123:[function(require,module,exports){
-var md5 = require('create-hash/md5')
-var rmd160 = require('ripemd160')
-var sha = require('sha.js')
-
-var checkParameters = require('./precondition')
-var defaultEncoding = require('./default-encoding')
-var Buffer = require('safe-buffer').Buffer
-var ZEROS = Buffer.alloc(128)
-var sizes = {
-  md5: 16,
-  sha1: 20,
-  sha224: 28,
-  sha256: 32,
-  sha384: 48,
-  sha512: 64,
-  rmd160: 20,
-  ripemd160: 20
-}
-
-function Hmac (alg, key, saltLen) {
-  var hash = getDigest(alg)
-  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64
-
-  if (key.length > blocksize) {
-    key = hash(key)
-  } else if (key.length < blocksize) {
-    key = Buffer.concat([key, ZEROS], blocksize)
-  }
-
-  var ipad = Buffer.allocUnsafe(blocksize + sizes[alg])
-  var opad = Buffer.allocUnsafe(blocksize + sizes[alg])
-  for (var i = 0; i < blocksize; i++) {
-    ipad[i] = key[i] ^ 0x36
-    opad[i] = key[i] ^ 0x5C
-  }
-
-  var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4)
-  ipad.copy(ipad1, 0, 0, blocksize)
-  this.ipad1 = ipad1
-  this.ipad2 = ipad
-  this.opad = opad
-  this.alg = alg
-  this.blocksize = blocksize
-  this.hash = hash
-  this.size = sizes[alg]
-}
-
-Hmac.prototype.run = function (data, ipad) {
-  data.copy(ipad, this.blocksize)
-  var h = this.hash(ipad)
-  h.copy(this.opad, this.blocksize)
-  return this.hash(this.opad)
-}
-
-function getDigest (alg) {
-  function shaFunc (data) {
-    return sha(alg).update(data).digest()
-  }
-
-  if (alg === 'rmd160' || alg === 'ripemd160') return rmd160
-  if (alg === 'md5') return md5
-  return shaFunc
-}
-
-function pbkdf2 (password, salt, iterations, keylen, digest) {
-  checkParameters(password, salt, iterations, keylen)
-
-  if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding)
-  if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding)
-
-  digest = digest || 'sha1'
-
-  var hmac = new Hmac(digest, password, salt.length)
-
-  var DK = Buffer.allocUnsafe(keylen)
-  var block1 = Buffer.allocUnsafe(salt.length + 4)
-  salt.copy(block1, 0, 0, salt.length)
-
-  var destPos = 0
-  var hLen = sizes[digest]
-  var l = Math.ceil(keylen / hLen)
-
-  for (var i = 1; i <= l; i++) {
-    block1.writeUInt32BE(i, salt.length)
-
-    var T = hmac.run(block1, hmac.ipad1)
-    var U = T
-
-    for (var j = 1; j < iterations; j++) {
-      U = hmac.run(U, hmac.ipad2)
-      for (var k = 0; k < hLen; k++) T[k] ^= U[k]
-    }
-
-    T.copy(DK, destPos)
-    destPos += hLen
-  }
-
-  return DK
-}
-
-module.exports = pbkdf2
-
-},{"./default-encoding":121,"./precondition":122,"create-hash/md5":60,"ripemd160":147,"safe-buffer":148,"sha.js":150}],124:[function(require,module,exports){
-(function (process){
-'use strict';
-
-if (!process.version ||
-    process.version.indexOf('v0.') === 0 ||
-    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
-  module.exports = { nextTick: nextTick };
-} else {
-  module.exports = process
-}
-
-function nextTick(fn, arg1, arg2, arg3) {
-  if (typeof fn !== 'function') {
-    throw new TypeError('"callback" argument must be a function');
-  }
-  var len = arguments.length;
-  var args, i;
-  switch (len) {
-  case 0:
-  case 1:
-    return process.nextTick(fn);
-  case 2:
-    return process.nextTick(function afterTickOne() {
-      fn.call(null, arg1);
-    });
-  case 3:
-    return process.nextTick(function afterTickTwo() {
-      fn.call(null, arg1, arg2);
-    });
-  case 4:
-    return process.nextTick(function afterTickThree() {
-      fn.call(null, arg1, arg2, arg3);
-    });
-  default:
-    args = new Array(len - 1);
-    i = 0;
-    while (i < args.length) {
-      args[i++] = arguments[i];
-    }
-    return process.nextTick(function afterTick() {
-      fn.apply(null, args);
-    });
-  }
-}
-
-
-}).call(this,require('_process'))
-},{"_process":125}],125:[function(require,module,exports){
-// shim for using process in browser
-var process = module.exports = {};
-
-// cached from whatever global is present so that test runners that stub it
-// don't break things.  But we need to wrap it in a try catch in case it is
-// wrapped in strict mode code which doesn't define any globals.  It's inside a
-// function because try/catches deoptimize in certain engines.
-
-var cachedSetTimeout;
-var cachedClearTimeout;
-
-function defaultSetTimout() {
-    throw new Error('setTimeout has not been defined');
-}
-function defaultClearTimeout () {
-    throw new Error('clearTimeout has not been defined');
-}
-(function () {
-    try {
-        if (typeof setTimeout === 'function') {
-            cachedSetTimeout = setTimeout;
-        } else {
-            cachedSetTimeout = defaultSetTimout;
-        }
-    } catch (e) {
-        cachedSetTimeout = defaultSetTimout;
-    }
-    try {
-        if (typeof clearTimeout === 'function') {
-            cachedClearTimeout = clearTimeout;
-        } else {
-            cachedClearTimeout = defaultClearTimeout;
-        }
-    } catch (e) {
-        cachedClearTimeout = defaultClearTimeout;
-    }
-} ())
-function runTimeout(fun) {
-    if (cachedSetTimeout === setTimeout) {
-        //normal enviroments in sane situations
-        return setTimeout(fun, 0);
-    }
-    // if setTimeout wasn't available but was latter defined
-    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-        cachedSetTimeout = setTimeout;
-        return setTimeout(fun, 0);
-    }
-    try {
-        // when when somebody has screwed with setTimeout but no I.E. maddness
-        return cachedSetTimeout(fun, 0);
-    } catch(e){
-        try {
-            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
-            return cachedSetTimeout.call(null, fun, 0);
-        } catch(e){
-            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
-            return cachedSetTimeout.call(this, fun, 0);
-        }
-    }
-
-
-}
-function runClearTimeout(marker) {
-    if (cachedClearTimeout === clearTimeout) {
-        //normal enviroments in sane situations
-        return clearTimeout(marker);
-    }
-    // if clearTimeout wasn't available but was latter defined
-    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
-        cachedClearTimeout = clearTimeout;
-        return clearTimeout(marker);
-    }
-    try {
-        // when when somebody has screwed with setTimeout but no I.E. maddness
-        return cachedClearTimeout(marker);
-    } catch (e){
-        try {
-            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
-            return cachedClearTimeout.call(null, marker);
-        } catch (e){
-            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
-            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
-            return cachedClearTimeout.call(this, marker);
-        }
-    }
-
-
-
-}
-var queue = [];
-var draining = false;
-var currentQueue;
-var queueIndex = -1;
-
-function cleanUpNextTick() {
-    if (!draining || !currentQueue) {
-        return;
-    }
-    draining = false;
-    if (currentQueue.length) {
-        queue = currentQueue.concat(queue);
-    } else {
-        queueIndex = -1;
-    }
-    if (queue.length) {
-        drainQueue();
-    }
-}
-
-function drainQueue() {
-    if (draining) {
-        return;
-    }
-    var timeout = runTimeout(cleanUpNextTick);
-    draining = true;
-
-    var len = queue.length;
-    while(len) {
-        currentQueue = queue;
-        queue = [];
-        while (++queueIndex < len) {
-            if (currentQueue) {
-                currentQueue[queueIndex].run();
-            }
-        }
-        queueIndex = -1;
-        len = queue.length;
-    }
-    currentQueue = null;
-    draining = false;
-    runClearTimeout(timeout);
-}
-
-process.nextTick = function (fun) {
-    var args = new Array(arguments.length - 1);
-    if (arguments.length > 1) {
-        for (var i = 1; i < arguments.length; i++) {
-            args[i - 1] = arguments[i];
-        }
-    }
-    queue.push(new Item(fun, args));
-    if (queue.length === 1 && !draining) {
-        runTimeout(drainQueue);
-    }
-};
-
-// v8 likes predictible objects
-function Item(fun, array) {
-    this.fun = fun;
-    this.array = array;
-}
-Item.prototype.run = function () {
-    this.fun.apply(null, this.array);
-};
-process.title = 'browser';
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = ''; // empty string to avoid regexp issues
-process.versions = {};
-
-function noop() {}
-
-process.on = noop;
-process.addListener = noop;
-process.once = noop;
-process.off = noop;
-process.removeListener = noop;
-process.removeAllListeners = noop;
-process.emit = noop;
-process.prependListener = noop;
-process.prependOnceListener = noop;
-
-process.listeners = function (name) { return [] }
-
-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; };
-
-},{}],126:[function(require,module,exports){
-exports.publicEncrypt = require('./publicEncrypt');
-exports.privateDecrypt = require('./privateDecrypt');
-
-exports.privateEncrypt = function privateEncrypt(key, buf) {
-  return exports.publicEncrypt(key, buf, true);
-};
-
-exports.publicDecrypt = function publicDecrypt(key, buf) {
-  return exports.privateDecrypt(key, buf, true);
-};
-},{"./privateDecrypt":128,"./publicEncrypt":129}],127:[function(require,module,exports){
-(function (Buffer){
-var createHash = require('create-hash');
-module.exports = function (seed, len) {
-  var t = new Buffer('');
-  var  i = 0, c;
-  while (t.length < len) {
-    c = i2ops(i++);
-    t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()]);
-  }
-  return t.slice(0, len);
-};
-
-function i2ops(c) {
-  var out = new Buffer(4);
-  out.writeUInt32BE(c,0);
-  return out;
-}
-}).call(this,require("buffer").Buffer)
-},{"buffer":55,"create-hash":59}],128:[function(require,module,exports){
-(function (Buffer){
-var parseKeys = require('parse-asn1');
-var mgf = require('./mgf');
-var xor = require('./xor');
-var bn = require('bn.js');
-var crt = require('browserify-rsa');
-var createHash = require('create-hash');
-var withPublic = require('./withPublic');
-module.exports = function privateDecrypt(private_key, enc, reverse) {
-  var padding;
-  if (private_key.padding) {
-    padding = private_key.padding;
-  } else if (reverse) {
-    padding = 1;
-  } else {
-    padding = 4;
-  }
-  
-  var key = parseKeys(private_key);
-  var k = key.modulus.byteLength();
-  if (enc.length > k || new bn(enc).cmp(key.modulus) >= 0) {
-    throw new Error('decryption error');
-  }
-  var msg;
-  if (reverse) {
-    msg = withPublic(new bn(enc), key);
-  } else {
-    msg = crt(enc, key);
-  }
-  var zBuffer = new Buffer(k - msg.length);
-  zBuffer.fill(0);
-  msg = Buffer.concat([zBuffer, msg], k);
-  if (padding === 4) {
-    return oaep(key, msg);
-  } else if (padding === 1) {
-    return pkcs1(key, msg, reverse);
-  } else if (padding === 3) {
-    return msg;
-  } else {
-    throw new Error('unknown padding');
-  }
-};
-
-function oaep(key, msg){
-  var n = key.modulus;
-  var k = key.modulus.byteLength();
-  var mLen = msg.length;
-  var iHash = createHash('sha1').update(new Buffer('')).digest();
-  var hLen = iHash.length;
-  var hLen2 = 2 * hLen;
-  if (msg[0] !== 0) {
-    throw new Error('decryption error');
-  }
-  var maskedSeed = msg.slice(1, hLen + 1);
-  var maskedDb =  msg.slice(hLen + 1);
-  var seed = xor(maskedSeed, mgf(maskedDb, hLen));
-  var db = xor(maskedDb, mgf(seed, k - hLen - 1));
-  if (compare(iHash, db.slice(0, hLen))) {
-    throw new Error('decryption error');
-  }
-  var i = hLen;
-  while (db[i] === 0) {
-    i++;
-  }
-  if (db[i++] !== 1) {
-    throw new Error('decryption error');
-  }
-  return db.slice(i);
-}
-
-function pkcs1(key, msg, reverse){
-  var p1 = msg.slice(0, 2);
-  var i = 2;
-  var status = 0;
-  while (msg[i++] !== 0) {
-    if (i >= msg.length) {
-      status++;
-      break;
-    }
-  }
-  var ps = msg.slice(2, i - 1);
-  var p2 = msg.slice(i - 1, i);
-
-  if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)){
-    status++;
-  }
-  if (ps.length < 8) {
-    status++;
-  }
-  if (status) {
-    throw new Error('decryption error');
-  }
-  return  msg.slice(i);
-}
-function compare(a, b){
-  a = new Buffer(a);
-  b = new Buffer(b);
-  var dif = 0;
-  var len = a.length;
-  if (a.length !== b.length) {
-    dif++;
-    len = Math.min(a.length, b.length);
-  }
-  var i = -1;
-  while (++i < len) {
-    dif += (a[i] ^ b[i]);
-  }
-  return dif;
-}
-}).call(this,require("buffer").Buffer)
-},{"./mgf":127,"./withPublic":130,"./xor":131,"bn.js":24,"browserify-rsa":47,"buffer":55,"create-hash":59,"parse-asn1":118}],129:[function(require,module,exports){
-(function (Buffer){
-var parseKeys = require('parse-asn1');
-var randomBytes = require('randombytes');
-var createHash = require('create-hash');
-var mgf = require('./mgf');
-var xor = require('./xor');
-var bn = require('bn.js');
-var withPublic = require('./withPublic');
-var crt = require('browserify-rsa');
-
-var constants = {
-  RSA_PKCS1_OAEP_PADDING: 4,
-  RSA_PKCS1_PADDIN: 1,
-  RSA_NO_PADDING: 3
-};
-
-module.exports = function publicEncrypt(public_key, msg, reverse) {
-  var padding;
-  if (public_key.padding) {
-    padding = public_key.padding;
-  } else if (reverse) {
-    padding = 1;
-  } else {
-    padding = 4;
-  }
-  var key = parseKeys(public_key);
-  var paddedMsg;
-  if (padding === 4) {
-    paddedMsg = oaep(key, msg);
-  } else if (padding === 1) {
-    paddedMsg = pkcs1(key, msg, reverse);
-  } else if (padding === 3) {
-    paddedMsg = new bn(msg);
-    if (paddedMsg.cmp(key.modulus) >= 0) {
-      throw new Error('data too long for modulus');
-    }
-  } else {
-    throw new Error('unknown padding');
-  }
-  if (reverse) {
-    return crt(paddedMsg, key);
-  } else {
-    return withPublic(paddedMsg, key);
-  }
-};
-
-function oaep(key, msg){
-  var k = key.modulus.byteLength();
-  var mLen = msg.length;
-  var iHash = createHash('sha1').update(new Buffer('')).digest();
-  var hLen = iHash.length;
-  var hLen2 = 2 * hLen;
-  if (mLen > k - hLen2 - 2) {
-    throw new Error('message too long');
-  }
-  var ps = new Buffer(k - mLen - hLen2 - 2);
-  ps.fill(0);
-  var dblen = k - hLen - 1;
-  var seed = randomBytes(hLen);
-  var maskedDb = xor(Buffer.concat([iHash, ps, new Buffer([1]), msg], dblen), mgf(seed, dblen));
-  var maskedSeed = xor(seed, mgf(maskedDb, hLen));
-  return new bn(Buffer.concat([new Buffer([0]), maskedSeed, maskedDb], k));
-}
-function pkcs1(key, msg, reverse){
-  var mLen = msg.length;
-  var k = key.modulus.byteLength();
-  if (mLen > k - 11) {
-    throw new Error('message too long');
-  }
-  var ps;
-  if (reverse) {
-    ps = new Buffer(k - mLen - 3);
-    ps.fill(0xff);
-  } else {
-    ps = nonZero(k - mLen - 3);
-  }
-  return new bn(Buffer.concat([new Buffer([0, reverse?1:2]), ps, new Buffer([0]), msg], k));
-}
-function nonZero(len, crypto) {
-  var out = new Buffer(len);
-  var i = 0;
-  var cache = randomBytes(len*2);
-  var cur = 0;
-  var num;
-  while (i < len) {
-    if (cur === cache.length) {
-      cache = randomBytes(len*2);
-      cur = 0;
-    }
-    num = cache[cur++];
-    if (num) {
-      out[i++] = num;
-    }
-  }
-  return out;
-}
-}).call(this,require("buffer").Buffer)
-},{"./mgf":127,"./withPublic":130,"./xor":131,"bn.js":24,"browserify-rsa":47,"buffer":55,"create-hash":59,"parse-asn1":118,"randombytes":132}],130:[function(require,module,exports){
-(function (Buffer){
-var bn = require('bn.js');
-function withPublic(paddedMsg, key) {
-  return new Buffer(paddedMsg
-    .toRed(bn.mont(key.modulus))
-    .redPow(new bn(key.publicExponent))
-    .fromRed()
-    .toArray());
-}
-
-module.exports = withPublic;
-}).call(this,require("buffer").Buffer)
-},{"bn.js":24,"buffer":55}],131:[function(require,module,exports){
-module.exports = function xor(a, b) {
-  var len = a.length;
-  var i = -1;
-  while (++i < len) {
-    a[i] ^= b[i];
-  }
-  return a
-};
-},{}],132:[function(require,module,exports){
-arguments[4][6][0].apply(exports,arguments)
-},{"_process":125,"dup":6,"safe-buffer":148}],133:[function(require,module,exports){
-(function (process,global){
-'use strict'
-
-function oldBrowser () {
-  throw new Error('secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11')
-}
-var safeBuffer = require('safe-buffer')
-var randombytes = require('randombytes')
-var Buffer = safeBuffer.Buffer
-var kBufferMaxLength = safeBuffer.kMaxLength
-var crypto = global.crypto || global.msCrypto
-var kMaxUint32 = Math.pow(2, 32) - 1
-function assertOffset (offset, length) {
-  if (typeof offset !== 'number' || offset !== offset) { // eslint-disable-line no-self-compare
-    throw new TypeError('offset must be a number')
-  }
-
-  if (offset > kMaxUint32 || offset < 0) {
-    throw new TypeError('offset must be a uint32')
-  }
-
-  if (offset > kBufferMaxLength || offset > length) {
-    throw new RangeError('offset out of range')
-  }
-}
-
-function assertSize (size, offset, length) {
-  if (typeof size !== 'number' || size !== size) { // eslint-disable-line no-self-compare
-    throw new TypeError('size must be a number')
-  }
-
-  if (size > kMaxUint32 || size < 0) {
-    throw new TypeError('size must be a uint32')
-  }
-
-  if (size + offset > length || size > kBufferMaxLength) {
-    throw new RangeError('buffer too small')
-  }
-}
-if ((crypto && crypto.getRandomValues) || !process.browser) {
-  exports.randomFill = randomFill
-  exports.randomFillSync = randomFillSync
-} else {
-  exports.randomFill = oldBrowser
-  exports.randomFillSync = oldBrowser
-}
-function randomFill (buf, offset, size, cb) {
-  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
-    throw new TypeError('"buf" argument must be a Buffer or Uint8Array')
-  }
-
-  if (typeof offset === 'function') {
-    cb = offset
-    offset = 0
-    size = buf.length
-  } else if (typeof size === 'function') {
-    cb = size
-    size = buf.length - offset
-  } else if (typeof cb !== 'function') {
-    throw new TypeError('"cb" argument must be a function')
-  }
-  assertOffset(offset, buf.length)
-  assertSize(size, offset, buf.length)
-  return actualFill(buf, offset, size, cb)
-}
-
-function actualFill (buf, offset, size, cb) {
-  if (process.browser) {
-    var ourBuf = buf.buffer
-    var uint = new Uint8Array(ourBuf, offset, size)
-    crypto.getRandomValues(uint)
-    if (cb) {
-      process.nextTick(function () {
-        cb(null, buf)
-      })
-      return
-    }
-    return buf
-  }
-  if (cb) {
-    randombytes(size, function (err, bytes) {
-      if (err) {
-        return cb(err)
-      }
-      bytes.copy(buf, offset)
-      cb(null, buf)
-    })
-    return
-  }
-  var bytes = randombytes(size)
-  bytes.copy(buf, offset)
-  return buf
-}
-function randomFillSync (buf, offset, size) {
-  if (typeof offset === 'undefined') {
-    offset = 0
-  }
-  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
-    throw new TypeError('"buf" argument must be a Buffer or Uint8Array')
-  }
-
-  assertOffset(offset, buf.length)
-
-  if (size === undefined) size = buf.length - offset
-
-  assertSize(size, offset, buf.length)
-
-  return actualFill(buf, offset, size)
-}
-
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"_process":125,"randombytes":132,"safe-buffer":148}],134:[function(require,module,exports){
-module.exports = require('./lib/_stream_duplex.js');
-
-},{"./lib/_stream_duplex.js":135}],135:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a duplex stream is just a stream that is both readable and writable.
-// Since JS doesn't have multiple prototypal inheritance, this class
-// prototypally inherits from Readable, and then parasitically from
-// Writable.
-
-'use strict';
-
-/*<replacement>*/
-
-var pna = require('process-nextick-args');
-/*</replacement>*/
-
-/*<replacement>*/
-var objectKeys = Object.keys || function (obj) {
-  var keys = [];
-  for (var key in obj) {
-    keys.push(key);
-  }return keys;
-};
-/*</replacement>*/
-
-module.exports = Duplex;
-
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
-
-var Readable = require('./_stream_readable');
-var Writable = require('./_stream_writable');
-
-util.inherits(Duplex, Readable);
-
-{
-  // avoid scope creep, the keys array can then be collected
-  var keys = objectKeys(Writable.prototype);
-  for (var v = 0; v < keys.length; v++) {
-    var method = keys[v];
-    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
-  }
-}
-
-function Duplex(options) {
-  if (!(this instanceof Duplex)) return new Duplex(options);
-
-  Readable.call(this, options);
-  Writable.call(this, options);
-
-  if (options && options.readable === false) this.readable = false;
-
-  if (options && options.writable === false) this.writable = false;
-
-  this.allowHalfOpen = true;
-  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
-
-  this.once('end', onend);
-}
-
-Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function () {
-    return this._writableState.highWaterMark;
-  }
-});
-
-// the no-half-open enforcer
-function onend() {
-  // if we allow half-open state, or if the writable side ended,
-  // then we're ok.
-  if (this.allowHalfOpen || this._writableState.ended) return;
-
-  // no more data can be written.
-  // But allow more writes to happen in this tick.
-  pna.nextTick(onEndNT, this);
-}
-
-function onEndNT(self) {
-  self.end();
-}
-
-Object.defineProperty(Duplex.prototype, 'destroyed', {
-  get: function () {
-    if (this._readableState === undefined || this._writableState === undefined) {
-      return false;
-    }
-    return this._readableState.destroyed && this._writableState.destroyed;
-  },
-  set: function (value) {
-    // we ignore the value if the stream
-    // has not been initialized yet
-    if (this._readableState === undefined || this._writableState === undefined) {
-      return;
-    }
-
-    // backward compatibility, the user is explicitly
-    // managing destroyed
-    this._readableState.destroyed = value;
-    this._writableState.destroyed = value;
-  }
-});
-
-Duplex.prototype._destroy = function (err, cb) {
-  this.push(null);
-  this.end();
-
-  pna.nextTick(cb, err);
-};
-},{"./_stream_readable":137,"./_stream_writable":139,"core-util-is":57,"inherits":107,"process-nextick-args":124}],136:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a passthrough stream.
-// basically just the most minimal sort of Transform stream.
-// Every written chunk gets output as-is.
-
-'use strict';
-
-module.exports = PassThrough;
-
-var Transform = require('./_stream_transform');
-
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
-
-util.inherits(PassThrough, Transform);
-
-function PassThrough(options) {
-  if (!(this instanceof PassThrough)) return new PassThrough(options);
-
-  Transform.call(this, options);
-}
-
-PassThrough.prototype._transform = function (chunk, encoding, cb) {
-  cb(null, chunk);
-};
-},{"./_stream_transform":138,"core-util-is":57,"inherits":107}],137:[function(require,module,exports){
-(function (process,global){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-'use strict';
-
-/*<replacement>*/
-
-var pna = require('process-nextick-args');
-/*</replacement>*/
-
-module.exports = Readable;
-
-/*<replacement>*/
-var isArray = require('isarray');
-/*</replacement>*/
-
-/*<replacement>*/
-var Duplex;
-/*</replacement>*/
-
-Readable.ReadableState = ReadableState;
-
-/*<replacement>*/
-var EE = require('events').EventEmitter;
-
-var EElistenerCount = function (emitter, type) {
-  return emitter.listeners(type).length;
-};
-/*</replacement>*/
-
-/*<replacement>*/
-var Stream = require('./internal/streams/stream');
-/*</replacement>*/
-
-/*<replacement>*/
-
-var Buffer = require('safe-buffer').Buffer;
-var OurUint8Array = global.Uint8Array || function () {};
-function _uint8ArrayToBuffer(chunk) {
-  return Buffer.from(chunk);
-}
-function _isUint8Array(obj) {
-  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
-}
-
-/*</replacement>*/
-
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
-
-/*<replacement>*/
-var debugUtil = require('util');
-var debug = void 0;
-if (debugUtil && debugUtil.debuglog) {
-  debug = debugUtil.debuglog('stream');
-} else {
-  debug = function () {};
-}
-/*</replacement>*/
-
-var BufferList = require('./internal/streams/BufferList');
-var destroyImpl = require('./internal/streams/destroy');
-var StringDecoder;
-
-util.inherits(Readable, Stream);
-
-var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
-
-function prependListener(emitter, event, fn) {
-  // Sadly this is not cacheable as some libraries bundle their own
-  // event emitter implementation with them.
-  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
-
-  // This is a hack to make sure that our error handler is attached before any
-  // userland ones.  NEVER DO THIS. This is here only because this code needs
-  // to continue to work with older versions of Node.js that do not include
-  // the prependListener() method. The goal is to eventually remove this hack.
-  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
-}
-
-function ReadableState(options, stream) {
-  Duplex = Duplex || require('./_stream_duplex');
-
-  options = options || {};
-
-  // Duplex streams are both readable and writable, but share
-  // the same options object.
-  // However, some cases require setting options to different
-  // values for the readable and the writable sides of the duplex stream.
-  // These options can be provided separately as readableXXX and writableXXX.
-  var isDuplex = stream instanceof Duplex;
-
-  // object stream flag. Used to make read(n) ignore n and to
-  // make all the buffer merging and length checks go away
-  this.objectMode = !!options.objectMode;
-
-  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
-
-  // the point at which it stops calling _read() to fill the buffer
-  // Note: 0 is a valid value, means "don't call _read preemptively ever"
-  var hwm = options.highWaterMark;
-  var readableHwm = options.readableHighWaterMark;
-  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
-
-  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
-
-  // cast to ints.
-  this.highWaterMark = Math.floor(this.highWaterMark);
-
-  // A linked list is used to store data chunks instead of an array because the
-  // linked list can remove elements from the beginning faster than
-  // array.shift()
-  this.buffer = new BufferList();
-  this.length = 0;
-  this.pipes = null;
-  this.pipesCount = 0;
-  this.flowing = null;
-  this.ended = false;
-  this.endEmitted = false;
-  this.reading = false;
-
-  // a flag to be able to tell if the event 'readable'/'data' is emitted
-  // immediately, or on a later tick.  We set this to true at first, because
-  // any actions that shouldn't happen until "later" should generally also
-  // not happen before the first read call.
-  this.sync = true;
-
-  // whenever we return null, then we set a flag to say
-  // that we're awaiting a 'readable' event emission.
-  this.needReadable = false;
-  this.emittedReadable = false;
-  this.readableListening = false;
-  this.resumeScheduled = false;
-
-  // has it been destroyed
-  this.destroyed = false;
-
-  // Crypto is kind of old and crusty.  Historically, its default string
-  // encoding is 'binary' so we have to make this configurable.
-  // Everything else in the universe uses 'utf8', though.
-  this.defaultEncoding = options.defaultEncoding || 'utf8';
-
-  // the number of writers that are awaiting a drain event in .pipe()s
-  this.awaitDrain = 0;
-
-  // if true, a maybeReadMore has been scheduled
-  this.readingMore = false;
-
-  this.decoder = null;
-  this.encoding = null;
-  if (options.encoding) {
-    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
-    this.decoder = new StringDecoder(options.encoding);
-    this.encoding = options.encoding;
-  }
-}
-
-function Readable(options) {
-  Duplex = Duplex || require('./_stream_duplex');
-
-  if (!(this instanceof Readable)) return new Readable(options);
-
-  this._readableState = new ReadableState(options, this);
-
-  // legacy
-  this.readable = true;
-
-  if (options) {
-    if (typeof options.read === 'function') this._read = options.read;
-
-    if (typeof options.destroy === 'function') this._destroy = options.destroy;
-  }
-
-  Stream.call(this);
-}
-
-Object.defineProperty(Readable.prototype, 'destroyed', {
-  get: function () {
-    if (this._readableState === undefined) {
-      return false;
-    }
-    return this._readableState.destroyed;
-  },
-  set: function (value) {
-    // we ignore the value if the stream
-    // has not been initialized yet
-    if (!this._readableState) {
-      return;
-    }
-
-    // backward compatibility, the user is explicitly
-    // managing destroyed
-    this._readableState.destroyed = value;
-  }
-});
-
-Readable.prototype.destroy = destroyImpl.destroy;
-Readable.prototype._undestroy = destroyImpl.undestroy;
-Readable.prototype._destroy = function (err, cb) {
-  this.push(null);
-  cb(err);
-};
-
-// Manually shove something into the read() buffer.
-// This returns true if the highWaterMark has not been hit yet,
-// similar to how Writable.write() returns true if you should
-// write() some more.
-Readable.prototype.push = function (chunk, encoding) {
-  var state = this._readableState;
-  var skipChunkCheck;
-
-  if (!state.objectMode) {
-    if (typeof chunk === 'string') {
-      encoding = encoding || state.defaultEncoding;
-      if (encoding !== state.encoding) {
-        chunk = Buffer.from(chunk, encoding);
-        encoding = '';
-      }
-      skipChunkCheck = true;
-    }
-  } else {
-    skipChunkCheck = true;
-  }
-
-  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
-};
-
-// Unshift should *always* be something directly out of read()
-Readable.prototype.unshift = function (chunk) {
-  return readableAddChunk(this, chunk, null, true, false);
-};
-
-function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
-  var state = stream._readableState;
-  if (chunk === null) {
-    state.reading = false;
-    onEofChunk(stream, state);
-  } else {
-    var er;
-    if (!skipChunkCheck) er = chunkInvalid(state, chunk);
-    if (er) {
-      stream.emit('error', er);
-    } else if (state.objectMode || chunk && chunk.length > 0) {
-      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
-        chunk = _uint8ArrayToBuffer(chunk);
-      }
-
-      if (addToFront) {
-        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
-      } else if (state.ended) {
-        stream.emit('error', new Error('stream.push() after EOF'));
-      } else {
-        state.reading = false;
-        if (state.decoder && !encoding) {
-          chunk = state.decoder.write(chunk);
-          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
-        } else {
-          addChunk(stream, state, chunk, false);
-        }
-      }
-    } else if (!addToFront) {
-      state.reading = false;
-    }
-  }
-
-  return needMoreData(state);
-}
-
-function addChunk(stream, state, chunk, addToFront) {
-  if (state.flowing && state.length === 0 && !state.sync) {
-    stream.emit('data', chunk);
-    stream.read(0);
-  } else {
-    // update the buffer info.
-    state.length += state.objectMode ? 1 : chunk.length;
-    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
-
-    if (state.needReadable) emitReadable(stream);
-  }
-  maybeReadMore(stream, state);
-}
-
-function chunkInvalid(state, chunk) {
-  var er;
-  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
-    er = new TypeError('Invalid non-string/buffer chunk');
-  }
-  return er;
-}
-
-// if it's past the high water mark, we can push in some more.
-// Also, if we have no data yet, we can stand some
-// more bytes.  This is to work around cases where hwm=0,
-// such as the repl.  Also, if the push() triggered a
-// readable event, and the user called read(largeNumber) such that
-// needReadable was set, then we ought to push more, so that another
-// 'readable' event will be triggered.
-function needMoreData(state) {
-  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
-}
-
-Readable.prototype.isPaused = function () {
-  return this._readableState.flowing === false;
-};
-
-// backwards compatibility.
-Readable.prototype.setEncoding = function (enc) {
-  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
-  this._readableState.decoder = new StringDecoder(enc);
-  this._readableState.encoding = enc;
-  return this;
-};
-
-// Don't raise the hwm > 8MB
-var MAX_HWM = 0x800000;
-function computeNewHighWaterMark(n) {
-  if (n >= MAX_HWM) {
-    n = MAX_HWM;
-  } else {
-    // Get the next highest power of 2 to prevent increasing hwm excessively in
-    // tiny amounts
-    n--;
-    n |= n >>> 1;
-    n |= n >>> 2;
-    n |= n >>> 4;
-    n |= n >>> 8;
-    n |= n >>> 16;
-    n++;
-  }
-  return n;
-}
-
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function howMuchToRead(n, state) {
-  if (n <= 0 || state.length === 0 && state.ended) return 0;
-  if (state.objectMode) return 1;
-  if (n !== n) {
-    // Only flow one buffer at a time
-    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
-  }
-  // If we're asking for more than the current hwm, then raise the hwm.
-  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
-  if (n <= state.length) return n;
-  // Don't have enough
-  if (!state.ended) {
-    state.needReadable = true;
-    return 0;
-  }
-  return state.length;
-}
-
-// you can override either this method, or the async _read(n) below.
-Readable.prototype.read = function (n) {
-  debug('read', n);
-  n = parseInt(n, 10);
-  var state = this._readableState;
-  var nOrig = n;
-
-  if (n !== 0) state.emittedReadable = false;
-
-  // if we're doing read(0) to trigger a readable event, but we
-  // already have a bunch of data in the buffer, then just trigger
-  // the 'readable' event and move on.
-  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
-    debug('read: emitReadable', state.length, state.ended);
-    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
-    return null;
-  }
-
-  n = howMuchToRead(n, state);
-
-  // if we've ended, and we're now clear, then finish it up.
-  if (n === 0 && state.ended) {
-    if (state.length === 0) endReadable(this);
-    return null;
-  }
-
-  // All the actual chunk generation logic needs to be
-  // *below* the call to _read.  The reason is that in certain
-  // synthetic stream cases, such as passthrough streams, _read
-  // may be a completely synchronous operation which may change
-  // the state of the read buffer, providing enough data when
-  // before there was *not* enough.
-  //
-  // So, the steps are:
-  // 1. Figure out what the state of things will be after we do
-  // a read from the buffer.
-  //
-  // 2. If that resulting state will trigger a _read, then call _read.
-  // Note that this may be asynchronous, or synchronous.  Yes, it is
-  // deeply ugly to write APIs this way, but that still doesn't mean
-  // that the Readable class should behave improperly, as streams are
-  // designed to be sync/async agnostic.
-  // Take note if the _read call is sync or async (ie, if the read call
-  // has returned yet), so that we know whether or not it's safe to emit
-  // 'readable' etc.
-  //
-  // 3. Actually pull the requested chunks out of the buffer and return.
-
-  // if we need a readable event, then we need to do some reading.
-  var doRead = state.needReadable;
-  debug('need readable', doRead);
-
-  // if we currently have less than the highWaterMark, then also read some
-  if (state.length === 0 || state.length - n < state.highWaterMark) {
-    doRead = true;
-    debug('length less than watermark', doRead);
-  }
-
-  // however, if we've ended, then there's no point, and if we're already
-  // reading, then it's unnecessary.
-  if (state.ended || state.reading) {
-    doRead = false;
-    debug('reading or ended', doRead);
-  } else if (doRead) {
-    debug('do read');
-    state.reading = true;
-    state.sync = true;
-    // if the length is currently zero, then we *need* a readable event.
-    if (state.length === 0) state.needReadable = true;
-    // call internal read method
-    this._read(state.highWaterMark);
-    state.sync = false;
-    // If _read pushed data synchronously, then `reading` will be false,
-    // and we need to re-evaluate how much data we can return to the user.
-    if (!state.reading) n = howMuchToRead(nOrig, state);
-  }
-
-  var ret;
-  if (n > 0) ret = fromList(n, state);else ret = null;
-
-  if (ret === null) {
-    state.needReadable = true;
-    n = 0;
-  } else {
-    state.length -= n;
-  }
-
-  if (state.length === 0) {
-    // If we have nothing in the buffer, then we want to know
-    // as soon as we *do* get something into the buffer.
-    if (!state.ended) state.needReadable = true;
-
-    // If we tried to read() past the EOF, then emit end on the next tick.
-    if (nOrig !== n && state.ended) endReadable(this);
-  }
-
-  if (ret !== null) this.emit('data', ret);
-
-  return ret;
-};
-
-function onEofChunk(stream, state) {
-  if (state.ended) return;
-  if (state.decoder) {
-    var chunk = state.decoder.end();
-    if (chunk && chunk.length) {
-      state.buffer.push(chunk);
-      state.length += state.objectMode ? 1 : chunk.length;
-    }
-  }
-  state.ended = true;
-
-  // emit 'readable' now to make sure it gets picked up.
-  emitReadable(stream);
-}
-
-// Don't emit readable right away in sync mode, because this can trigger
-// another read() call => stack overflow.  This way, it might trigger
-// a nextTick recursion warning, but that's not so bad.
-function emitReadable(stream) {
-  var state = stream._readableState;
-  state.needReadable = false;
-  if (!state.emittedReadable) {
-    debug('emitReadable', state.flowing);
-    state.emittedReadable = true;
-    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
-  }
-}
-
-function emitReadable_(stream) {
-  debug('emit readable');
-  stream.emit('readable');
-  flow(stream);
-}
-
-// at this point, the user has presumably seen the 'readable' event,
-// and called read() to consume some data.  that may have triggered
-// in turn another _read(n) call, in which case reading = true if
-// it's in progress.
-// However, if we're not ended, or reading, and the length < hwm,
-// then go ahead and try to read some more preemptively.
-function maybeReadMore(stream, state) {
-  if (!state.readingMore) {
-    state.readingMore = true;
-    pna.nextTick(maybeReadMore_, stream, state);
-  }
-}
-
-function maybeReadMore_(stream, state) {
-  var len = state.length;
-  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
-    debug('maybeReadMore read 0');
-    stream.read(0);
-    if (len === state.length)
-      // didn't get any data, stop spinning.
-      break;else len = state.length;
-  }
-  state.readingMore = false;
-}
-
-// abstract method.  to be overridden in specific implementation classes.
-// call cb(er, data) where data is <= n in length.
-// for virtual (non-string, non-buffer) streams, "length" is somewhat
-// arbitrary, and perhaps not very meaningful.
-Readable.prototype._read = function (n) {
-  this.emit('error', new Error('_read() is not implemented'));
-};
-
-Readable.prototype.pipe = function (dest, pipeOpts) {
-  var src = this;
-  var state = this._readableState;
-
-  switch (state.pipesCount) {
-    case 0:
-      state.pipes = dest;
-      break;
-    case 1:
-      state.pipes = [state.pipes, dest];
-      break;
-    default:
-      state.pipes.push(dest);
-      break;
-  }
-  state.pipesCount += 1;
-  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
-
-  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
-
-  var endFn = doEnd ? onend : unpipe;
-  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
-
-  dest.on('unpipe', onunpipe);
-  function onunpipe(readable, unpipeInfo) {
-    debug('onunpipe');
-    if (readable === src) {
-      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
-        unpipeInfo.hasUnpiped = true;
-        cleanup();
-      }
-    }
-  }
-
-  function onend() {
-    debug('onend');
-    dest.end();
-  }
-
-  // when the dest drains, it reduces the awaitDrain counter
-  // on the source.  This would be more elegant with a .once()
-  // handler in flow(), but adding and removing repeatedly is
-  // too slow.
-  var ondrain = pipeOnDrain(src);
-  dest.on('drain', ondrain);
-
-  var cleanedUp = false;
-  function cleanup() {
-    debug('cleanup');
-    // cleanup event handlers once the pipe is broken
-    dest.removeListener('close', onclose);
-    dest.removeListener('finish', onfinish);
-    dest.removeListener('drain', ondrain);
-    dest.removeListener('error', onerror);
-    dest.removeListener('unpipe', onunpipe);
-    src.removeListener('end', onend);
-    src.removeListener('end', unpipe);
-    src.removeListener('data', ondata);
-
-    cleanedUp = true;
-
-    // if the reader is waiting for a drain event from this
-    // specific writer, then it would cause it to never start
-    // flowing again.
-    // So, if this is awaiting a drain, then we just call it now.
-    // If we don't know, then assume that we are waiting for one.
-    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
-  }
-
-  // If the user pushes more data while we're writing to dest then we'll end up
-  // in ondata again. However, we only want to increase awaitDrain once because
-  // dest will only emit one 'drain' event for the multiple writes.
-  // => Introduce a guard on increasing awaitDrain.
-  var increasedAwaitDrain = false;
-  src.on('data', ondata);
-  function ondata(chunk) {
-    debug('ondata');
-    increasedAwaitDrain = false;
-    var ret = dest.write(chunk);
-    if (false === ret && !increasedAwaitDrain) {
-      // If the user unpiped during `dest.write()`, it is possible
-      // to get stuck in a permanently paused state if that write
-      // also returned false.
-      // => Check whether `dest` is still a piping destination.
-      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
-        debug('false write response, pause', src._readableState.awaitDrain);
-        src._readableState.awaitDrain++;
-        increasedAwaitDrain = true;
-      }
-      src.pause();
-    }
-  }
-
-  // if the dest has an error, then stop piping into it.
-  // however, don't suppress the throwing behavior for this.
-  function onerror(er) {
-    debug('onerror', er);
-    unpipe();
-    dest.removeListener('error', onerror);
-    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
-  }
-
-  // Make sure our error handler is attached before userland ones.
-  prependListener(dest, 'error', onerror);
-
-  // Both close and finish should trigger unpipe, but only once.
-  function onclose() {
-    dest.removeListener('finish', onfinish);
-    unpipe();
-  }
-  dest.once('close', onclose);
-  function onfinish() {
-    debug('onfinish');
-    dest.removeListener('close', onclose);
-    unpipe();
-  }
-  dest.once('finish', onfinish);
-
-  function unpipe() {
-    debug('unpipe');
-    src.unpipe(dest);
-  }
-
-  // tell the dest that it's being piped to
-  dest.emit('pipe', src);
-
-  // start the flow if it hasn't been started already.
-  if (!state.flowing) {
-    debug('pipe resume');
-    src.resume();
-  }
-
-  return dest;
-};
-
-function pipeOnDrain(src) {
-  return function () {
-    var state = src._readableState;
-    debug('pipeOnDrain', state.awaitDrain);
-    if (state.awaitDrain) state.awaitDrain--;
-    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
-      state.flowing = true;
-      flow(src);
-    }
-  };
-}
-
-Readable.prototype.unpipe = function (dest) {
-  var state = this._readableState;
-  var unpipeInfo = { hasUnpiped: false };
-
-  // if we're not piping anywhere, then do nothing.
-  if (state.pipesCount === 0) return this;
-
-  // just one destination.  most common case.
-  if (state.pipesCount === 1) {
-    // passed in one, but it's not the right one.
-    if (dest && dest !== state.pipes) return this;
-
-    if (!dest) dest = state.pipes;
-
-    // got a match.
-    state.pipes = null;
-    state.pipesCount = 0;
-    state.flowing = false;
-    if (dest) dest.emit('unpipe', this, unpipeInfo);
-    return this;
-  }
-
-  // slow case. multiple pipe destinations.
-
-  if (!dest) {
-    // remove all.
-    var dests = state.pipes;
-    var len = state.pipesCount;
-    state.pipes = null;
-    state.pipesCount = 0;
-    state.flowing = false;
-
-    for (var i = 0; i < len; i++) {
-      dests[i].emit('unpipe', this, unpipeInfo);
-    }return this;
-  }
-
-  // try to find the right one.
-  var index = indexOf(state.pipes, dest);
-  if (index === -1) return this;
-
-  state.pipes.splice(index, 1);
-  state.pipesCount -= 1;
-  if (state.pipesCount === 1) state.pipes = state.pipes[0];
-
-  dest.emit('unpipe', this, unpipeInfo);
-
-  return this;
-};
-
-// set up data events if they are asked for
-// Ensure readable listeners eventually get something
-Readable.prototype.on = function (ev, fn) {
-  var res = Stream.prototype.on.call(this, ev, fn);
-
-  if (ev === 'data') {
-    // Start flowing on next tick if stream isn't explicitly paused
-    if (this._readableState.flowing !== false) this.resume();
-  } else if (ev === 'readable') {
-    var state = this._readableState;
-    if (!state.endEmitted && !state.readableListening) {
-      state.readableListening = state.needReadable = true;
-      state.emittedReadable = false;
-      if (!state.reading) {
-        pna.nextTick(nReadingNextTick, this);
-      } else if (state.length) {
-        emitReadable(this);
-      }
-    }
-  }
-
-  return res;
-};
-Readable.prototype.addListener = Readable.prototype.on;
-
-function nReadingNextTick(self) {
-  debug('readable nexttick read 0');
-  self.read(0);
-}
-
-// pause() and resume() are remnants of the legacy readable stream API
-// If the user uses them, then switch into old mode.
-Readable.prototype.resume = function () {
-  var state = this._readableState;
-  if (!state.flowing) {
-    debug('resume');
-    state.flowing = true;
-    resume(this, state);
-  }
-  return this;
-};
-
-function resume(stream, state) {
-  if (!state.resumeScheduled) {
-    state.resumeScheduled = true;
-    pna.nextTick(resume_, stream, state);
-  }
-}
-
-function resume_(stream, state) {
-  if (!state.reading) {
-    debug('resume read 0');
-    stream.read(0);
-  }
-
-  state.resumeScheduled = false;
-  state.awaitDrain = 0;
-  stream.emit('resume');
-  flow(stream);
-  if (state.flowing && !state.reading) stream.read(0);
-}
-
-Readable.prototype.pause = function () {
-  debug('call pause flowing=%j', this._readableState.flowing);
-  if (false !== this._readableState.flowing) {
-    debug('pause');
-    this._readableState.flowing = false;
-    this.emit('pause');
-  }
-  return this;
-};
-
-function flow(stream) {
-  var state = stream._readableState;
-  debug('flow', state.flowing);
-  while (state.flowing && stream.read() !== null) {}
-}
-
-// wrap an old-style stream as the async data source.
-// This is *not* part of the readable stream interface.
-// It is an ugly unfortunate mess of history.
-Readable.prototype.wrap = function (stream) {
-  var _this = this;
-
-  var state = this._readableState;
-  var paused = false;
-
-  stream.on('end', function () {
-    debug('wrapped end');
-    if (state.decoder && !state.ended) {
-      var chunk = state.decoder.end();
-      if (chunk && chunk.length) _this.push(chunk);
-    }
-
-    _this.push(null);
-  });
-
-  stream.on('data', function (chunk) {
-    debug('wrapped data');
-    if (state.decoder) chunk = state.decoder.write(chunk);
-
-    // don't skip over falsy values in objectMode
-    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
-
-    var ret = _this.push(chunk);
-    if (!ret) {
-      paused = true;
-      stream.pause();
-    }
-  });
-
-  // proxy all the other methods.
-  // important when wrapping filters and duplexes.
-  for (var i in stream) {
-    if (this[i] === undefined && typeof stream[i] === 'function') {
-      this[i] = function (method) {
-        return function () {
-          return stream[method].apply(stream, arguments);
-        };
-      }(i);
-    }
-  }
-
-  // proxy certain important events.
-  for (var n = 0; n < kProxyEvents.length; n++) {
-    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
-  }
-
-  // when we try to consume some more bytes, simply unpause the
-  // underlying stream.
-  this._read = function (n) {
-    debug('wrapped _read', n);
-    if (paused) {
-      paused = false;
-      stream.resume();
-    }
-  };
-
-  return this;
-};
-
-Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function () {
-    return this._readableState.highWaterMark;
-  }
-});
-
-// exposed for testing purposes only.
-Readable._fromList = fromList;
-
-// Pluck off n bytes from an array of buffers.
-// Length is the combined lengths of all the buffers in the list.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function fromList(n, state) {
-  // nothing buffered
-  if (state.length === 0) return null;
-
-  var ret;
-  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
-    // read it all, truncate the list
-    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
-    state.buffer.clear();
-  } else {
-    // read part of list
-    ret = fromListPartial(n, state.buffer, state.decoder);
-  }
-
-  return ret;
-}
-
-// Extracts only enough buffered data to satisfy the amount requested.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function fromListPartial(n, list, hasStrings) {
-  var ret;
-  if (n < list.head.data.length) {
-    // slice is the same for buffers and strings
-    ret = list.head.data.slice(0, n);
-    list.head.data = list.head.data.slice(n);
-  } else if (n === list.head.data.length) {
-    // first chunk is a perfect match
-    ret = list.shift();
-  } else {
-    // result spans more than one buffer
-    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
-  }
-  return ret;
-}
-
-// Copies a specified amount of characters from the list of buffered data
-// chunks.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function copyFromBufferString(n, list) {
-  var p = list.head;
-  var c = 1;
-  var ret = p.data;
-  n -= ret.length;
-  while (p = p.next) {
-    var str = p.data;
-    var nb = n > str.length ? str.length : n;
-    if (nb === str.length) ret += str;else ret += str.slice(0, n);
-    n -= nb;
-    if (n === 0) {
-      if (nb === str.length) {
-        ++c;
-        if (p.next) list.head = p.next;else list.head = list.tail = null;
-      } else {
-        list.head = p;
-        p.data = str.slice(nb);
-      }
-      break;
-    }
-    ++c;
-  }
-  list.length -= c;
-  return ret;
-}
-
-// Copies a specified amount of bytes from the list of buffered data chunks.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function copyFromBuffer(n, list) {
-  var ret = Buffer.allocUnsafe(n);
-  var p = list.head;
-  var c = 1;
-  p.data.copy(ret);
-  n -= p.data.length;
-  while (p = p.next) {
-    var buf = p.data;
-    var nb = n > buf.length ? buf.length : n;
-    buf.copy(ret, ret.length - n, 0, nb);
-    n -= nb;
-    if (n === 0) {
-      if (nb === buf.length) {
-        ++c;
-        if (p.next) list.head = p.next;else list.head = list.tail = null;
-      } else {
-        list.head = p;
-        p.data = buf.slice(nb);
-      }
-      break;
-    }
-    ++c;
-  }
-  list.length -= c;
-  return ret;
-}
-
-function endReadable(stream) {
-  var state = stream._readableState;
-
-  // If we get here before consuming all the bytes, then that is a
-  // bug in node.  Should never happen.
-  if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
-
-  if (!state.endEmitted) {
-    state.ended = true;
-    pna.nextTick(endReadableNT, state, stream);
-  }
-}
-
-function endReadableNT(state, stream) {
-  // Check that we didn't get one last unshift.
-  if (!state.endEmitted && state.length === 0) {
-    state.endEmitted = true;
-    stream.readable = false;
-    stream.emit('end');
-  }
-}
-
-function indexOf(xs, x) {
-  for (var i = 0, l = xs.length; i < l; i++) {
-    if (xs[i] === x) return i;
-  }
-  return -1;
-}
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./_stream_duplex":135,"./internal/streams/BufferList":140,"./internal/streams/destroy":141,"./internal/streams/stream":142,"_process":125,"core-util-is":57,"events":90,"inherits":107,"isarray":109,"process-nextick-args":124,"safe-buffer":148,"string_decoder/":158,"util":26}],138:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a transform stream is a readable/writable stream where you do
-// something with the data.  Sometimes it's called a "filter",
-// but that's not a great name for it, since that implies a thing where
-// some bits pass through, and others are simply ignored.  (That would
-// be a valid example of a transform, of course.)
-//
-// While the output is causally related to the input, it's not a
-// necessarily symmetric or synchronous transformation.  For example,
-// a zlib stream might take multiple plain-text writes(), and then
-// emit a single compressed chunk some time in the future.
-//
-// Here's how this works:
-//
-// The Transform stream has all the aspects of the readable and writable
-// stream classes.  When you write(chunk), that calls _write(chunk,cb)
-// internally, and returns false if there's a lot of pending writes
-// buffered up.  When you call read(), that calls _read(n) until
-// there's enough pending readable data buffered up.
-//
-// In a transform stream, the written data is placed in a buffer.  When
-// _read(n) is called, it transforms the queued up data, calling the
-// buffered _write cb's as it consumes chunks.  If consuming a single
-// written chunk would result in multiple output chunks, then the first
-// outputted bit calls the readcb, and subsequent chunks just go into
-// the read buffer, and will cause it to emit 'readable' if necessary.
-//
-// This way, back-pressure is actually determined by the reading side,
-// since _read has to be called to start processing a new chunk.  However,
-// a pathological inflate type of transform can cause excessive buffering
-// here.  For example, imagine a stream where every byte of input is
-// interpreted as an integer from 0-255, and then results in that many
-// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
-// 1kb of data being output.  In this case, you could write a very small
-// amount of input, and end up with a very large amount of output.  In
-// such a pathological inflating mechanism, there'd be no way to tell
-// the system to stop doing the transform.  A single 4MB write could
-// cause the system to run out of memory.
-//
-// However, even in such a pathological case, only a single written chunk
-// would be consumed, and then the rest would wait (un-transformed) until
-// the results of the previous transformed chunk were consumed.
-
-'use strict';
-
-module.exports = Transform;
-
-var Duplex = require('./_stream_duplex');
-
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
-
-util.inherits(Transform, Duplex);
-
-function afterTransform(er, data) {
-  var ts = this._transformState;
-  ts.transforming = false;
-
-  var cb = ts.writecb;
-
-  if (!cb) {
-    return this.emit('error', new Error('write callback called multiple times'));
-  }
-
-  ts.writechunk = null;
-  ts.writecb = null;
-
-  if (data != null) // single equals check for both `null` and `undefined`
-    this.push(data);
-
-  cb(er);
-
-  var rs = this._readableState;
-  rs.reading = false;
-  if (rs.needReadable || rs.length < rs.highWaterMark) {
-    this._read(rs.highWaterMark);
-  }
-}
-
-function Transform(options) {
-  if (!(this instanceof Transform)) return new Transform(options);
-
-  Duplex.call(this, options);
-
-  this._transformState = {
-    afterTransform: afterTransform.bind(this),
-    needTransform: false,
-    transforming: false,
-    writecb: null,
-    writechunk: null,
-    writeencoding: null
-  };
-
-  // start out asking for a readable event once data is transformed.
-  this._readableState.needReadable = true;
-
-  // we have implemented the _read method, and done the other things
-  // that Readable wants before the first _read call, so unset the
-  // sync guard flag.
-  this._readableState.sync = false;
-
-  if (options) {
-    if (typeof options.transform === 'function') this._transform = options.transform;
-
-    if (typeof options.flush === 'function') this._flush = options.flush;
-  }
-
-  // When the writable side finishes, then flush out anything remaining.
-  this.on('prefinish', prefinish);
-}
-
-function prefinish() {
-  var _this = this;
-
-  if (typeof this._flush === 'function') {
-    this._flush(function (er, data) {
-      done(_this, er, data);
-    });
-  } else {
-    done(this, null, null);
-  }
-}
-
-Transform.prototype.push = function (chunk, encoding) {
-  this._transformState.needTransform = false;
-  return Duplex.prototype.push.call(this, chunk, encoding);
-};
-
-// This is the part where you do stuff!
-// override this function in implementation classes.
-// 'chunk' is an input chunk.
-//
-// Call `push(newChunk)` to pass along transformed output
-// to the readable side.  You may call 'push' zero or more times.
-//
-// Call `cb(err)` when you are done with this chunk.  If you pass
-// an error, then that'll put the hurt on the whole operation.  If you
-// never call cb(), then you'll never get another chunk.
-Transform.prototype._transform = function (chunk, encoding, cb) {
-  throw new Error('_transform() is not implemented');
-};
-
-Transform.prototype._write = function (chunk, encoding, cb) {
-  var ts = this._transformState;
-  ts.writecb = cb;
-  ts.writechunk = chunk;
-  ts.writeencoding = encoding;
-  if (!ts.transforming) {
-    var rs = this._readableState;
-    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
-  }
-};
-
-// Doesn't matter what the args are here.
-// _transform does all the work.
-// That we got here means that the readable side wants more data.
-Transform.prototype._read = function (n) {
-  var ts = this._transformState;
-
-  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
-    ts.transforming = true;
-    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
-  } else {
-    // mark that we need a transform, so that any data that comes in
-    // will get processed, now that we've asked for it.
-    ts.needTransform = true;
-  }
-};
-
-Transform.prototype._destroy = function (err, cb) {
-  var _this2 = this;
-
-  Duplex.prototype._destroy.call(this, err, function (err2) {
-    cb(err2);
-    _this2.emit('close');
-  });
-};
-
-function done(stream, er, data) {
-  if (er) return stream.emit('error', er);
-
-  if (data != null) // single equals check for both `null` and `undefined`
-    stream.push(data);
-
-  // if there's nothing in the write buffer, then that means
-  // that nothing more will ever be provided
-  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
-
-  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
-
-  return stream.push(null);
-}
-},{"./_stream_duplex":135,"core-util-is":57,"inherits":107}],139:[function(require,module,exports){
-(function (process,global,setImmediate){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// A bit simpler than readable streams.
-// Implement an async ._write(chunk, encoding, cb), and it'll handle all
-// the drain event emission and buffering.
-
-'use strict';
-
-/*<replacement>*/
-
-var pna = require('process-nextick-args');
-/*</replacement>*/
-
-module.exports = Writable;
-
-/* <replacement> */
-function WriteReq(chunk, encoding, cb) {
-  this.chunk = chunk;
-  this.encoding = encoding;
-  this.callback = cb;
-  this.next = null;
-}
-
-// It seems a linked list but it is not
-// there will be only 2 of these for each stream
-function CorkedRequest(state) {
-  var _this = this;
-
-  this.next = null;
-  this.entry = null;
-  this.finish = function () {
-    onCorkedFinish(_this, state);
-  };
-}
-/* </replacement> */
-
-/*<replacement>*/
-var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
-/*</replacement>*/
-
-/*<replacement>*/
-var Duplex;
-/*</replacement>*/
-
-Writable.WritableState = WritableState;
-
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
-
-/*<replacement>*/
-var internalUtil = {
-  deprecate: require('util-deprecate')
-};
-/*</replacement>*/
-
-/*<replacement>*/
-var Stream = require('./internal/streams/stream');
-/*</replacement>*/
-
-/*<replacement>*/
-
-var Buffer = require('safe-buffer').Buffer;
-var OurUint8Array = global.Uint8Array || function () {};
-function _uint8ArrayToBuffer(chunk) {
-  return Buffer.from(chunk);
-}
-function _isUint8Array(obj) {
-  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
-}
-
-/*</replacement>*/
-
-var destroyImpl = require('./internal/streams/destroy');
-
-util.inherits(Writable, Stream);
-
-function nop() {}
-
-function WritableState(options, stream) {
-  Duplex = Duplex || require('./_stream_duplex');
-
-  options = options || {};
-
-  // Duplex streams are both readable and writable, but share
-  // the same options object.
-  // However, some cases require setting options to different
-  // values for the readable and the writable sides of the duplex stream.
-  // These options can be provided separately as readableXXX and writableXXX.
-  var isDuplex = stream instanceof Duplex;
-
-  // object stream flag to indicate whether or not this stream
-  // contains buffers or objects.
-  this.objectMode = !!options.objectMode;
-
-  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
-
-  // the point at which write() starts returning false
-  // Note: 0 is a valid value, means that we always return false if
-  // the entire buffer is not flushed immediately on write()
-  var hwm = options.highWaterMark;
-  var writableHwm = options.writableHighWaterMark;
-  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
-
-  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
-
-  // cast to ints.
-  this.highWaterMark = Math.floor(this.highWaterMark);
-
-  // if _final has been called
-  this.finalCalled = false;
-
-  // drain event flag.
-  this.needDrain = false;
-  // at the start of calling end()
-  this.ending = false;
-  // when end() has been called, and returned
-  this.ended = false;
-  // when 'finish' is emitted
-  this.finished = false;
-
-  // has it been destroyed
-  this.destroyed = false;
-
-  // should we decode strings into buffers before passing to _write?
-  // this is here so that some node-core streams can optimize string
-  // handling at a lower level.
-  var noDecode = options.decodeStrings === false;
-  this.decodeStrings = !noDecode;
-
-  // Crypto is kind of old and crusty.  Historically, its default string
-  // encoding is 'binary' so we have to make this configurable.
-  // Everything else in the universe uses 'utf8', though.
-  this.defaultEncoding = options.defaultEncoding || 'utf8';
-
-  // not an actual buffer we keep track of, but a measurement
-  // of how much we're waiting to get pushed to some underlying
-  // socket or file.
-  this.length = 0;
-
-  // a flag to see when we're in the middle of a write.
-  this.writing = false;
-
-  // when true all writes will be buffered until .uncork() call
-  this.corked = 0;
-
-  // a flag to be able to tell if the onwrite cb is called immediately,
-  // or on a later tick.  We set this to true at first, because any
-  // actions that shouldn't happen until "later" should generally also
-  // not happen before the first write call.
-  this.sync = true;
-
-  // a flag to know if we're processing previously buffered items, which
-  // may call the _write() callback in the same tick, so that we don't
-  // end up in an overlapped onwrite situation.
-  this.bufferProcessing = false;
-
-  // the callback that's passed to _write(chunk,cb)
-  this.onwrite = function (er) {
-    onwrite(stream, er);
-  };
-
-  // the callback that the user supplies to write(chunk,encoding,cb)
-  this.writecb = null;
-
-  // the amount that is being written when _write is called.
-  this.writelen = 0;
-
-  this.bufferedRequest = null;
-  this.lastBufferedRequest = null;
-
-  // number of pending user-supplied write callbacks
-  // this must be 0 before 'finish' can be emitted
-  this.pendingcb = 0;
-
-  // emit prefinish if the only thing we're waiting for is _write cbs
-  // This is relevant for synchronous Transform streams
-  this.prefinished = false;
-
-  // True if the error was already emitted and should not be thrown again
-  this.errorEmitted = false;
-
-  // count buffered requests
-  this.bufferedRequestCount = 0;
-
-  // allocate the first CorkedRequest, there is always
-  // one allocated and free to use, and we maintain at most two
-  this.corkedRequestsFree = new CorkedRequest(this);
-}
-
-WritableState.prototype.getBuffer = function getBuffer() {
-  var current = this.bufferedRequest;
-  var out = [];
-  while (current) {
-    out.push(current);
-    current = current.next;
-  }
-  return out;
-};
-
-(function () {
-  try {
-    Object.defineProperty(WritableState.prototype, 'buffer', {
-      get: internalUtil.deprecate(function () {
-        return this.getBuffer();
-      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
-    });
-  } catch (_) {}
-})();
-
-// Test _writableState for inheritance to account for Duplex streams,
-// whose prototype chain only points to Readable.
-var realHasInstance;
-if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
-  realHasInstance = Function.prototype[Symbol.hasInstance];
-  Object.defineProperty(Writable, Symbol.hasInstance, {
-    value: function (object) {
-      if (realHasInstance.call(this, object)) return true;
-      if (this !== Writable) return false;
-
-      return object && object._writableState instanceof WritableState;
-    }
-  });
-} else {
-  realHasInstance = function (object) {
-    return object instanceof this;
-  };
-}
-
-function Writable(options) {
-  Duplex = Duplex || require('./_stream_duplex');
-
-  // Writable ctor is applied to Duplexes, too.
-  // `realHasInstance` is necessary because using plain `instanceof`
-  // would return false, as no `_writableState` property is attached.
-
-  // Trying to use the custom `instanceof` for Writable here will also break the
-  // Node.js LazyTransform implementation, which has a non-trivial getter for
-  // `_writableState` that would lead to infinite recursion.
-  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
-    return new Writable(options);
-  }
-
-  this._writableState = new WritableState(options, this);
-
-  // legacy.
-  this.writable = true;
-
-  if (options) {
-    if (typeof options.write === 'function') this._write = options.write;
-
-    if (typeof options.writev === 'function') this._writev = options.writev;
-
-    if (typeof options.destroy === 'function') this._destroy = options.destroy;
-
-    if (typeof options.final === 'function') this._final = options.final;
-  }
-
-  Stream.call(this);
-}
-
-// Otherwise people can pipe Writable streams, which is just wrong.
-Writable.prototype.pipe = function () {
-  this.emit('error', new Error('Cannot pipe, not readable'));
-};
-
-function writeAfterEnd(stream, cb) {
-  var er = new Error('write after end');
-  // TODO: defer error events consistently everywhere, not just the cb
-  stream.emit('error', er);
-  pna.nextTick(cb, er);
-}
-
-// Checks that a user-supplied chunk is valid, especially for the particular
-// mode the stream is in. Currently this means that `null` is never accepted
-// and undefined/non-string values are only allowed in object mode.
-function validChunk(stream, state, chunk, cb) {
-  var valid = true;
-  var er = false;
-
-  if (chunk === null) {
-    er = new TypeError('May not write null values to stream');
-  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
-    er = new TypeError('Invalid non-string/buffer chunk');
-  }
-  if (er) {
-    stream.emit('error', er);
-    pna.nextTick(cb, er);
-    valid = false;
-  }
-  return valid;
-}
-
-Writable.prototype.write = function (chunk, encoding, cb) {
-  var state = this._writableState;
-  var ret = false;
-  var isBuf = !state.objectMode && _isUint8Array(chunk);
-
-  if (isBuf && !Buffer.isBuffer(chunk)) {
-    chunk = _uint8ArrayToBuffer(chunk);
-  }
-
-  if (typeof encoding === 'function') {
-    cb = encoding;
-    encoding = null;
-  }
-
-  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
-
-  if (typeof cb !== 'function') cb = nop;
-
-  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
-    state.pendingcb++;
-    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
-  }
-
-  return ret;
-};
-
-Writable.prototype.cork = function () {
-  var state = this._writableState;
-
-  state.corked++;
-};
-
-Writable.prototype.uncork = function () {
-  var state = this._writableState;
-
-  if (state.corked) {
-    state.corked--;
-
-    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
-  }
-};
-
-Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
-  // node::ParseEncoding() requires lower case.
-  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
-  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
-  this._writableState.defaultEncoding = encoding;
-  return this;
-};
-
-function decodeChunk(state, chunk, encoding) {
-  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
-    chunk = Buffer.from(chunk, encoding);
-  }
-  return chunk;
-}
-
-Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
-  // making it explicit this property is not enumerable
-  // because otherwise some prototype manipulation in
-  // userland will fail
-  enumerable: false,
-  get: function () {
-    return this._writableState.highWaterMark;
-  }
-});
-
-// if we're already writing something, then just put this
-// in the queue, and wait our turn.  Otherwise, call _write
-// If we return false, then we need a drain event, so set that flag.
-function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
-  if (!isBuf) {
-    var newChunk = decodeChunk(state, chunk, encoding);
-    if (chunk !== newChunk) {
-      isBuf = true;
-      encoding = 'buffer';
-      chunk = newChunk;
-    }
-  }
-  var len = state.objectMode ? 1 : chunk.length;
-
-  state.length += len;
-
-  var ret = state.length < state.highWaterMark;
-  // we must ensure that previous needDrain will not be reset to false.
-  if (!ret) state.needDrain = true;
-
-  if (state.writing || state.corked) {
-    var last = state.lastBufferedRequest;
-    state.lastBufferedRequest = {
-      chunk: chunk,
-      encoding: encoding,
-      isBuf: isBuf,
-      callback: cb,
-      next: null
-    };
-    if (last) {
-      last.next = state.lastBufferedRequest;
-    } else {
-      state.bufferedRequest = state.lastBufferedRequest;
-    }
-    state.bufferedRequestCount += 1;
-  } else {
-    doWrite(stream, state, false, len, chunk, encoding, cb);
-  }
-
-  return ret;
-}
-
-function doWrite(stream, state, writev, len, chunk, encoding, cb) {
-  state.writelen = len;
-  state.writecb = cb;
-  state.writing = true;
-  state.sync = true;
-  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
-  state.sync = false;
-}
-
-function onwriteError(stream, state, sync, er, cb) {
-  --state.pendingcb;
-
-  if (sync) {
-    // defer the callback if we are being called synchronously
-    // to avoid piling up things on the stack
-    pna.nextTick(cb, er);
-    // this can emit finish, and it will always happen
-    // after error
-    pna.nextTick(finishMaybe, stream, state);
-    stream._writableState.errorEmitted = true;
-    stream.emit('error', er);
-  } else {
-    // the caller expect this to happen before if
-    // it is async
-    cb(er);
-    stream._writableState.errorEmitted = true;
-    stream.emit('error', er);
-    // this can emit finish, but finish must
-    // always follow error
-    finishMaybe(stream, state);
-  }
-}
-
-function onwriteStateUpdate(state) {
-  state.writing = false;
-  state.writecb = null;
-  state.length -= state.writelen;
-  state.writelen = 0;
-}
-
-function onwrite(stream, er) {
-  var state = stream._writableState;
-  var sync = state.sync;
-  var cb = state.writecb;
-
-  onwriteStateUpdate(state);
-
-  if (er) onwriteError(stream, state, sync, er, cb);else {
-    // Check if we're actually ready to finish, but don't emit yet
-    var finished = needFinish(state);
-
-    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
-      clearBuffer(stream, state);
-    }
-
-    if (sync) {
-      /*<replacement>*/
-      asyncWrite(afterWrite, stream, state, finished, cb);
-      /*</replacement>*/
-    } else {
-      afterWrite(stream, state, finished, cb);
-    }
-  }
-}
-
-function afterWrite(stream, state, finished, cb) {
-  if (!finished) onwriteDrain(stream, state);
-  state.pendingcb--;
-  cb();
-  finishMaybe(stream, state);
-}
-
-// Must force callback to be called on nextTick, so that we don't
-// emit 'drain' before the write() consumer gets the 'false' return
-// value, and has a chance to attach a 'drain' listener.
-function onwriteDrain(stream, state) {
-  if (state.length === 0 && state.needDrain) {
-    state.needDrain = false;
-    stream.emit('drain');
-  }
-}
-
-// if there's something in the buffer waiting, then process it
-function clearBuffer(stream, state) {
-  state.bufferProcessing = true;
-  var entry = state.bufferedRequest;
-
-  if (stream._writev && entry && entry.next) {
-    // Fast case, write everything using _writev()
-    var l = state.bufferedRequestCount;
-    var buffer = new Array(l);
-    var holder = state.corkedRequestsFree;
-    holder.entry = entry;
-
-    var count = 0;
-    var allBuffers = true;
-    while (entry) {
-      buffer[count] = entry;
-      if (!entry.isBuf) allBuffers = false;
-      entry = entry.next;
-      count += 1;
-    }
-    buffer.allBuffers = allBuffers;
-
-    doWrite(stream, state, true, state.length, buffer, '', holder.finish);
-
-    // doWrite is almost always async, defer these to save a bit of time
-    // as the hot path ends with doWrite
-    state.pendingcb++;
-    state.lastBufferedRequest = null;
-    if (holder.next) {
-      state.corkedRequestsFree = holder.next;
-      holder.next = null;
-    } else {
-      state.corkedRequestsFree = new CorkedRequest(state);
-    }
-    state.bufferedRequestCount = 0;
-  } else {
-    // Slow case, write chunks one-by-one
-    while (entry) {
-      var chunk = entry.chunk;
-      var encoding = entry.encoding;
-      var cb = entry.callback;
-      var len = state.objectMode ? 1 : chunk.length;
-
-      doWrite(stream, state, false, len, chunk, encoding, cb);
-      entry = entry.next;
-      state.bufferedRequestCount--;
-      // if we didn't call the onwrite immediately, then
-      // it means that we need to wait until it does.
-      // also, that means that the chunk and cb are currently
-      // being processed, so move the buffer counter past them.
-      if (state.writing) {
-        break;
-      }
-    }
-
-    if (entry === null) state.lastBufferedRequest = null;
-  }
-
-  state.bufferedRequest = entry;
-  state.bufferProcessing = false;
-}
-
-Writable.prototype._write = function (chunk, encoding, cb) {
-  cb(new Error('_write() is not implemented'));
-};
-
-Writable.prototype._writev = null;
-
-Writable.prototype.end = function (chunk, encoding, cb) {
-  var state = this._writableState;
-
-  if (typeof chunk === 'function') {
-    cb = chunk;
-    chunk = null;
-    encoding = null;
-  } else if (typeof encoding === 'function') {
-    cb = encoding;
-    encoding = null;
-  }
-
-  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
-
-  // .end() fully uncorks
-  if (state.corked) {
-    state.corked = 1;
-    this.uncork();
-  }
-
-  // ignore unnecessary end() calls.
-  if (!state.ending && !state.finished) endWritable(this, state, cb);
-};
-
-function needFinish(state) {
-  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
-}
-function callFinal(stream, state) {
-  stream._final(function (err) {
-    state.pendingcb--;
-    if (err) {
-      stream.emit('error', err);
-    }
-    state.prefinished = true;
-    stream.emit('prefinish');
-    finishMaybe(stream, state);
-  });
-}
-function prefinish(stream, state) {
-  if (!state.prefinished && !state.finalCalled) {
-    if (typeof stream._final === 'function') {
-      state.pendingcb++;
-      state.finalCalled = true;
-      pna.nextTick(callFinal, stream, state);
-    } else {
-      state.prefinished = true;
-      stream.emit('prefinish');
-    }
-  }
-}
-
-function finishMaybe(stream, state) {
-  var need = needFinish(state);
-  if (need) {
-    prefinish(stream, state);
-    if (state.pendingcb === 0) {
-      state.finished = true;
-      stream.emit('finish');
-    }
-  }
-  return need;
-}
-
-function endWritable(stream, state, cb) {
-  state.ending = true;
-  finishMaybe(stream, state);
-  if (cb) {
-    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
-  }
-  state.ended = true;
-  stream.writable = false;
-}
-
-function onCorkedFinish(corkReq, state, err) {
-  var entry = corkReq.entry;
-  corkReq.entry = null;
-  while (entry) {
-    var cb = entry.callback;
-    state.pendingcb--;
-    cb(err);
-    entry = entry.next;
-  }
-  if (state.corkedRequestsFree) {
-    state.corkedRequestsFree.next = corkReq;
-  } else {
-    state.corkedRequestsFree = corkReq;
-  }
-}
-
-Object.defineProperty(Writable.prototype, 'destroyed', {
-  get: function () {
-    if (this._writableState === undefined) {
-      return false;
-    }
-    return this._writableState.destroyed;
-  },
-  set: function (value) {
-    // we ignore the value if the stream
-    // has not been initialized yet
-    if (!this._writableState) {
-      return;
-    }
-
-    // backward compatibility, the user is explicitly
-    // managing destroyed
-    this._writableState.destroyed = value;
-  }
-});
-
-Writable.prototype.destroy = destroyImpl.destroy;
-Writable.prototype._undestroy = destroyImpl.undestroy;
-Writable.prototype._destroy = function (err, cb) {
-  this.end();
-  cb(err);
-};
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
-},{"./_stream_duplex":135,"./internal/streams/destroy":141,"./internal/streams/stream":142,"_process":125,"core-util-is":57,"inherits":107,"process-nextick-args":124,"safe-buffer":148,"timers":159,"util-deprecate":160}],140:[function(require,module,exports){
-'use strict';
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var Buffer = require('safe-buffer').Buffer;
-var util = require('util');
-
-function copyBuffer(src, target, offset) {
-  src.copy(target, offset);
-}
-
-module.exports = function () {
-  function BufferList() {
-    _classCallCheck(this, BufferList);
-
-    this.head = null;
-    this.tail = null;
-    this.length = 0;
-  }
-
-  BufferList.prototype.push = function push(v) {
-    var entry = { data: v, next: null };
-    if (this.length > 0) this.tail.next = entry;else this.head = entry;
-    this.tail = entry;
-    ++this.length;
-  };
-
-  BufferList.prototype.unshift = function unshift(v) {
-    var entry = { data: v, next: this.head };
-    if (this.length === 0) this.tail = entry;
-    this.head = entry;
-    ++this.length;
-  };
-
-  BufferList.prototype.shift = function shift() {
-    if (this.length === 0) return;
-    var ret = this.head.data;
-    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
-    --this.length;
-    return ret;
-  };
-
-  BufferList.prototype.clear = function clear() {
-    this.head = this.tail = null;
-    this.length = 0;
-  };
-
-  BufferList.prototype.join = function join(s) {
-    if (this.length === 0) return '';
-    var p = this.head;
-    var ret = '' + p.data;
-    while (p = p.next) {
-      ret += s + p.data;
-    }return ret;
-  };
-
-  BufferList.prototype.concat = function concat(n) {
-    if (this.length === 0) return Buffer.alloc(0);
-    if (this.length === 1) return this.head.data;
-    var ret = Buffer.allocUnsafe(n >>> 0);
-    var p = this.head;
-    var i = 0;
-    while (p) {
-      copyBuffer(p.data, ret, i);
-      i += p.data.length;
-      p = p.next;
-    }
-    return ret;
-  };
-
-  return BufferList;
-}();
-
-if (util && util.inspect && util.inspect.custom) {
-  module.exports.prototype[util.inspect.custom] = function () {
-    var obj = util.inspect({ length: this.length });
-    return this.constructor.name + ' ' + obj;
-  };
-}
-},{"safe-buffer":148,"util":26}],141:[function(require,module,exports){
-'use strict';
-
-/*<replacement>*/
-
-var pna = require('process-nextick-args');
-/*</replacement>*/
-
-// undocumented cb() API, needed for core, not for public API
-function destroy(err, cb) {
-  var _this = this;
-
-  var readableDestroyed = this._readableState && this._readableState.destroyed;
-  var writableDestroyed = this._writableState && this._writableState.destroyed;
-
-  if (readableDestroyed || writableDestroyed) {
-    if (cb) {
-      cb(err);
-    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
-      pna.nextTick(emitErrorNT, this, err);
-    }
-    return this;
-  }
-
-  // we set destroyed to true before firing error callbacks in order
-  // to make it re-entrance safe in case destroy() is called within callbacks
-
-  if (this._readableState) {
-    this._readableState.destroyed = true;
-  }
-
-  // if this is a duplex stream mark the writable part as destroyed as well
-  if (this._writableState) {
-    this._writableState.destroyed = true;
-  }
-
-  this._destroy(err || null, function (err) {
-    if (!cb && err) {
-      pna.nextTick(emitErrorNT, _this, err);
-      if (_this._writableState) {
-        _this._writableState.errorEmitted = true;
-      }
-    } else if (cb) {
-      cb(err);
-    }
-  });
-
-  return this;
-}
-
-function undestroy() {
-  if (this._readableState) {
-    this._readableState.destroyed = false;
-    this._readableState.reading = false;
-    this._readableState.ended = false;
-    this._readableState.endEmitted = false;
-  }
-
-  if (this._writableState) {
-    this._writableState.destroyed = false;
-    this._writableState.ended = false;
-    this._writableState.ending = false;
-    this._writableState.finished = false;
-    this._writableState.errorEmitted = false;
-  }
-}
-
-function emitErrorNT(self, err) {
-  self.emit('error', err);
-}
-
-module.exports = {
-  destroy: destroy,
-  undestroy: undestroy
-};
-},{"process-nextick-args":124}],142:[function(require,module,exports){
-module.exports = require('events').EventEmitter;
-
-},{"events":90}],143:[function(require,module,exports){
-module.exports = require('./readable').PassThrough
-
-},{"./readable":144}],144:[function(require,module,exports){
-exports = module.exports = require('./lib/_stream_readable.js');
-exports.Stream = exports;
-exports.Readable = exports;
-exports.Writable = require('./lib/_stream_writable.js');
-exports.Duplex = require('./lib/_stream_duplex.js');
-exports.Transform = require('./lib/_stream_transform.js');
-exports.PassThrough = require('./lib/_stream_passthrough.js');
-
-},{"./lib/_stream_duplex.js":135,"./lib/_stream_passthrough.js":136,"./lib/_stream_readable.js":137,"./lib/_stream_transform.js":138,"./lib/_stream_writable.js":139}],145:[function(require,module,exports){
-module.exports = require('./readable').Transform
-
-},{"./readable":144}],146:[function(require,module,exports){
-module.exports = require('./lib/_stream_writable.js');
-
-},{"./lib/_stream_writable.js":139}],147:[function(require,module,exports){
-'use strict'
-var Buffer = require('buffer').Buffer
-var inherits = require('inherits')
-var HashBase = require('hash-base')
-
-var ARRAY16 = new Array(16)
-
-var zl = [
-  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
-  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
-  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
-  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
-]
-
-var zr = [
-  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
-  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
-  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
-  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
-  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
-]
-
-var sl = [
-  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
-  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
-  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
-  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
-  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
-]
-
-var sr = [
-  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
-  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
-  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
-  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
-  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
-]
-
-var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]
-var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]
-
-function RIPEMD160 () {
-  HashBase.call(this, 64)
-
-  // state
-  this._a = 0x67452301
-  this._b = 0xefcdab89
-  this._c = 0x98badcfe
-  this._d = 0x10325476
-  this._e = 0xc3d2e1f0
-}
-
-inherits(RIPEMD160, HashBase)
-
-RIPEMD160.prototype._update = function () {
-  var words = ARRAY16
-  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)
-
-  var al = this._a | 0
-  var bl = this._b | 0
-  var cl = this._c | 0
-  var dl = this._d | 0
-  var el = this._e | 0
-
-  var ar = this._a | 0
-  var br = this._b | 0
-  var cr = this._c | 0
-  var dr = this._d | 0
-  var er = this._e | 0
-
-  // computation
-  for (var i = 0; i < 80; i += 1) {
-    var tl
-    var tr
-    if (i < 16) {
-      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])
-      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])
-    } else if (i < 32) {
-      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])
-      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])
-    } else if (i < 48) {
-      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])
-      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])
-    } else if (i < 64) {
-      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])
-      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])
-    } else { // if (i<80) {
-      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])
-      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])
-    }
-
-    al = el
-    el = dl
-    dl = rotl(cl, 10)
-    cl = bl
-    bl = tl
-
-    ar = er
-    er = dr
-    dr = rotl(cr, 10)
-    cr = br
-    br = tr
-  }
-
-  // update state
-  var t = (this._b + cl + dr) | 0
-  this._b = (this._c + dl + er) | 0
-  this._c = (this._d + el + ar) | 0
-  this._d = (this._e + al + br) | 0
-  this._e = (this._a + bl + cr) | 0
-  this._a = t
-}
-
-RIPEMD160.prototype._digest = function () {
-  // create padding and handle blocks
-  this._block[this._blockOffset++] = 0x80
-  if (this._blockOffset > 56) {
-    this._block.fill(0, this._blockOffset, 64)
-    this._update()
-    this._blockOffset = 0
-  }
-
-  this._block.fill(0, this._blockOffset, 56)
-  this._block.writeUInt32LE(this._length[0], 56)
-  this._block.writeUInt32LE(this._length[1], 60)
-  this._update()
-
-  // produce result
-  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)
-  buffer.writeInt32LE(this._a, 0)
-  buffer.writeInt32LE(this._b, 4)
-  buffer.writeInt32LE(this._c, 8)
-  buffer.writeInt32LE(this._d, 12)
-  buffer.writeInt32LE(this._e, 16)
-  return buffer
-}
-
-function rotl (x, n) {
-  return (x << n) | (x >>> (32 - n))
-}
-
-function fn1 (a, b, c, d, e, m, k, s) {
-  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0
-}
-
-function fn2 (a, b, c, d, e, m, k, s) {
-  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0
-}
-
-function fn3 (a, b, c, d, e, m, k, s) {
-  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0
-}
-
-function fn4 (a, b, c, d, e, m, k, s) {
-  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0
-}
-
-function fn5 (a, b, c, d, e, m, k, s) {
-  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0
-}
-
-module.exports = RIPEMD160
-
-},{"buffer":55,"hash-base":92,"inherits":107}],148:[function(require,module,exports){
-arguments[4][7][0].apply(exports,arguments)
-},{"buffer":55,"dup":7}],149:[function(require,module,exports){
-var Buffer = require('safe-buffer').Buffer
-
-// prototype class for hash functions
-function Hash (blockSize, finalSize) {
-  this._block = Buffer.alloc(blockSize)
-  this._finalSize = finalSize
-  this._blockSize = blockSize
-  this._len = 0
-}
-
-Hash.prototype.update = function (data, enc) {
-  if (typeof data === 'string') {
-    enc = enc || 'utf8'
-    data = Buffer.from(data, enc)
-  }
-
-  var block = this._block
-  var blockSize = this._blockSize
-  var length = data.length
-  var accum = this._len
-
-  for (var offset = 0; offset < length;) {
-    var assigned = accum % blockSize
-    var remainder = Math.min(length - offset, blockSize - assigned)
-
-    for (var i = 0; i < remainder; i++) {
-      block[assigned + i] = data[offset + i]
-    }
-
-    accum += remainder
-    offset += remainder
-
-    if ((accum % blockSize) === 0) {
-      this._update(block)
-    }
-  }
-
-  this._len += length
-  return this
-}
-
-Hash.prototype.digest = function (enc) {
-  var rem = this._len % this._blockSize
-
-  this._block[rem] = 0x80
-
-  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest
-  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
-  this._block.fill(0, rem + 1)
-
-  if (rem >= this._finalSize) {
-    this._update(this._block)
-    this._block.fill(0)
-  }
-
-  var bits = this._len * 8
-
-  // uint32
-  if (bits <= 0xffffffff) {
-    this._block.writeUInt32BE(bits, this._blockSize - 4)
-
-  // uint64
-  } else {
-    var lowBits = (bits & 0xffffffff) >>> 0
-    var highBits = (bits - lowBits) / 0x100000000
-
-    this._block.writeUInt32BE(highBits, this._blockSize - 8)
-    this._block.writeUInt32BE(lowBits, this._blockSize - 4)
-  }
-
-  this._update(this._block)
-  var hash = this._hash()
-
-  return enc ? hash.toString(enc) : hash
-}
-
-Hash.prototype._update = function () {
-  throw new Error('_update must be implemented by subclass')
-}
-
-module.exports = Hash
-
-},{"safe-buffer":148}],150:[function(require,module,exports){
-var exports = module.exports = function SHA (algorithm) {
-  algorithm = algorithm.toLowerCase()
-
-  var Algorithm = exports[algorithm]
-  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')
-
-  return new Algorithm()
-}
-
-exports.sha = require('./sha')
-exports.sha1 = require('./sha1')
-exports.sha224 = require('./sha224')
-exports.sha256 = require('./sha256')
-exports.sha384 = require('./sha384')
-exports.sha512 = require('./sha512')
-
-},{"./sha":151,"./sha1":152,"./sha224":153,"./sha256":154,"./sha384":155,"./sha512":156}],151:[function(require,module,exports){
-/*
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
- * in FIPS PUB 180-1
- * This source code is derived from sha1.js of the same repository.
- * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
- * operation was added.
- */
-
-var inherits = require('inherits')
-var Hash = require('./hash')
-var Buffer = require('safe-buffer').Buffer
-
-var K = [
-  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
-]
-
-var W = new Array(80)
-
-function Sha () {
-  this.init()
-  this._w = W
-
-  Hash.call(this, 64, 56)
-}
-
-inherits(Sha, Hash)
-
-Sha.prototype.init = function () {
-  this._a = 0x67452301
-  this._b = 0xefcdab89
-  this._c = 0x98badcfe
-  this._d = 0x10325476
-  this._e = 0xc3d2e1f0
-
-  return this
-}
-
-function rotl5 (num) {
-  return (num << 5) | (num >>> 27)
-}
-
-function rotl30 (num) {
-  return (num << 30) | (num >>> 2)
-}
-
-function ft (s, b, c, d) {
-  if (s === 0) return (b & c) | ((~b) & d)
-  if (s === 2) return (b & c) | (b & d) | (c & d)
-  return b ^ c ^ d
-}
-
-Sha.prototype._update = function (M) {
-  var W = this._w
-
-  var a = this._a | 0
-  var b = this._b | 0
-  var c = this._c | 0
-  var d = this._d | 0
-  var e = this._e | 0
-
-  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
-  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]
-
-  for (var j = 0; j < 80; ++j) {
-    var s = ~~(j / 20)
-    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0
-
-    e = d
-    d = c
-    c = rotl30(b)
-    b = a
-    a = t
-  }
-
-  this._a = (a + this._a) | 0
-  this._b = (b + this._b) | 0
-  this._c = (c + this._c) | 0
-  this._d = (d + this._d) | 0
-  this._e = (e + this._e) | 0
-}
-
-Sha.prototype._hash = function () {
-  var H = Buffer.allocUnsafe(20)
-
-  H.writeInt32BE(this._a | 0, 0)
-  H.writeInt32BE(this._b | 0, 4)
-  H.writeInt32BE(this._c | 0, 8)
-  H.writeInt32BE(this._d | 0, 12)
-  H.writeInt32BE(this._e | 0, 16)
-
-  return H
-}
-
-module.exports = Sha
-
-},{"./hash":149,"inherits":107,"safe-buffer":148}],152:[function(require,module,exports){
-/*
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
- * in FIPS PUB 180-1
- * Version 2.1a Copyright Paul Johnston 2000 - 2002.
- * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
- * Distributed under the BSD License
- * See http://pajhome.org.uk/crypt/md5 for details.
- */
-
-var inherits = require('inherits')
-var Hash = require('./hash')
-var Buffer = require('safe-buffer').Buffer
-
-var K = [
-  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
-]
-
-var W = new Array(80)
-
-function Sha1 () {
-  this.init()
-  this._w = W
-
-  Hash.call(this, 64, 56)
-}
-
-inherits(Sha1, Hash)
-
-Sha1.prototype.init = function () {
-  this._a = 0x67452301
-  this._b = 0xefcdab89
-  this._c = 0x98badcfe
-  this._d = 0x10325476
-  this._e = 0xc3d2e1f0
-
-  return this
-}
-
-function rotl1 (num) {
-  return (num << 1) | (num >>> 31)
-}
-
-function rotl5 (num) {
-  return (num << 5) | (num >>> 27)
-}
-
-function rotl30 (num) {
-  return (num << 30) | (num >>> 2)
-}
-
-function ft (s, b, c, d) {
-  if (s === 0) return (b & c) | ((~b) & d)
-  if (s === 2) return (b & c) | (b & d) | (c & d)
-  return b ^ c ^ d
-}
-
-Sha1.prototype._update = function (M) {
-  var W = this._w
-
-  var a = this._a | 0
-  var b = this._b | 0
-  var c = this._c | 0
-  var d = this._d | 0
-  var e = this._e | 0
-
-  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
-  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])
-
-  for (var j = 0; j < 80; ++j) {
-    var s = ~~(j / 20)
-    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0
-
-    e = d
-    d = c
-    c = rotl30(b)
-    b = a
-    a = t
-  }
-
-  this._a = (a + this._a) | 0
-  this._b = (b + this._b) | 0
-  this._c = (c + this._c) | 0
-  this._d = (d + this._d) | 0
-  this._e = (e + this._e) | 0
-}
-
-Sha1.prototype._hash = function () {
-  var H = Buffer.allocUnsafe(20)
-
-  H.writeInt32BE(this._a | 0, 0)
-  H.writeInt32BE(this._b | 0, 4)
-  H.writeInt32BE(this._c | 0, 8)
-  H.writeInt32BE(this._d | 0, 12)
-  H.writeInt32BE(this._e | 0, 16)
-
-  return H
-}
-
-module.exports = Sha1
-
-},{"./hash":149,"inherits":107,"safe-buffer":148}],153:[function(require,module,exports){
-/**
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
- * in FIPS 180-2
- * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
- * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
- *
- */
-
-var inherits = require('inherits')
-var Sha256 = require('./sha256')
-var Hash = require('./hash')
-var Buffer = require('safe-buffer').Buffer
-
-var W = new Array(64)
-
-function Sha224 () {
-  this.init()
-
-  this._w = W // new Array(64)
-
-  Hash.call(this, 64, 56)
-}
-
-inherits(Sha224, Sha256)
-
-Sha224.prototype.init = function () {
-  this._a = 0xc1059ed8
-  this._b = 0x367cd507
-  this._c = 0x3070dd17
-  this._d = 0xf70e5939
-  this._e = 0xffc00b31
-  this._f = 0x68581511
-  this._g = 0x64f98fa7
-  this._h = 0xbefa4fa4
-
-  return this
-}
-
-Sha224.prototype._hash = function () {
-  var H = Buffer.allocUnsafe(28)
-
-  H.writeInt32BE(this._a, 0)
-  H.writeInt32BE(this._b, 4)
-  H.writeInt32BE(this._c, 8)
-  H.writeInt32BE(this._d, 12)
-  H.writeInt32BE(this._e, 16)
-  H.writeInt32BE(this._f, 20)
-  H.writeInt32BE(this._g, 24)
-
-  return H
-}
-
-module.exports = Sha224
-
-},{"./hash":149,"./sha256":154,"inherits":107,"safe-buffer":148}],154:[function(require,module,exports){
-/**
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
- * in FIPS 180-2
- * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
- * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
- *
- */
-
-var inherits = require('inherits')
-var Hash = require('./hash')
-var Buffer = require('safe-buffer').Buffer
-
-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 W = new Array(64)
-
-function Sha256 () {
-  this.init()
-
-  this._w = W // new Array(64)
-
-  Hash.call(this, 64, 56)
-}
-
-inherits(Sha256, Hash)
-
-Sha256.prototype.init = function () {
-  this._a = 0x6a09e667
-  this._b = 0xbb67ae85
-  this._c = 0x3c6ef372
-  this._d = 0xa54ff53a
-  this._e = 0x510e527f
-  this._f = 0x9b05688c
-  this._g = 0x1f83d9ab
-  this._h = 0x5be0cd19
-
-  return this
-}
-
-function ch (x, y, z) {
-  return z ^ (x & (y ^ z))
-}
-
-function maj (x, y, z) {
-  return (x & y) | (z & (x | y))
-}
-
-function sigma0 (x) {
-  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)
-}
-
-function sigma1 (x) {
-  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)
-}
-
-function gamma0 (x) {
-  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)
-}
-
-function gamma1 (x) {
-  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)
-}
-
-Sha256.prototype._update = function (M) {
-  var W = this._w
-
-  var a = this._a | 0
-  var b = this._b | 0
-  var c = this._c | 0
-  var d = this._d | 0
-  var e = this._e | 0
-  var f = this._f | 0
-  var g = this._g | 0
-  var h = this._h | 0
-
-  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
-  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0
-
-  for (var j = 0; j < 64; ++j) {
-    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0
-    var T2 = (sigma0(a) + maj(a, b, c)) | 0
-
-    h = g
-    g = f
-    f = e
-    e = (d + T1) | 0
-    d = c
-    c = b
-    b = a
-    a = (T1 + T2) | 0
-  }
-
-  this._a = (a + this._a) | 0
-  this._b = (b + this._b) | 0
-  this._c = (c + this._c) | 0
-  this._d = (d + this._d) | 0
-  this._e = (e + this._e) | 0
-  this._f = (f + this._f) | 0
-  this._g = (g + this._g) | 0
-  this._h = (h + this._h) | 0
-}
-
-Sha256.prototype._hash = function () {
-  var H = Buffer.allocUnsafe(32)
-
-  H.writeInt32BE(this._a, 0)
-  H.writeInt32BE(this._b, 4)
-  H.writeInt32BE(this._c, 8)
-  H.writeInt32BE(this._d, 12)
-  H.writeInt32BE(this._e, 16)
-  H.writeInt32BE(this._f, 20)
-  H.writeInt32BE(this._g, 24)
-  H.writeInt32BE(this._h, 28)
-
-  return H
-}
-
-module.exports = Sha256
-
-},{"./hash":149,"inherits":107,"safe-buffer":148}],155:[function(require,module,exports){
-var inherits = require('inherits')
-var SHA512 = require('./sha512')
-var Hash = require('./hash')
-var Buffer = require('safe-buffer').Buffer
-
-var W = new Array(160)
-
-function Sha384 () {
-  this.init()
-  this._w = W
-
-  Hash.call(this, 128, 112)
-}
-
-inherits(Sha384, SHA512)
-
-Sha384.prototype.init = function () {
-  this._ah = 0xcbbb9d5d
-  this._bh = 0x629a292a
-  this._ch = 0x9159015a
-  this._dh = 0x152fecd8
-  this._eh = 0x67332667
-  this._fh = 0x8eb44a87
-  this._gh = 0xdb0c2e0d
-  this._hh = 0x47b5481d
-
-  this._al = 0xc1059ed8
-  this._bl = 0x367cd507
-  this._cl = 0x3070dd17
-  this._dl = 0xf70e5939
-  this._el = 0xffc00b31
-  this._fl = 0x68581511
-  this._gl = 0x64f98fa7
-  this._hl = 0xbefa4fa4
-
-  return this
-}
-
-Sha384.prototype._hash = function () {
-  var H = Buffer.allocUnsafe(48)
-
-  function writeInt64BE (h, l, offset) {
-    H.writeInt32BE(h, offset)
-    H.writeInt32BE(l, offset + 4)
-  }
-
-  writeInt64BE(this._ah, this._al, 0)
-  writeInt64BE(this._bh, this._bl, 8)
-  writeInt64BE(this._ch, this._cl, 16)
-  writeInt64BE(this._dh, this._dl, 24)
-  writeInt64BE(this._eh, this._el, 32)
-  writeInt64BE(this._fh, this._fl, 40)
-
-  return H
-}
-
-module.exports = Sha384
-
-},{"./hash":149,"./sha512":156,"inherits":107,"safe-buffer":148}],156:[function(require,module,exports){
-var inherits = require('inherits')
-var Hash = require('./hash')
-var Buffer = require('safe-buffer').Buffer
-
-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
-]
-
-var W = new Array(160)
-
-function Sha512 () {
-  this.init()
-  this._w = W
-
-  Hash.call(this, 128, 112)
-}
-
-inherits(Sha512, Hash)
-
-Sha512.prototype.init = function () {
-  this._ah = 0x6a09e667
-  this._bh = 0xbb67ae85
-  this._ch = 0x3c6ef372
-  this._dh = 0xa54ff53a
-  this._eh = 0x510e527f
-  this._fh = 0x9b05688c
-  this._gh = 0x1f83d9ab
-  this._hh = 0x5be0cd19
-
-  this._al = 0xf3bcc908
-  this._bl = 0x84caa73b
-  this._cl = 0xfe94f82b
-  this._dl = 0x5f1d36f1
-  this._el = 0xade682d1
-  this._fl = 0x2b3e6c1f
-  this._gl = 0xfb41bd6b
-  this._hl = 0x137e2179
-
-  return this
-}
-
-function Ch (x, y, z) {
-  return z ^ (x & (y ^ z))
-}
-
-function maj (x, y, z) {
-  return (x & y) | (z & (x | y))
-}
-
-function sigma0 (x, xl) {
-  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)
-}
-
-function sigma1 (x, xl) {
-  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)
-}
-
-function Gamma0 (x, xl) {
-  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)
-}
-
-function Gamma0l (x, xl) {
-  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)
-}
-
-function Gamma1 (x, xl) {
-  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)
-}
-
-function Gamma1l (x, xl) {
-  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)
-}
-
-function getCarry (a, b) {
-  return (a >>> 0) < (b >>> 0) ? 1 : 0
-}
-
-Sha512.prototype._update = function (M) {
-  var W = this._w
-
-  var ah = this._ah | 0
-  var bh = this._bh | 0
-  var ch = this._ch | 0
-  var dh = this._dh | 0
-  var eh = this._eh | 0
-  var fh = this._fh | 0
-  var gh = this._gh | 0
-  var hh = this._hh | 0
-
-  var al = this._al | 0
-  var bl = this._bl | 0
-  var cl = this._cl | 0
-  var dl = this._dl | 0
-  var el = this._el | 0
-  var fl = this._fl | 0
-  var gl = this._gl | 0
-  var hl = this._hl | 0
-
-  for (var i = 0; i < 32; i += 2) {
-    W[i] = M.readInt32BE(i * 4)
-    W[i + 1] = M.readInt32BE(i * 4 + 4)
-  }
-  for (; i < 160; i += 2) {
-    var xh = W[i - 15 * 2]
-    var xl = W[i - 15 * 2 + 1]
-    var gamma0 = Gamma0(xh, xl)
-    var gamma0l = Gamma0l(xl, xh)
-
-    xh = W[i - 2 * 2]
-    xl = W[i - 2 * 2 + 1]
-    var gamma1 = Gamma1(xh, xl)
-    var gamma1l = Gamma1l(xl, xh)
-
-    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
-    var Wi7h = W[i - 7 * 2]
-    var Wi7l = W[i - 7 * 2 + 1]
-
-    var Wi16h = W[i - 16 * 2]
-    var Wi16l = W[i - 16 * 2 + 1]
-
-    var Wil = (gamma0l + Wi7l) | 0
-    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0
-    Wil = (Wil + gamma1l) | 0
-    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0
-    Wil = (Wil + Wi16l) | 0
-    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0
-
-    W[i] = Wih
-    W[i + 1] = Wil
-  }
-
-  for (var j = 0; j < 160; j += 2) {
-    Wih = W[j]
-    Wil = W[j + 1]
-
-    var majh = maj(ah, bh, ch)
-    var majl = maj(al, bl, cl)
-
-    var sigma0h = sigma0(ah, al)
-    var sigma0l = sigma0(al, ah)
-    var sigma1h = sigma1(eh, el)
-    var sigma1l = sigma1(el, eh)
-
-    // t1 = h + sigma1 + ch + K[j] + W[j]
-    var Kih = K[j]
-    var Kil = K[j + 1]
-
-    var chh = Ch(eh, fh, gh)
-    var chl = Ch(el, fl, gl)
-
-    var t1l = (hl + sigma1l) | 0
-    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0
-    t1l = (t1l + chl) | 0
-    t1h = (t1h + chh + getCarry(t1l, chl)) | 0
-    t1l = (t1l + Kil) | 0
-    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0
-    t1l = (t1l + Wil) | 0
-    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0
-
-    // t2 = sigma0 + maj
-    var t2l = (sigma0l + majl) | 0
-    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0
-
-    hh = gh
-    hl = gl
-    gh = fh
-    gl = fl
-    fh = eh
-    fl = el
-    el = (dl + t1l) | 0
-    eh = (dh + t1h + getCarry(el, dl)) | 0
-    dh = ch
-    dl = cl
-    ch = bh
-    cl = bl
-    bh = ah
-    bl = al
-    al = (t1l + t2l) | 0
-    ah = (t1h + t2h + getCarry(al, t1l)) | 0
-  }
-
-  this._al = (this._al + al) | 0
-  this._bl = (this._bl + bl) | 0
-  this._cl = (this._cl + cl) | 0
-  this._dl = (this._dl + dl) | 0
-  this._el = (this._el + el) | 0
-  this._fl = (this._fl + fl) | 0
-  this._gl = (this._gl + gl) | 0
-  this._hl = (this._hl + hl) | 0
-
-  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0
-  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0
-  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0
-  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0
-  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0
-  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0
-  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0
-  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0
-}
-
-Sha512.prototype._hash = function () {
-  var H = Buffer.allocUnsafe(64)
-
-  function writeInt64BE (h, l, offset) {
-    H.writeInt32BE(h, offset)
-    H.writeInt32BE(l, offset + 4)
-  }
-
-  writeInt64BE(this._ah, this._al, 0)
-  writeInt64BE(this._bh, this._bl, 8)
-  writeInt64BE(this._ch, this._cl, 16)
-  writeInt64BE(this._dh, this._dl, 24)
-  writeInt64BE(this._eh, this._el, 32)
-  writeInt64BE(this._fh, this._fl, 40)
-  writeInt64BE(this._gh, this._gl, 48)
-  writeInt64BE(this._hh, this._hl, 56)
-
-  return H
-}
-
-module.exports = Sha512
-
-},{"./hash":149,"inherits":107,"safe-buffer":148}],157:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-module.exports = Stream;
-
-var EE = require('events').EventEmitter;
-var inherits = require('inherits');
-
-inherits(Stream, EE);
-Stream.Readable = require('readable-stream/readable.js');
-Stream.Writable = require('readable-stream/writable.js');
-Stream.Duplex = require('readable-stream/duplex.js');
-Stream.Transform = require('readable-stream/transform.js');
-Stream.PassThrough = require('readable-stream/passthrough.js');
-
-// Backwards-compat with node 0.4.x
-Stream.Stream = Stream;
-
-
-
-// old-style streams.  Note that the pipe method (the only relevant
-// part of this class) is overridden in the Readable class.
-
-function Stream() {
-  EE.call(this);
-}
-
-Stream.prototype.pipe = function(dest, options) {
-  var source = this;
-
-  function ondata(chunk) {
-    if (dest.writable) {
-      if (false === dest.write(chunk) && source.pause) {
-        source.pause();
-      }
-    }
-  }
-
-  source.on('data', ondata);
-
-  function ondrain() {
-    if (source.readable && source.resume) {
-      source.resume();
-    }
-  }
-
-  dest.on('drain', ondrain);
-
-  // If the 'end' option is not supplied, dest.end() will be called when
-  // source gets the 'end' or 'close' events.  Only dest.end() once.
-  if (!dest._isStdio && (!options || options.end !== false)) {
-    source.on('end', onend);
-    source.on('close', onclose);
-  }
-
-  var didOnEnd = false;
-  function onend() {
-    if (didOnEnd) return;
-    didOnEnd = true;
-
-    dest.end();
-  }
-
-
-  function onclose() {
-    if (didOnEnd) return;
-    didOnEnd = true;
-
-    if (typeof dest.destroy === 'function') dest.destroy();
-  }
-
-  // don't leave dangling pipes when there are errors.
-  function onerror(er) {
-    cleanup();
-    if (EE.listenerCount(this, 'error') === 0) {
-      throw er; // Unhandled stream error in pipe.
-    }
-  }
-
-  source.on('error', onerror);
-  dest.on('error', onerror);
-
-  // remove all the event listeners that were added.
-  function cleanup() {
-    source.removeListener('data', ondata);
-    dest.removeListener('drain', ondrain);
-
-    source.removeListener('end', onend);
-    source.removeListener('close', onclose);
-
-    source.removeListener('error', onerror);
-    dest.removeListener('error', onerror);
-
-    source.removeListener('end', cleanup);
-    source.removeListener('close', cleanup);
-
-    dest.removeListener('close', cleanup);
-  }
-
-  source.on('end', cleanup);
-  source.on('close', cleanup);
-
-  dest.on('close', cleanup);
-
-  dest.emit('pipe', source);
-
-  // Allow for unix-like usage: A.pipe(B).pipe(C)
-  return dest;
-};
-
-},{"events":90,"inherits":107,"readable-stream/duplex.js":134,"readable-stream/passthrough.js":143,"readable-stream/readable.js":144,"readable-stream/transform.js":145,"readable-stream/writable.js":146}],158:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-'use strict';
-
-/*<replacement>*/
-
-var Buffer = require('safe-buffer').Buffer;
-/*</replacement>*/
-
-var isEncoding = Buffer.isEncoding || function (encoding) {
-  encoding = '' + encoding;
-  switch (encoding && encoding.toLowerCase()) {
-    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
-      return true;
-    default:
-      return false;
-  }
-};
-
-function _normalizeEncoding(enc) {
-  if (!enc) return 'utf8';
-  var retried;
-  while (true) {
-    switch (enc) {
-      case 'utf8':
-      case 'utf-8':
-        return 'utf8';
-      case 'ucs2':
-      case 'ucs-2':
-      case 'utf16le':
-      case 'utf-16le':
-        return 'utf16le';
-      case 'latin1':
-      case 'binary':
-        return 'latin1';
-      case 'base64':
-      case 'ascii':
-      case 'hex':
-        return enc;
-      default:
-        if (retried) return; // undefined
-        enc = ('' + enc).toLowerCase();
-        retried = true;
-    }
-  }
-};
-
-// Do not cache `Buffer.isEncoding` when checking encoding names as some
-// modules monkey-patch it to support additional encodings
-function normalizeEncoding(enc) {
-  var nenc = _normalizeEncoding(enc);
-  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
-  return nenc || enc;
-}
-
-// StringDecoder provides an interface for efficiently splitting a series of
-// buffers into a series of JS strings without breaking apart multi-byte
-// characters.
-exports.StringDecoder = StringDecoder;
-function StringDecoder(encoding) {
-  this.encoding = normalizeEncoding(encoding);
-  var nb;
-  switch (this.encoding) {
-    case 'utf16le':
-      this.text = utf16Text;
-      this.end = utf16End;
-      nb = 4;
-      break;
-    case 'utf8':
-      this.fillLast = utf8FillLast;
-      nb = 4;
-      break;
-    case 'base64':
-      this.text = base64Text;
-      this.end = base64End;
-      nb = 3;
-      break;
-    default:
-      this.write = simpleWrite;
-      this.end = simpleEnd;
-      return;
-  }
-  this.lastNeed = 0;
-  this.lastTotal = 0;
-  this.lastChar = Buffer.allocUnsafe(nb);
-}
-
-StringDecoder.prototype.write = function (buf) {
-  if (buf.length === 0) return '';
-  var r;
-  var i;
-  if (this.lastNeed) {
-    r = this.fillLast(buf);
-    if (r === undefined) return '';
-    i = this.lastNeed;
-    this.lastNeed = 0;
-  } else {
-    i = 0;
-  }
-  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
-  return r || '';
-};
-
-StringDecoder.prototype.end = utf8End;
-
-// Returns only complete characters in a Buffer
-StringDecoder.prototype.text = utf8Text;
-
-// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
-StringDecoder.prototype.fillLast = function (buf) {
-  if (this.lastNeed <= buf.length) {
-    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
-    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
-  }
-  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
-  this.lastNeed -= buf.length;
-};
-
-// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
-// continuation byte. If an invalid byte is detected, -2 is returned.
-function utf8CheckByte(byte) {
-  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
-  return byte >> 6 === 0x02 ? -1 : -2;
-}
-
-// Checks at most 3 bytes at the end of a Buffer in order to detect an
-// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
-// needed to complete the UTF-8 character (if applicable) are returned.
-function utf8CheckIncomplete(self, buf, i) {
-  var j = buf.length - 1;
-  if (j < i) return 0;
-  var nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) self.lastNeed = nb - 1;
-    return nb;
-  }
-  if (--j < i || nb === -2) return 0;
-  nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) self.lastNeed = nb - 2;
-    return nb;
-  }
-  if (--j < i || nb === -2) return 0;
-  nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) {
-      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
-    }
-    return nb;
-  }
-  return 0;
-}
-
-// Validates as many continuation bytes for a multi-byte UTF-8 character as
-// needed or are available. If we see a non-continuation byte where we expect
-// one, we "replace" the validated continuation bytes we've seen so far with
-// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
-// behavior. The continuation byte check is included three times in the case
-// where all of the continuation bytes for a character exist in the same buffer.
-// It is also done this way as a slight performance increase instead of using a
-// loop.
-function utf8CheckExtraBytes(self, buf, p) {
-  if ((buf[0] & 0xC0) !== 0x80) {
-    self.lastNeed = 0;
-    return '\ufffd';
-  }
-  if (self.lastNeed > 1 && buf.length > 1) {
-    if ((buf[1] & 0xC0) !== 0x80) {
-      self.lastNeed = 1;
-      return '\ufffd';
-    }
-    if (self.lastNeed > 2 && buf.length > 2) {
-      if ((buf[2] & 0xC0) !== 0x80) {
-        self.lastNeed = 2;
-        return '\ufffd';
-      }
-    }
-  }
-}
-
-// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
-function utf8FillLast(buf) {
-  var p = this.lastTotal - this.lastNeed;
-  var r = utf8CheckExtraBytes(this, buf, p);
-  if (r !== undefined) return r;
-  if (this.lastNeed <= buf.length) {
-    buf.copy(this.lastChar, p, 0, this.lastNeed);
-    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
-  }
-  buf.copy(this.lastChar, p, 0, buf.length);
-  this.lastNeed -= buf.length;
-}
-
-// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
-// partial character, the character's bytes are buffered until the required
-// number of bytes are available.
-function utf8Text(buf, i) {
-  var total = utf8CheckIncomplete(this, buf, i);
-  if (!this.lastNeed) return buf.toString('utf8', i);
-  this.lastTotal = total;
-  var end = buf.length - (total - this.lastNeed);
-  buf.copy(this.lastChar, 0, end);
-  return buf.toString('utf8', i, end);
-}
-
-// For UTF-8, a replacement character is added when ending on a partial
-// character.
-function utf8End(buf) {
-  var r = buf && buf.length ? this.write(buf) : '';
-  if (this.lastNeed) return r + '\ufffd';
-  return r;
-}
-
-// UTF-16LE typically needs two bytes per character, but even if we have an even
-// number of bytes available, we need to check if we end on a leading/high
-// surrogate. In that case, we need to wait for the next two bytes in order to
-// decode the last character properly.
-function utf16Text(buf, i) {
-  if ((buf.length - i) % 2 === 0) {
-    var r = buf.toString('utf16le', i);
-    if (r) {
-      var c = r.charCodeAt(r.length - 1);
-      if (c >= 0xD800 && c <= 0xDBFF) {
-        this.lastNeed = 2;
-        this.lastTotal = 4;
-        this.lastChar[0] = buf[buf.length - 2];
-        this.lastChar[1] = buf[buf.length - 1];
-        return r.slice(0, -1);
-      }
-    }
-    return r;
-  }
-  this.lastNeed = 1;
-  this.lastTotal = 2;
-  this.lastChar[0] = buf[buf.length - 1];
-  return buf.toString('utf16le', i, buf.length - 1);
-}
-
-// For UTF-16LE we do not explicitly append special replacement characters if we
-// end on a partial character, we simply let v8 handle that.
-function utf16End(buf) {
-  var r = buf && buf.length ? this.write(buf) : '';
-  if (this.lastNeed) {
-    var end = this.lastTotal - this.lastNeed;
-    return r + this.lastChar.toString('utf16le', 0, end);
-  }
-  return r;
-}
-
-function base64Text(buf, i) {
-  var n = (buf.length - i) % 3;
-  if (n === 0) return buf.toString('base64', i);
-  this.lastNeed = 3 - n;
-  this.lastTotal = 3;
-  if (n === 1) {
-    this.lastChar[0] = buf[buf.length - 1];
-  } else {
-    this.lastChar[0] = buf[buf.length - 2];
-    this.lastChar[1] = buf[buf.length - 1];
-  }
-  return buf.toString('base64', i, buf.length - n);
-}
-
-function base64End(buf) {
-  var r = buf && buf.length ? this.write(buf) : '';
-  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
-  return r;
-}
-
-// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
-function simpleWrite(buf) {
-  return buf.toString(this.encoding);
-}
-
-function simpleEnd(buf) {
-  return buf && buf.length ? this.write(buf) : '';
-}
-},{"safe-buffer":148}],159:[function(require,module,exports){
-(function (setImmediate,clearImmediate){
-var nextTick = require('process/browser.js').nextTick;
-var apply = Function.prototype.apply;
-var slice = Array.prototype.slice;
-var immediateIds = {};
-var nextImmediateId = 0;
-
-// DOM APIs, for completeness
-
-exports.setTimeout = function() {
-  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
-};
-exports.setInterval = function() {
-  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
-};
-exports.clearTimeout =
-exports.clearInterval = function(timeout) { timeout.close(); };
-
-function Timeout(id, clearFn) {
-  this._id = id;
-  this._clearFn = clearFn;
-}
-Timeout.prototype.unref = Timeout.prototype.ref = function() {};
-Timeout.prototype.close = function() {
-  this._clearFn.call(window, this._id);
-};
-
-// Does not start the time, just sets up the members needed.
-exports.enroll = function(item, msecs) {
-  clearTimeout(item._idleTimeoutId);
-  item._idleTimeout = msecs;
-};
-
-exports.unenroll = function(item) {
-  clearTimeout(item._idleTimeoutId);
-  item._idleTimeout = -1;
-};
-
-exports._unrefActive = exports.active = function(item) {
-  clearTimeout(item._idleTimeoutId);
-
-  var msecs = item._idleTimeout;
-  if (msecs >= 0) {
-    item._idleTimeoutId = setTimeout(function onTimeout() {
-      if (item._onTimeout)
-        item._onTimeout();
-    }, msecs);
-  }
-};
-
-// That's not how node.js implements it but the exposed api is the same.
-exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
-  var id = nextImmediateId++;
-  var args = arguments.length < 2 ? false : slice.call(arguments, 1);
-
-  immediateIds[id] = true;
-
-  nextTick(function onNextTick() {
-    if (immediateIds[id]) {
-      // fn.call() is faster so we optimize for the common use-case
-      // @see http://jsperf.com/call-apply-segu
-      if (args) {
-        fn.apply(null, args);
-      } else {
-        fn.call(null);
-      }
-      // Prevent ids from leaking
-      exports.clearImmediate(id);
-    }
-  });
-
-  return id;
-};
-
-exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
-  delete immediateIds[id];
-};
-}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
-},{"process/browser.js":125,"timers":159}],160:[function(require,module,exports){
-(function (global){
-
-/**
- * Module exports.
- */
-
-module.exports = deprecate;
-
-/**
- * Mark that a method should not be used.
- * Returns a modified function which warns once by default.
- *
- * If `localStorage.noDeprecation = true` is set, then it is a no-op.
- *
- * If `localStorage.throwDeprecation = true` is set, then deprecated functions
- * will throw an Error when invoked.
- *
- * If `localStorage.traceDeprecation = true` is set, then deprecated functions
- * will invoke `console.trace()` instead of `console.error()`.
- *
- * @param {Function} fn - the function to deprecate
- * @param {String} msg - the string to print to the console when `fn` is invoked
- * @returns {Function} a new "deprecated" version of `fn`
- * @api public
- */
-
-function deprecate (fn, msg) {
-  if (config('noDeprecation')) {
-    return fn;
-  }
-
-  var warned = false;
-  function deprecated() {
-    if (!warned) {
-      if (config('throwDeprecation')) {
-        throw new Error(msg);
-      } else if (config('traceDeprecation')) {
-        console.trace(msg);
-      } else {
-        console.warn(msg);
-      }
-      warned = true;
-    }
-    return fn.apply(this, arguments);
-  }
-
-  return deprecated;
-}
-
-/**
- * Checks `localStorage` for boolean values for the given `name`.
- *
- * @param {String} name
- * @returns {Boolean}
- * @api private
- */
-
-function config (name) {
-  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
-  try {
-    if (!global.localStorage) return false;
-  } catch (_) {
-    return false;
-  }
-  var val = global.localStorage[name];
-  if (null == val) return false;
-  return String(val).toLowerCase() === 'true';
-}
-
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{}],161:[function(require,module,exports){
-module.exports = function isBuffer(arg) {
-  return arg && typeof arg === 'object'
-    && typeof arg.copy === 'function'
-    && typeof arg.fill === 'function'
-    && typeof arg.readUInt8 === 'function';
-}
-},{}],162:[function(require,module,exports){
-(function (process,global){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-var formatRegExp = /%[sdj%]/g;
-exports.format = function(f) {
-  if (!isString(f)) {
-    var objects = [];
-    for (var i = 0; i < arguments.length; i++) {
-      objects.push(inspect(arguments[i]));
-    }
-    return objects.join(' ');
-  }
-
-  var i = 1;
-  var args = arguments;
-  var len = args.length;
-  var str = String(f).replace(formatRegExp, function(x) {
-    if (x === '%%') return '%';
-    if (i >= len) return x;
-    switch (x) {
-      case '%s': return String(args[i++]);
-      case '%d': return Number(args[i++]);
-      case '%j':
-        try {
-          return JSON.stringify(args[i++]);
-        } catch (_) {
-          return '[Circular]';
-        }
-      default:
-        return x;
-    }
-  });
-  for (var x = args[i]; i < len; x = args[++i]) {
-    if (isNull(x) || !isObject(x)) {
-      str += ' ' + x;
-    } else {
-      str += ' ' + inspect(x);
-    }
-  }
-  return str;
-};
-
-
-// Mark that a method should not be used.
-// Returns a modified function which warns once by default.
-// If --no-deprecation is set, then it is a no-op.
-exports.deprecate = function(fn, msg) {
-  // Allow for deprecating things in the process of starting up.
-  if (isUndefined(global.process)) {
-    return function() {
-      return exports.deprecate(fn, msg).apply(this, arguments);
-    };
-  }
-
-  if (process.noDeprecation === true) {
-    return fn;
-  }
-
-  var warned = false;
-  function deprecated() {
-    if (!warned) {
-      if (process.throwDeprecation) {
-        throw new Error(msg);
-      } else if (process.traceDeprecation) {
-        console.trace(msg);
-      } else {
-        console.error(msg);
-      }
-      warned = true;
-    }
-    return fn.apply(this, arguments);
-  }
-
-  return deprecated;
-};
-
-
-var debugs = {};
-var debugEnviron;
-exports.debuglog = function(set) {
-  if (isUndefined(debugEnviron))
-    debugEnviron = process.env.NODE_DEBUG || '';
-  set = set.toUpperCase();
-  if (!debugs[set]) {
-    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
-      var pid = process.pid;
-      debugs[set] = function() {
-        var msg = exports.format.apply(exports, arguments);
-        console.error('%s %d: %s', set, pid, msg);
-      };
-    } else {
-      debugs[set] = function() {};
-    }
-  }
-  return debugs[set];
-};
-
-
-/**
- * Echos the value of a value. Trys to print the value out
- * in the best way possible given the different types.
- *
- * @param {Object} obj The object to print out.
- * @param {Object} opts Optional options object that alters the output.
- */
-/* legacy: obj, showHidden, depth, colors*/
-function inspect(obj, opts) {
-  // default options
-  var ctx = {
-    seen: [],
-    stylize: stylizeNoColor
-  };
-  // legacy...
-  if (arguments.length >= 3) ctx.depth = arguments[2];
-  if (arguments.length >= 4) ctx.colors = arguments[3];
-  if (isBoolean(opts)) {
-    // legacy...
-    ctx.showHidden = opts;
-  } else if (opts) {
-    // got an "options" object
-    exports._extend(ctx, opts);
-  }
-  // set default options
-  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
-  if (isUndefined(ctx.depth)) ctx.depth = 2;
-  if (isUndefined(ctx.colors)) ctx.colors = false;
-  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
-  if (ctx.colors) ctx.stylize = stylizeWithColor;
-  return formatValue(ctx, obj, ctx.depth);
-}
-exports.inspect = inspect;
-
-
-// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
-inspect.colors = {
-  'bold' : [1, 22],
-  'italic' : [3, 23],
-  'underline' : [4, 24],
-  'inverse' : [7, 27],
-  'white' : [37, 39],
-  'grey' : [90, 39],
-  'black' : [30, 39],
-  'blue' : [34, 39],
-  'cyan' : [36, 39],
-  'green' : [32, 39],
-  'magenta' : [35, 39],
-  'red' : [31, 39],
-  'yellow' : [33, 39]
-};
-
-// Don't use 'blue' not visible on cmd.exe
-inspect.styles = {
-  'special': 'cyan',
-  'number': 'yellow',
-  'boolean': 'yellow',
-  'undefined': 'grey',
-  'null': 'bold',
-  'string': 'green',
-  'date': 'magenta',
-  // "name": intentionally not styling
-  'regexp': 'red'
-};
-
-
-function stylizeWithColor(str, styleType) {
-  var style = inspect.styles[styleType];
-
-  if (style) {
-    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
-           '\u001b[' + inspect.colors[style][1] + 'm';
-  } else {
-    return str;
-  }
-}
-
-
-function stylizeNoColor(str, styleType) {
-  return str;
-}
-
-
-function arrayToHash(array) {
-  var hash = {};
-
-  array.forEach(function(val, idx) {
-    hash[val] = true;
-  });
-
-  return hash;
-}
-
-
-function formatValue(ctx, value, recurseTimes) {
-  // Provide a hook for user-specified inspect functions.
-  // Check that value is an object with an inspect function on it
-  if (ctx.customInspect &&
-      value &&
-      isFunction(value.inspect) &&
-      // Filter out the util module, it's inspect function is special
-      value.inspect !== exports.inspect &&
-      // Also filter out any prototype objects using the circular check.
-      !(value.constructor && value.constructor.prototype === value)) {
-    var ret = value.inspect(recurseTimes, ctx);
-    if (!isString(ret)) {
-      ret = formatValue(ctx, ret, recurseTimes);
-    }
-    return ret;
-  }
-
-  // Primitive types cannot have properties
-  var primitive = formatPrimitive(ctx, value);
-  if (primitive) {
-    return primitive;
-  }
-
-  // Look up the keys of the object.
-  var keys = Object.keys(value);
-  var visibleKeys = arrayToHash(keys);
-
-  if (ctx.showHidden) {
-    keys = Object.getOwnPropertyNames(value);
-  }
-
-  // IE doesn't make error fields non-enumerable
-  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
-  if (isError(value)
-      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
-    return formatError(value);
-  }
-
-  // Some type of object without properties can be shortcutted.
-  if (keys.length === 0) {
-    if (isFunction(value)) {
-      var name = value.name ? ': ' + value.name : '';
-      return ctx.stylize('[Function' + name + ']', 'special');
-    }
-    if (isRegExp(value)) {
-      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
-    }
-    if (isDate(value)) {
-      return ctx.stylize(Date.prototype.toString.call(value), 'date');
-    }
-    if (isError(value)) {
-      return formatError(value);
-    }
-  }
-
-  var base = '', array = false, braces = ['{', '}'];
-
-  // Make Array say that they are Array
-  if (isArray(value)) {
-    array = true;
-    braces = ['[', ']'];
-  }
-
-  // Make functions say that they are functions
-  if (isFunction(value)) {
-    var n = value.name ? ': ' + value.name : '';
-    base = ' [Function' + n + ']';
-  }
-
-  // Make RegExps say that they are RegExps
-  if (isRegExp(value)) {
-    base = ' ' + RegExp.prototype.toString.call(value);
-  }
-
-  // Make dates with properties first say the date
-  if (isDate(value)) {
-    base = ' ' + Date.prototype.toUTCString.call(value);
-  }
-
-  // Make error with message first say the error
-  if (isError(value)) {
-    base = ' ' + formatError(value);
-  }
-
-  if (keys.length === 0 && (!array || value.length == 0)) {
-    return braces[0] + base + braces[1];
-  }
-
-  if (recurseTimes < 0) {
-    if (isRegExp(value)) {
-      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
-    } else {
-      return ctx.stylize('[Object]', 'special');
-    }
-  }
-
-  ctx.seen.push(value);
-
-  var output;
-  if (array) {
-    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
-  } else {
-    output = keys.map(function(key) {
-      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
-    });
-  }
-
-  ctx.seen.pop();
-
-  return reduceToSingleString(output, base, braces);
-}
-
-
-function formatPrimitive(ctx, value) {
-  if (isUndefined(value))
-    return ctx.stylize('undefined', 'undefined');
-  if (isString(value)) {
-    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
-                                             .replace(/'/g, "\\'")
-                                             .replace(/\\"/g, '"') + '\'';
-    return ctx.stylize(simple, 'string');
-  }
-  if (isNumber(value))
-    return ctx.stylize('' + value, 'number');
-  if (isBoolean(value))
-    return ctx.stylize('' + value, 'boolean');
-  // For some reason typeof null is "object", so special case here.
-  if (isNull(value))
-    return ctx.stylize('null', 'null');
-}
-
-
-function formatError(value) {
-  return '[' + Error.prototype.toString.call(value) + ']';
-}
-
-
-function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
-  var output = [];
-  for (var i = 0, l = value.length; i < l; ++i) {
-    if (hasOwnProperty(value, String(i))) {
-      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
-          String(i), true));
-    } else {
-      output.push('');
-    }
-  }
-  keys.forEach(function(key) {
-    if (!key.match(/^\d+$/)) {
-      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
-          key, true));
-    }
-  });
-  return output;
-}
-
-
-function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
-  var name, str, desc;
-  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
-  if (desc.get) {
-    if (desc.set) {
-      str = ctx.stylize('[Getter/Setter]', 'special');
-    } else {
-      str = ctx.stylize('[Getter]', 'special');
-    }
-  } else {
-    if (desc.set) {
-      str = ctx.stylize('[Setter]', 'special');
-    }
-  }
-  if (!hasOwnProperty(visibleKeys, key)) {
-    name = '[' + key + ']';
-  }
-  if (!str) {
-    if (ctx.seen.indexOf(desc.value) < 0) {
-      if (isNull(recurseTimes)) {
-        str = formatValue(ctx, desc.value, null);
-      } else {
-        str = formatValue(ctx, desc.value, recurseTimes - 1);
-      }
-      if (str.indexOf('\n') > -1) {
-        if (array) {
-          str = str.split('\n').map(function(line) {
-            return '  ' + line;
-          }).join('\n').substr(2);
-        } else {
-          str = '\n' + str.split('\n').map(function(line) {
-            return '   ' + line;
-          }).join('\n');
-        }
-      }
-    } else {
-      str = ctx.stylize('[Circular]', 'special');
-    }
-  }
-  if (isUndefined(name)) {
-    if (array && key.match(/^\d+$/)) {
-      return str;
-    }
-    name = JSON.stringify('' + key);
-    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
-      name = name.substr(1, name.length - 2);
-      name = ctx.stylize(name, 'name');
-    } else {
-      name = name.replace(/'/g, "\\'")
-                 .replace(/\\"/g, '"')
-                 .replace(/(^"|"$)/g, "'");
-      name = ctx.stylize(name, 'string');
-    }
-  }
-
-  return name + ': ' + str;
-}
-
-
-function reduceToSingleString(output, base, braces) {
-  var numLinesEst = 0;
-  var length = output.reduce(function(prev, cur) {
-    numLinesEst++;
-    if (cur.indexOf('\n') >= 0) numLinesEst++;
-    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
-  }, 0);
-
-  if (length > 60) {
-    return braces[0] +
-           (base === '' ? '' : base + '\n ') +
-           ' ' +
-           output.join(',\n  ') +
-           ' ' +
-           braces[1];
-  }
-
-  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
-}
-
-
-// NOTE: These type checking functions intentionally don't use `instanceof`
-// because it is fragile and can be easily faked with `Object.create()`.
-function isArray(ar) {
-  return Array.isArray(ar);
-}
-exports.isArray = isArray;
-
-function isBoolean(arg) {
-  return typeof arg === 'boolean';
-}
-exports.isBoolean = isBoolean;
-
-function isNull(arg) {
-  return arg === null;
-}
-exports.isNull = isNull;
-
-function isNullOrUndefined(arg) {
-  return arg == null;
-}
-exports.isNullOrUndefined = isNullOrUndefined;
-
-function isNumber(arg) {
-  return typeof arg === 'number';
-}
-exports.isNumber = isNumber;
-
-function isString(arg) {
-  return typeof arg === 'string';
-}
-exports.isString = isString;
-
-function isSymbol(arg) {
-  return typeof arg === 'symbol';
-}
-exports.isSymbol = isSymbol;
-
-function isUndefined(arg) {
-  return arg === void 0;
-}
-exports.isUndefined = isUndefined;
-
-function isRegExp(re) {
-  return isObject(re) && objectToString(re) === '[object RegExp]';
-}
-exports.isRegExp = isRegExp;
-
-function isObject(arg) {
-  return typeof arg === 'object' && arg !== null;
-}
-exports.isObject = isObject;
-
-function isDate(d) {
-  return isObject(d) && objectToString(d) === '[object Date]';
-}
-exports.isDate = isDate;
-
-function isError(e) {
-  return isObject(e) &&
-      (objectToString(e) === '[object Error]' || e instanceof Error);
-}
-exports.isError = isError;
-
-function isFunction(arg) {
-  return typeof arg === 'function';
-}
-exports.isFunction = isFunction;
-
-function isPrimitive(arg) {
-  return arg === null ||
-         typeof arg === 'boolean' ||
-         typeof arg === 'number' ||
-         typeof arg === 'string' ||
-         typeof arg === 'symbol' ||  // ES6 symbol
-         typeof arg === 'undefined';
-}
-exports.isPrimitive = isPrimitive;
-
-exports.isBuffer = require('./support/isBuffer');
-
-function objectToString(o) {
-  return Object.prototype.toString.call(o);
-}
-
-
-function pad(n) {
-  return n < 10 ? '0' + n.toString(10) : n.toString(10);
-}
-
-
-var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
-              'Oct', 'Nov', 'Dec'];
-
-// 26 Feb 16:19:34
-function timestamp() {
-  var d = new Date();
-  var time = [pad(d.getHours()),
-              pad(d.getMinutes()),
-              pad(d.getSeconds())].join(':');
-  return [d.getDate(), months[d.getMonth()], time].join(' ');
-}
-
-
-// log is just a thin wrapper to console.log that prepends a timestamp
-exports.log = function() {
-  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
-};
-
-
-/**
- * Inherit the prototype methods from one constructor into another.
- *
- * The Function.prototype.inherits from lang.js rewritten as a standalone
- * function (not on Function.prototype). NOTE: If this file is to be loaded
- * during bootstrapping this function needs to be rewritten using some native
- * functions as prototype setup using normal JavaScript does not work as
- * expected during bootstrapping (see mirror.js in r114903).
- *
- * @param {function} ctor Constructor function which needs to inherit the
- *     prototype.
- * @param {function} superCtor Constructor function to inherit prototype from.
- */
-exports.inherits = require('inherits');
-
-exports._extend = function(origin, add) {
-  // Don't do anything if add isn't an object
-  if (!add || !isObject(add)) return origin;
-
-  var keys = Object.keys(add);
-  var i = keys.length;
-  while (i--) {
-    origin[keys[i]] = add[keys[i]];
-  }
-  return origin;
-};
-
-function hasOwnProperty(obj, prop) {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./support/isBuffer":161,"_process":125,"inherits":107}],163:[function(require,module,exports){
-var indexOf = function (xs, item) {
-    if (xs.indexOf) return xs.indexOf(item);
-    else for (var i = 0; i < xs.length; i++) {
-        if (xs[i] === item) return i;
-    }
-    return -1;
-};
-var Object_keys = function (obj) {
-    if (Object.keys) return Object.keys(obj)
-    else {
-        var res = [];
-        for (var key in obj) res.push(key)
-        return res;
-    }
-};
-
-var forEach = function (xs, fn) {
-    if (xs.forEach) return xs.forEach(fn)
-    else for (var i = 0; i < xs.length; i++) {
-        fn(xs[i], i, xs);
-    }
-};
-
-var defineProp = (function() {
-    try {
-        Object.defineProperty({}, '_', {});
-        return function(obj, name, value) {
-            Object.defineProperty(obj, name, {
-                writable: true,
-                enumerable: false,
-                configurable: true,
-                value: value
-            })
-        };
-    } catch(e) {
-        return function(obj, name, value) {
-            obj[name] = value;
-        };
-    }
-}());
-
-var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function',
-'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError',
-'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError',
-'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape',
-'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'];
-
-function Context() {}
-Context.prototype = {};
-
-var Script = exports.Script = function NodeScript (code) {
-    if (!(this instanceof Script)) return new Script(code);
-    this.code = code;
-};
-
-Script.prototype.runInContext = function (context) {
-    if (!(context instanceof Context)) {
-        throw new TypeError("needs a 'context' argument.");
-    }
-    
-    var iframe = document.createElement('iframe');
-    if (!iframe.style) iframe.style = {};
-    iframe.style.display = 'none';
-    
-    document.body.appendChild(iframe);
-    
-    var win = iframe.contentWindow;
-    var wEval = win.eval, wExecScript = win.execScript;
-
-    if (!wEval && wExecScript) {
-        // win.eval() magically appears when this is called in IE:
-        wExecScript.call(win, 'null');
-        wEval = win.eval;
-    }
-    
-    forEach(Object_keys(context), function (key) {
-        win[key] = context[key];
-    });
-    forEach(globals, function (key) {
-        if (context[key]) {
-            win[key] = context[key];
-        }
-    });
-    
-    var winKeys = Object_keys(win);
-
-    var res = wEval.call(win, this.code);
-    
-    forEach(Object_keys(win), function (key) {
-        // Avoid copying circular objects like `top` and `window` by only
-        // updating existing context properties or new properties in the `win`
-        // that was only introduced after the eval.
-        if (key in context || indexOf(winKeys, key) === -1) {
-            context[key] = win[key];
-        }
-    });
-
-    forEach(globals, function (key) {
-        if (!(key in context)) {
-            defineProp(context, key, win[key]);
-        }
-    });
-    
-    document.body.removeChild(iframe);
-    
-    return res;
-};
-
-Script.prototype.runInThisContext = function () {
-    return eval(this.code); // maybe...
-};
-
-Script.prototype.runInNewContext = function (context) {
-    var ctx = Script.createContext(context);
-    var res = this.runInContext(ctx);
-
-    if (context) {
-        forEach(Object_keys(ctx), function (key) {
-            context[key] = ctx[key];
-        });
-    }
-
-    return res;
-};
-
-forEach(Object_keys(Script.prototype), function (name) {
-    exports[name] = Script[name] = function (code) {
-        var s = Script(code);
-        return s[name].apply(s, [].slice.call(arguments, 1));
-    };
-});
-
-exports.createScript = function (code) {
-    return exports.Script(code);
-};
-
-exports.createContext = Script.createContext = function (context) {
-    var copy = new Context();
-    if(typeof context === 'object') {
-        forEach(Object_keys(context), function (key) {
-            copy[key] = context[key];
-        });
-    }
-    return copy;
-};
-
-},{}]},{},[1]);
+                        if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
 
+                        // the point at which write() starts returning false
+                        // Note: 0 is a valid value, means that we always return false if
+                        // the entire buffer is not flushed immediately on write()
+                        var hwm = options.highWaterMark;
+                        var writableHwm = options.writableHighWaterMark;
+                        var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+
+                        if (hwm || hwm === 0) this.highWaterMark = hwm;
+                        else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark =
+                            writableHwm;
+                        else this.highWaterMark = defaultHwm;
+
+                        // cast to ints.
+                        this.highWaterMark = Math.floor(this.highWaterMark);
+
+                        // if _final has been called
+                        this.finalCalled = false;
+
+                        // drain event flag.
+                        this.needDrain = false;
+                        // at the start of calling end()
+                        this.ending = false;
+                        // when end() has been called, and returned
+                        this.ended = false;
+                        // when 'finish' is emitted
+                        this.finished = false;
+
+                        // has it been destroyed
+                        this.destroyed = false;
+
+                        // should we decode strings into buffers before passing to _write?
+                        // this is here so that some node-core streams can optimize string
+                        // handling at a lower level.
+                        var noDecode = options.decodeStrings === false;
+                        this.decodeStrings = !noDecode;
+
+                        // Crypto is kind of old and crusty.  Historically, its default string
+                        // encoding is 'binary' so we have to make this configurable.
+                        // Everything else in the universe uses 'utf8', though.
+                        this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+                        // not an actual buffer we keep track of, but a measurement
+                        // of how much we're waiting to get pushed to some underlying
+                        // socket or file.
+                        this.length = 0;
+
+                        // a flag to see when we're in the middle of a write.
+                        this.writing = false;
+
+                        // when true all writes will be buffered until .uncork() call
+                        this.corked = 0;
+
+                        // a flag to be able to tell if the onwrite cb is called immediately,
+                        // or on a later tick.  We set this to true at first, because any
+                        // actions that shouldn't happen until "later" should generally also
+                        // not happen before the first write call.
+                        this.sync = true;
+
+                        // a flag to know if we're processing previously buffered items, which
+                        // may call the _write() callback in the same tick, so that we don't
+                        // end up in an overlapped onwrite situation.
+                        this.bufferProcessing = false;
+
+                        // the callback that's passed to _write(chunk,cb)
+                        this.onwrite = function (er) {
+                            onwrite(stream, er);
+                        };
+
+                        // the callback that the user supplies to write(chunk,encoding,cb)
+                        this.writecb = null;
+
+                        // the amount that is being written when _write is called.
+                        this.writelen = 0;
+
+                        this.bufferedRequest = null;
+                        this.lastBufferedRequest = null;
+
+                        // number of pending user-supplied write callbacks
+                        // this must be 0 before 'finish' can be emitted
+                        this.pendingcb = 0;
+
+                        // emit prefinish if the only thing we're waiting for is _write cbs
+                        // This is relevant for synchronous Transform streams
+                        this.prefinished = false;
+
+                        // True if the error was already emitted and should not be thrown again
+                        this.errorEmitted = false;
+
+                        // count buffered requests
+                        this.bufferedRequestCount = 0;
+
+                        // allocate the first CorkedRequest, there is always
+                        // one allocated and free to use, and we maintain at most two
+                        this.corkedRequestsFree = new CorkedRequest(this);
+                    }
+
+                    WritableState.prototype.getBuffer = function getBuffer() {
+                        var current = this.bufferedRequest;
+                        var out = [];
+                        while (current) {
+                            out.push(current);
+                            current = current.next;
+                        }
+                        return out;
+                    };
+
+                    (function () {
+                        try {
+                            Object.defineProperty(WritableState.prototype, 'buffer', {
+                                get: internalUtil.deprecate(function () {
+                                        return this.getBuffer();
+                                    },
+                                    '_writableState.buffer is deprecated. Use _writableState.getBuffer ' +
+                                    'instead.', 'DEP0003')
+                            });
+                        } catch (_) {}
+                    })();
+
+                    // Test _writableState for inheritance to account for Duplex streams,
+                    // whose prototype chain only points to Readable.
+                    var realHasInstance;
+                    if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[
+                            Symbol.hasInstance] === 'function') {
+                        realHasInstance = Function.prototype[Symbol.hasInstance];
+                        Object.defineProperty(Writable, Symbol.hasInstance, {
+                            value: function (object) {
+                                if (realHasInstance.call(this, object)) return true;
+                                if (this !== Writable) return false;
+
+                                return object && object._writableState instanceof WritableState;
+                            }
+                        });
+                    } else {
+                        realHasInstance = function (object) {
+                            return object instanceof this;
+                        };
+                    }
+
+                    function Writable(options) {
+                        Duplex = Duplex || require('./_stream_duplex');
+
+                        // Writable ctor is applied to Duplexes, too.
+                        // `realHasInstance` is necessary because using plain `instanceof`
+                        // would return false, as no `_writableState` property is attached.
+
+                        // Trying to use the custom `instanceof` for Writable here will also break the
+                        // Node.js LazyTransform implementation, which has a non-trivial getter for
+                        // `_writableState` that would lead to infinite recursion.
+                        if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
+                            return new Writable(options);
+                        }
+
+                        this._writableState = new WritableState(options, this);
+
+                        // legacy.
+                        this.writable = true;
+
+                        if (options) {
+                            if (typeof options.write === 'function') this._write = options.write;
+
+                            if (typeof options.writev === 'function') this._writev = options.writev;
+
+                            if (typeof options.destroy === 'function') this._destroy = options.destroy;
+
+                            if (typeof options.final === 'function') this._final = options.final;
+                        }
+
+                        Stream.call(this);
+                    }
+
+                    // Otherwise people can pipe Writable streams, which is just wrong.
+                    Writable.prototype.pipe = function () {
+                        this.emit('error', new Error('Cannot pipe, not readable'));
+                    };
+
+                    function writeAfterEnd(stream, cb) {
+                        var er = new Error('write after end');
+                        // TODO: defer error events consistently everywhere, not just the cb
+                        stream.emit('error', er);
+                        pna.nextTick(cb, er);
+                    }
+
+                    // Checks that a user-supplied chunk is valid, especially for the particular
+                    // mode the stream is in. Currently this means that `null` is never accepted
+                    // and undefined/non-string values are only allowed in object mode.
+                    function validChunk(stream, state, chunk, cb) {
+                        var valid = true;
+                        var er = false;
+
+                        if (chunk === null) {
+                            er = new TypeError('May not write null values to stream');
+                        } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+                            er = new TypeError('Invalid non-string/buffer chunk');
+                        }
+                        if (er) {
+                            stream.emit('error', er);
+                            pna.nextTick(cb, er);
+                            valid = false;
+                        }
+                        return valid;
+                    }
+
+                    Writable.prototype.write = function (chunk, encoding, cb) {
+                        var state = this._writableState;
+                        var ret = false;
+                        var isBuf = !state.objectMode && _isUint8Array(chunk);
+
+                        if (isBuf && !Buffer.isBuffer(chunk)) {
+                            chunk = _uint8ArrayToBuffer(chunk);
+                        }
+
+                        if (typeof encoding === 'function') {
+                            cb = encoding;
+                            encoding = null;
+                        }
+
+                        if (isBuf) encoding = 'buffer';
+                        else if (!encoding) encoding = state.defaultEncoding;
+
+                        if (typeof cb !== 'function') cb = nop;
+
+                        if (state.ended) writeAfterEnd(this, cb);
+                        else if (isBuf || validChunk(this, state, chunk, cb)) {
+                            state.pendingcb++;
+                            ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+                        }
+
+                        return ret;
+                    };
+
+                    Writable.prototype.cork = function () {
+                        var state = this._writableState;
+
+                        state.corked++;
+                    };
+
+                    Writable.prototype.uncork = function () {
+                        var state = this._writableState;
+
+                        if (state.corked) {
+                            state.corked--;
+
+                            if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing &&
+                                state.bufferedRequest) clearBuffer(this, state);
+                        }
+                    };
+
+                    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+                        // node::ParseEncoding() requires lower case.
+                        if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+                        if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2',
+                                'utf16le', 'utf-16le', 'raw'
+                            ].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError(
+                            'Unknown encoding: ' + encoding);
+                        this._writableState.defaultEncoding = encoding;
+                        return this;
+                    };
+
+                    function decodeChunk(state, chunk, encoding) {
+                        if (!state.objectMode && state.decodeStrings !== false && typeof chunk ===
+                            'string') {
+                            chunk = Buffer.from(chunk, encoding);
+                        }
+                        return chunk;
+                    }
+
+                    Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
+                        // making it explicit this property is not enumerable
+                        // because otherwise some prototype manipulation in
+                        // userland will fail
+                        enumerable: false,
+                        get: function () {
+                            return this._writableState.highWaterMark;
+                        }
+                    });
+
+                    // if we're already writing something, then just put this
+                    // in the queue, and wait our turn.  Otherwise, call _write
+                    // If we return false, then we need a drain event, so set that flag.
+                    function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+                        if (!isBuf) {
+                            var newChunk = decodeChunk(state, chunk, encoding);
+                            if (chunk !== newChunk) {
+                                isBuf = true;
+                                encoding = 'buffer';
+                                chunk = newChunk;
+                            }
+                        }
+                        var len = state.objectMode ? 1 : chunk.length;
+
+                        state.length += len;
+
+                        var ret = state.length < state.highWaterMark;
+                        // we must ensure that previous needDrain will not be reset to false.
+                        if (!ret) state.needDrain = true;
+
+                        if (state.writing || state.corked) {
+                            var last = state.lastBufferedRequest;
+                            state.lastBufferedRequest = {
+                                chunk: chunk,
+                                encoding: encoding,
+                                isBuf: isBuf,
+                                callback: cb,
+                                next: null
+                            };
+                            if (last) {
+                                last.next = state.lastBufferedRequest;
+                            } else {
+                                state.bufferedRequest = state.lastBufferedRequest;
+                            }
+                            state.bufferedRequestCount += 1;
+                        } else {
+                            doWrite(stream, state, false, len, chunk, encoding, cb);
+                        }
+
+                        return ret;
+                    }
+
+                    function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+                        state.writelen = len;
+                        state.writecb = cb;
+                        state.writing = true;
+                        state.sync = true;
+                        if (writev) stream._writev(chunk, state.onwrite);
+                        else stream._write(chunk, encoding, state.onwrite);
+                        state.sync = false;
+                    }
+
+                    function onwriteError(stream, state, sync, er, cb) {
+                        --state.pendingcb;
+
+                        if (sync) {
+                            // defer the callback if we are being called synchronously
+                            // to avoid piling up things on the stack
+                            pna.nextTick(cb, er);
+                            // this can emit finish, and it will always happen
+                            // after error
+                            pna.nextTick(finishMaybe, stream, state);
+                            stream._writableState.errorEmitted = true;
+                            stream.emit('error', er);
+                        } else {
+                            // the caller expect this to happen before if
+                            // it is async
+                            cb(er);
+                            stream._writableState.errorEmitted = true;
+                            stream.emit('error', er);
+                            // this can emit finish, but finish must
+                            // always follow error
+                            finishMaybe(stream, state);
+                        }
+                    }
+
+                    function onwriteStateUpdate(state) {
+                        state.writing = false;
+                        state.writecb = null;
+                        state.length -= state.writelen;
+                        state.writelen = 0;
+                    }
+
+                    function onwrite(stream, er) {
+                        var state = stream._writableState;
+                        var sync = state.sync;
+                        var cb = state.writecb;
+
+                        onwriteStateUpdate(state);
+
+                        if (er) onwriteError(stream, state, sync, er, cb);
+                        else {
+                            // Check if we're actually ready to finish, but don't emit yet
+                            var finished = needFinish(state);
+
+                            if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+                                clearBuffer(stream, state);
+                            }
+
+                            if (sync) {
+                                /*<replacement>*/
+                                asyncWrite(afterWrite, stream, state, finished, cb);
+                                /*</replacement>*/
+                            } else {
+                                afterWrite(stream, state, finished, cb);
+                            }
+                        }
+                    }
+
+                    function afterWrite(stream, state, finished, cb) {
+                        if (!finished) onwriteDrain(stream, state);
+                        state.pendingcb--;
+                        cb();
+                        finishMaybe(stream, state);
+                    }
+
+                    // Must force callback to be called on nextTick, so that we don't
+                    // emit 'drain' before the write() consumer gets the 'false' return
+                    // value, and has a chance to attach a 'drain' listener.
+                    function onwriteDrain(stream, state) {
+                        if (state.length === 0 && state.needDrain) {
+                            state.needDrain = false;
+                            stream.emit('drain');
+                        }
+                    }
+
+                    // if there's something in the buffer waiting, then process it
+                    function clearBuffer(stream, state) {
+                        state.bufferProcessing = true;
+                        var entry = state.bufferedRequest;
+
+                        if (stream._writev && entry && entry.next) {
+                            // Fast case, write everything using _writev()
+                            var l = state.bufferedRequestCount;
+                            var buffer = new Array(l);
+                            var holder = state.corkedRequestsFree;
+                            holder.entry = entry;
+
+                            var count = 0;
+                            var allBuffers = true;
+                            while (entry) {
+                                buffer[count] = entry;
+                                if (!entry.isBuf) allBuffers = false;
+                                entry = entry.next;
+                                count += 1;
+                            }
+                            buffer.allBuffers = allBuffers;
+
+                            doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+
+                            // doWrite is almost always async, defer these to save a bit of time
+                            // as the hot path ends with doWrite
+                            state.pendingcb++;
+                            state.lastBufferedRequest = null;
+                            if (holder.next) {
+                                state.corkedRequestsFree = holder.next;
+                                holder.next = null;
+                            } else {
+                                state.corkedRequestsFree = new CorkedRequest(state);
+                            }
+                            state.bufferedRequestCount = 0;
+                        } else {
+                            // Slow case, write chunks one-by-one
+                            while (entry) {
+                                var chunk = entry.chunk;
+                                var encoding = entry.encoding;
+                                var cb = entry.callback;
+                                var len = state.objectMode ? 1 : chunk.length;
+
+                                doWrite(stream, state, false, len, chunk, encoding, cb);
+                                entry = entry.next;
+                                state.bufferedRequestCount--;
+                                // if we didn't call the onwrite immediately, then
+                                // it means that we need to wait until it does.
+                                // also, that means that the chunk and cb are currently
+                                // being processed, so move the buffer counter past them.
+                                if (state.writing) {
+                                    break;
+                                }
+                            }
+
+                            if (entry === null) state.lastBufferedRequest = null;
+                        }
+
+                        state.bufferedRequest = entry;
+                        state.bufferProcessing = false;
+                    }
+
+                    Writable.prototype._write = function (chunk, encoding, cb) {
+                        cb(new Error('_write() is not implemented'));
+                    };
+
+                    Writable.prototype._writev = null;
+
+                    Writable.prototype.end = function (chunk, encoding, cb) {
+                        var state = this._writableState;
+
+                        if (typeof chunk === 'function') {
+                            cb = chunk;
+                            chunk = null;
+                            encoding = null;
+                        } else if (typeof encoding === 'function') {
+                            cb = encoding;
+                            encoding = null;
+                        }
+
+                        if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+
+                        // .end() fully uncorks
+                        if (state.corked) {
+                            state.corked = 1;
+                            this.uncork();
+                        }
+
+                        // ignore unnecessary end() calls.
+                        if (!state.ending && !state.finished) endWritable(this, state, cb);
+                    };
+
+                    function needFinish(state) {
+                        return state.ending && state.length === 0 && state.bufferedRequest === null &&
+                            !state.finished && !state.writing;
+                    }
+
+                    function callFinal(stream, state) {
+                        stream._final(function (err) {
+                            state.pendingcb--;
+                            if (err) {
+                                stream.emit('error', err);
+                            }
+                            state.prefinished = true;
+                            stream.emit('prefinish');
+                            finishMaybe(stream, state);
+                        });
+                    }
+
+                    function prefinish(stream, state) {
+                        if (!state.prefinished && !state.finalCalled) {
+                            if (typeof stream._final === 'function') {
+                                state.pendingcb++;
+                                state.finalCalled = true;
+                                pna.nextTick(callFinal, stream, state);
+                            } else {
+                                state.prefinished = true;
+                                stream.emit('prefinish');
+                            }
+                        }
+                    }
+
+                    function finishMaybe(stream, state) {
+                        var need = needFinish(state);
+                        if (need) {
+                            prefinish(stream, state);
+                            if (state.pendingcb === 0) {
+                                state.finished = true;
+                                stream.emit('finish');
+                            }
+                        }
+                        return need;
+                    }
+
+                    function endWritable(stream, state, cb) {
+                        state.ending = true;
+                        finishMaybe(stream, state);
+                        if (cb) {
+                            if (state.finished) pna.nextTick(cb);
+                            else stream.once('finish', cb);
+                        }
+                        state.ended = true;
+                        stream.writable = false;
+                    }
+
+                    function onCorkedFinish(corkReq, state, err) {
+                        var entry = corkReq.entry;
+                        corkReq.entry = null;
+                        while (entry) {
+                            var cb = entry.callback;
+                            state.pendingcb--;
+                            cb(err);
+                            entry = entry.next;
+                        }
+                        if (state.corkedRequestsFree) {
+                            state.corkedRequestsFree.next = corkReq;
+                        } else {
+                            state.corkedRequestsFree = corkReq;
+                        }
+                    }
+
+                    Object.defineProperty(Writable.prototype, 'destroyed', {
+                        get: function () {
+                            if (this._writableState === undefined) {
+                                return false;
+                            }
+                            return this._writableState.destroyed;
+                        },
+                        set: function (value) {
+                            // we ignore the value if the stream
+                            // has not been initialized yet
+                            if (!this._writableState) {
+                                return;
+                            }
+
+                            // backward compatibility, the user is explicitly
+                            // managing destroyed
+                            this._writableState.destroyed = value;
+                        }
+                    });
+
+                    Writable.prototype.destroy = destroyImpl.destroy;
+                    Writable.prototype._undestroy = destroyImpl.undestroy;
+                    Writable.prototype._destroy = function (err, cb) {
+                        this.end();
+                        cb(err);
+                    };
+                }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !==
+                    "undefined" ? self : typeof window !== "undefined" ? window : {}, require("timers")
+                    .setImmediate)
+            }, {
+                "./_stream_duplex": 135,
+                "./internal/streams/destroy": 141,
+                "./internal/streams/stream": 142,
+                "_process": 125,
+                "core-util-is": 57,
+                "inherits": 107,
+                "process-nextick-args": 124,
+                "safe-buffer": 148,
+                "timers": 159,
+                "util-deprecate": 160
+            }],
+            140: [function (require, module, exports) {
+                'use strict';
+
+                function _classCallCheck(instance, Constructor) {
+                    if (!(instance instanceof Constructor)) {
+                        throw new TypeError("Cannot call a class as a function");
+                    }
+                }
+
+                var Buffer = require('safe-buffer').Buffer;
+                var util = require('util');
+
+                function copyBuffer(src, target, offset) {
+                    src.copy(target, offset);
+                }
+
+                module.exports = function () {
+                    function BufferList() {
+                        _classCallCheck(this, BufferList);
+
+                        this.head = null;
+                        this.tail = null;
+                        this.length = 0;
+                    }
+
+                    BufferList.prototype.push = function push(v) {
+                        var entry = {
+                            data: v,
+                            next: null
+                        };
+                        if (this.length > 0) this.tail.next = entry;
+                        else this.head = entry;
+                        this.tail = entry;
+                        ++this.length;
+                    };
+
+                    BufferList.prototype.unshift = function unshift(v) {
+                        var entry = {
+                            data: v,
+                            next: this.head
+                        };
+                        if (this.length === 0) this.tail = entry;
+                        this.head = entry;
+                        ++this.length;
+                    };
+
+                    BufferList.prototype.shift = function shift() {
+                        if (this.length === 0) return;
+                        var ret = this.head.data;
+                        if (this.length === 1) this.head = this.tail = null;
+                        else this.head = this.head.next;
+                        --this.length;
+                        return ret;
+                    };
+
+                    BufferList.prototype.clear = function clear() {
+                        this.head = this.tail = null;
+                        this.length = 0;
+                    };
+
+                    BufferList.prototype.join = function join(s) {
+                        if (this.length === 0) return '';
+                        var p = this.head;
+                        var ret = '' + p.data;
+                        while (p = p.next) {
+                            ret += s + p.data;
+                        }
+                        return ret;
+                    };
+
+                    BufferList.prototype.concat = function concat(n) {
+                        if (this.length === 0) return Buffer.alloc(0);
+                        if (this.length === 1) return this.head.data;
+                        var ret = Buffer.allocUnsafe(n >>> 0);
+                        var p = this.head;
+                        var i = 0;
+                        while (p) {
+                            copyBuffer(p.data, ret, i);
+                            i += p.data.length;
+                            p = p.next;
+                        }
+                        return ret;
+                    };
+
+                    return BufferList;
+                }();
+
+                if (util && util.inspect && util.inspect.custom) {
+                    module.exports.prototype[util.inspect.custom] = function () {
+                        var obj = util.inspect({
+                            length: this.length
+                        });
+                        return this.constructor.name + ' ' + obj;
+                    };
+                }
+            }, {
+                "safe-buffer": 148,
+                "util": 26
+            }],
+            141: [function (require, module, exports) {
+                'use strict';
+
+                /*<replacement>*/
+
+                var pna = require('process-nextick-args');
+                /*</replacement>*/
+
+                // undocumented cb() API, needed for core, not for public API
+                function destroy(err, cb) {
+                    var _this = this;
+
+                    var readableDestroyed = this._readableState && this._readableState.destroyed;
+                    var writableDestroyed = this._writableState && this._writableState.destroyed;
+
+                    if (readableDestroyed || writableDestroyed) {
+                        if (cb) {
+                            cb(err);
+                        } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+                            pna.nextTick(emitErrorNT, this, err);
+                        }
+                        return this;
+                    }
+
+                    // we set destroyed to true before firing error callbacks in order
+                    // to make it re-entrance safe in case destroy() is called within callbacks
+
+                    if (this._readableState) {
+                        this._readableState.destroyed = true;
+                    }
+
+                    // if this is a duplex stream mark the writable part as destroyed as well
+                    if (this._writableState) {
+                        this._writableState.destroyed = true;
+                    }
+
+                    this._destroy(err || null, function (err) {
+                        if (!cb && err) {
+                            pna.nextTick(emitErrorNT, _this, err);
+                            if (_this._writableState) {
+                                _this._writableState.errorEmitted = true;
+                            }
+                        } else if (cb) {
+                            cb(err);
+                        }
+                    });
+
+                    return this;
+                }
+
+                function undestroy() {
+                    if (this._readableState) {
+                        this._readableState.destroyed = false;
+                        this._readableState.reading = false;
+                        this._readableState.ended = false;
+                        this._readableState.endEmitted = false;
+                    }
+
+                    if (this._writableState) {
+                        this._writableState.destroyed = false;
+                        this._writableState.ended = false;
+                        this._writableState.ending = false;
+                        this._writableState.finished = false;
+                        this._writableState.errorEmitted = false;
+                    }
+                }
+
+                function emitErrorNT(self, err) {
+                    self.emit('error', err);
+                }
+
+                module.exports = {
+                    destroy: destroy,
+                    undestroy: undestroy
+                };
+            }, {
+                "process-nextick-args": 124
+            }],
+            142: [function (require, module, exports) {
+                module.exports = require('events').EventEmitter;
+
+            }, {
+                "events": 90
+            }],
+            143: [function (require, module, exports) {
+                module.exports = require('./readable').PassThrough
+
+            }, {
+                "./readable": 144
+            }],
+            144: [function (require, module, exports) {
+                exports = module.exports = require('./lib/_stream_readable.js');
+                exports.Stream = exports;
+                exports.Readable = exports;
+                exports.Writable = require('./lib/_stream_writable.js');
+                exports.Duplex = require('./lib/_stream_duplex.js');
+                exports.Transform = require('./lib/_stream_transform.js');
+                exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+            }, {
+                "./lib/_stream_duplex.js": 135,
+                "./lib/_stream_passthrough.js": 136,
+                "./lib/_stream_readable.js": 137,
+                "./lib/_stream_transform.js": 138,
+                "./lib/_stream_writable.js": 139
+            }],
+            145: [function (require, module, exports) {
+                module.exports = require('./readable').Transform
+
+            }, {
+                "./readable": 144
+            }],
+            146: [function (require, module, exports) {
+                module.exports = require('./lib/_stream_writable.js');
+
+            }, {
+                "./lib/_stream_writable.js": 139
+            }],
+            147: [function (require, module, exports) {
+                'use strict'
+                var Buffer = require('buffer').Buffer
+                var inherits = require('inherits')
+                var HashBase = require('hash-base')
+
+                var ARRAY16 = new Array(16)
+
+                var zl = [
+                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+                    7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+                    3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+                    1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+                    4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
+                ]
+
+                var zr = [
+                    5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+                    6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+                    15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+                    8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+                    12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
+                ]
+
+                var sl = [
+                    11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+                    7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+                    11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+                    11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+                    9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
+                ]
+
+                var sr = [
+                    8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+                    9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+                    9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+                    15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+                    8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
+                ]
+
+                var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]
+                var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]
+
+                function RIPEMD160() {
+                    HashBase.call(this, 64)
+
+                    // state
+                    this._a = 0x67452301
+                    this._b = 0xefcdab89
+                    this._c = 0x98badcfe
+                    this._d = 0x10325476
+                    this._e = 0xc3d2e1f0
+                }
+
+                inherits(RIPEMD160, HashBase)
+
+                RIPEMD160.prototype._update = function () {
+                    var words = ARRAY16
+                    for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)
+
+                    var al = this._a | 0
+                    var bl = this._b | 0
+                    var cl = this._c | 0
+                    var dl = this._d | 0
+                    var el = this._e | 0
+
+                    var ar = this._a | 0
+                    var br = this._b | 0
+                    var cr = this._c | 0
+                    var dr = this._d | 0
+                    var er = this._e | 0
+
+                    // computation
+                    for (var i = 0; i < 80; i += 1) {
+                        var tl
+                        var tr
+                        if (i < 16) {
+                            tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])
+                            tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])
+                        } else if (i < 32) {
+                            tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])
+                            tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])
+                        } else if (i < 48) {
+                            tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])
+                            tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])
+                        } else if (i < 64) {
+                            tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])
+                            tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])
+                        } else { // if (i<80) {
+                            tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])
+                            tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])
+                        }
+
+                        al = el
+                        el = dl
+                        dl = rotl(cl, 10)
+                        cl = bl
+                        bl = tl
+
+                        ar = er
+                        er = dr
+                        dr = rotl(cr, 10)
+                        cr = br
+                        br = tr
+                    }
+
+                    // update state
+                    var t = (this._b + cl + dr) | 0
+                    this._b = (this._c + dl + er) | 0
+                    this._c = (this._d + el + ar) | 0
+                    this._d = (this._e + al + br) | 0
+                    this._e = (this._a + bl + cr) | 0
+                    this._a = t
+                }
+
+                RIPEMD160.prototype._digest = function () {
+                    // create padding and handle blocks
+                    this._block[this._blockOffset++] = 0x80
+                    if (this._blockOffset > 56) {
+                        this._block.fill(0, this._blockOffset, 64)
+                        this._update()
+                        this._blockOffset = 0
+                    }
+
+                    this._block.fill(0, this._blockOffset, 56)
+                    this._block.writeUInt32LE(this._length[0], 56)
+                    this._block.writeUInt32LE(this._length[1], 60)
+                    this._update()
+
+                    // produce result
+                    var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)
+                    buffer.writeInt32LE(this._a, 0)
+                    buffer.writeInt32LE(this._b, 4)
+                    buffer.writeInt32LE(this._c, 8)
+                    buffer.writeInt32LE(this._d, 12)
+                    buffer.writeInt32LE(this._e, 16)
+                    return buffer
+                }
+
+                function rotl(x, n) {
+                    return (x << n) | (x >>> (32 - n))
+                }
+
+                function fn1(a, b, c, d, e, m, k, s) {
+                    return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0
+                }
+
+                function fn2(a, b, c, d, e, m, k, s) {
+                    return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0
+                }
+
+                function fn3(a, b, c, d, e, m, k, s) {
+                    return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0
+                }
+
+                function fn4(a, b, c, d, e, m, k, s) {
+                    return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0
+                }
+
+                function fn5(a, b, c, d, e, m, k, s) {
+                    return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0
+                }
+
+                module.exports = RIPEMD160
+
+            }, {
+                "buffer": 55,
+                "hash-base": 92,
+                "inherits": 107
+            }],
+            148: [function (require, module, exports) {
+                arguments[4][7][0].apply(exports, arguments)
+            }, {
+                "buffer": 55,
+                "dup": 7
+            }],
+            149: [function (require, module, exports) {
+                var Buffer = require('safe-buffer').Buffer
+
+                // prototype class for hash functions
+                function Hash(blockSize, finalSize) {
+                    this._block = Buffer.alloc(blockSize)
+                    this._finalSize = finalSize
+                    this._blockSize = blockSize
+                    this._len = 0
+                }
+
+                Hash.prototype.update = function (data, enc) {
+                    if (typeof data === 'string') {
+                        enc = enc || 'utf8'
+                        data = Buffer.from(data, enc)
+                    }
+
+                    var block = this._block
+                    var blockSize = this._blockSize
+                    var length = data.length
+                    var accum = this._len
+
+                    for (var offset = 0; offset < length;) {
+                        var assigned = accum % blockSize
+                        var remainder = Math.min(length - offset, blockSize - assigned)
+
+                        for (var i = 0; i < remainder; i++) {
+                            block[assigned + i] = data[offset + i]
+                        }
+
+                        accum += remainder
+                        offset += remainder
+
+                        if ((accum % blockSize) === 0) {
+                            this._update(block)
+                        }
+                    }
+
+                    this._len += length
+                    return this
+                }
+
+                Hash.prototype.digest = function (enc) {
+                    var rem = this._len % this._blockSize
+
+                    this._block[rem] = 0x80
+
+                    // zero (rem + 1) trailing bits, where (rem + 1) is the smallest
+                    // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
+                    this._block.fill(0, rem + 1)
+
+                    if (rem >= this._finalSize) {
+                        this._update(this._block)
+                        this._block.fill(0)
+                    }
+
+                    var bits = this._len * 8
+
+                    // uint32
+                    if (bits <= 0xffffffff) {
+                        this._block.writeUInt32BE(bits, this._blockSize - 4)
+
+                        // uint64
+                    } else {
+                        var lowBits = (bits & 0xffffffff) >>> 0
+                        var highBits = (bits - lowBits) / 0x100000000
+
+                        this._block.writeUInt32BE(highBits, this._blockSize - 8)
+                        this._block.writeUInt32BE(lowBits, this._blockSize - 4)
+                    }
+
+                    this._update(this._block)
+                    var hash = this._hash()
+
+                    return enc ? hash.toString(enc) : hash
+                }
+
+                Hash.prototype._update = function () {
+                    throw new Error('_update must be implemented by subclass')
+                }
+
+                module.exports = Hash
+
+            }, {
+                "safe-buffer": 148
+            }],
+            150: [function (require, module, exports) {
+                var exports = module.exports = function SHA(algorithm) {
+                    algorithm = algorithm.toLowerCase()
+
+                    var Algorithm = exports[algorithm]
+                    if (!Algorithm) throw new Error(algorithm +
+                        ' is not supported (we accept pull requests)')
+
+                    return new Algorithm()
+                }
+
+                exports.sha = require('./sha')
+                exports.sha1 = require('./sha1')
+                exports.sha224 = require('./sha224')
+                exports.sha256 = require('./sha256')
+                exports.sha384 = require('./sha384')
+                exports.sha512 = require('./sha512')
+
+            }, {
+                "./sha": 151,
+                "./sha1": 152,
+                "./sha224": 153,
+                "./sha256": 154,
+                "./sha384": 155,
+                "./sha512": 156
+            }],
+            151: [function (require, module, exports) {
+                /*
+                * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
+                * in FIPS PUB 180-1
+                * This source code is derived from sha1.js of the same repository.
+                * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
+                * operation was added.
+                */
+
+                var inherits = require('inherits')
+                var Hash = require('./hash')
+                var Buffer = require('safe-buffer').Buffer
+
+                var K = [
+                    0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
+                ]
+
+                var W = new Array(80)
+
+                function Sha() {
+                    this.init()
+                    this._w = W
+
+                    Hash.call(this, 64, 56)
+                }
+
+                inherits(Sha, Hash)
+
+                Sha.prototype.init = function () {
+                    this._a = 0x67452301
+                    this._b = 0xefcdab89
+                    this._c = 0x98badcfe
+                    this._d = 0x10325476
+                    this._e = 0xc3d2e1f0
+
+                    return this
+                }
+
+                function rotl5(num) {
+                    return (num << 5) | (num >>> 27)
+                }
+
+                function rotl30(num) {
+                    return (num << 30) | (num >>> 2)
+                }
+
+                function ft(s, b, c, d) {
+                    if (s === 0) return (b & c) | ((~b) & d)
+                    if (s === 2) return (b & c) | (b & d) | (c & d)
+                    return b ^ c ^ d
+                }
+
+                Sha.prototype._update = function (M) {
+                    var W = this._w
+
+                    var a = this._a | 0
+                    var b = this._b | 0
+                    var c = this._c | 0
+                    var d = this._d | 0
+                    var e = this._e | 0
+
+                    for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
+                    for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]
+
+                    for (var j = 0; j < 80; ++j) {
+                        var s = ~~(j / 20)
+                        var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0
+
+                        e = d
+                        d = c
+                        c = rotl30(b)
+                        b = a
+                        a = t
+                    }
+
+                    this._a = (a + this._a) | 0
+                    this._b = (b + this._b) | 0
+                    this._c = (c + this._c) | 0
+                    this._d = (d + this._d) | 0
+                    this._e = (e + this._e) | 0
+                }
+
+                Sha.prototype._hash = function () {
+                    var H = Buffer.allocUnsafe(20)
+
+                    H.writeInt32BE(this._a | 0, 0)
+                    H.writeInt32BE(this._b | 0, 4)
+                    H.writeInt32BE(this._c | 0, 8)
+                    H.writeInt32BE(this._d | 0, 12)
+                    H.writeInt32BE(this._e | 0, 16)
+
+                    return H
+                }
+
+                module.exports = Sha
+
+            }, {
+                "./hash": 149,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            152: [function (require, module, exports) {
+                /*
+                * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+                * in FIPS PUB 180-1
+                * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+                * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+                * Distributed under the BSD License
+                * See http://pajhome.org.uk/crypt/md5 for details.
+                */
+
+                var inherits = require('inherits')
+                var Hash = require('./hash')
+                var Buffer = require('safe-buffer').Buffer
+
+                var K = [
+                    0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
+                ]
+
+                var W = new Array(80)
+
+                function Sha1() {
+                    this.init()
+                    this._w = W
+
+                    Hash.call(this, 64, 56)
+                }
+
+                inherits(Sha1, Hash)
+
+                Sha1.prototype.init = function () {
+                    this._a = 0x67452301
+                    this._b = 0xefcdab89
+                    this._c = 0x98badcfe
+                    this._d = 0x10325476
+                    this._e = 0xc3d2e1f0
+
+                    return this
+                }
+
+                function rotl1(num) {
+                    return (num << 1) | (num >>> 31)
+                }
+
+                function rotl5(num) {
+                    return (num << 5) | (num >>> 27)
+                }
+
+                function rotl30(num) {
+                    return (num << 30) | (num >>> 2)
+                }
+
+                function ft(s, b, c, d) {
+                    if (s === 0) return (b & c) | ((~b) & d)
+                    if (s === 2) return (b & c) | (b & d) | (c & d)
+                    return b ^ c ^ d
+                }
+
+                Sha1.prototype._update = function (M) {
+                    var W = this._w
+
+                    var a = this._a | 0
+                    var b = this._b | 0
+                    var c = this._c | 0
+                    var d = this._d | 0
+                    var e = this._e | 0
+
+                    for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
+                    for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])
+
+                    for (var j = 0; j < 80; ++j) {
+                        var s = ~~(j / 20)
+                        var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0
+
+                        e = d
+                        d = c
+                        c = rotl30(b)
+                        b = a
+                        a = t
+                    }
+
+                    this._a = (a + this._a) | 0
+                    this._b = (b + this._b) | 0
+                    this._c = (c + this._c) | 0
+                    this._d = (d + this._d) | 0
+                    this._e = (e + this._e) | 0
+                }
+
+                Sha1.prototype._hash = function () {
+                    var H = Buffer.allocUnsafe(20)
+
+                    H.writeInt32BE(this._a | 0, 0)
+                    H.writeInt32BE(this._b | 0, 4)
+                    H.writeInt32BE(this._c | 0, 8)
+                    H.writeInt32BE(this._d | 0, 12)
+                    H.writeInt32BE(this._e | 0, 16)
+
+                    return H
+                }
+
+                module.exports = Sha1
+
+            }, {
+                "./hash": 149,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            153: [function (require, module, exports) {
+                /**
+                * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+                * in FIPS 180-2
+                * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+                * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+                *
+                */
+
+                var inherits = require('inherits')
+                var Sha256 = require('./sha256')
+                var Hash = require('./hash')
+                var Buffer = require('safe-buffer').Buffer
+
+                var W = new Array(64)
+
+                function Sha224() {
+                    this.init()
+
+                    this._w = W // new Array(64)
+
+                    Hash.call(this, 64, 56)
+                }
+
+                inherits(Sha224, Sha256)
+
+                Sha224.prototype.init = function () {
+                    this._a = 0xc1059ed8
+                    this._b = 0x367cd507
+                    this._c = 0x3070dd17
+                    this._d = 0xf70e5939
+                    this._e = 0xffc00b31
+                    this._f = 0x68581511
+                    this._g = 0x64f98fa7
+                    this._h = 0xbefa4fa4
+
+                    return this
+                }
+
+                Sha224.prototype._hash = function () {
+                    var H = Buffer.allocUnsafe(28)
+
+                    H.writeInt32BE(this._a, 0)
+                    H.writeInt32BE(this._b, 4)
+                    H.writeInt32BE(this._c, 8)
+                    H.writeInt32BE(this._d, 12)
+                    H.writeInt32BE(this._e, 16)
+                    H.writeInt32BE(this._f, 20)
+                    H.writeInt32BE(this._g, 24)
+
+                    return H
+                }
+
+                module.exports = Sha224
+
+            }, {
+                "./hash": 149,
+                "./sha256": 154,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            154: [function (require, module, exports) {
+                /**
+                * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+                * in FIPS 180-2
+                * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+                * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+                *
+                */
+
+                var inherits = require('inherits')
+                var Hash = require('./hash')
+                var Buffer = require('safe-buffer').Buffer
+
+                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 W = new Array(64)
+
+                function Sha256() {
+                    this.init()
+
+                    this._w = W // new Array(64)
+
+                    Hash.call(this, 64, 56)
+                }
+
+                inherits(Sha256, Hash)
+
+                Sha256.prototype.init = function () {
+                    this._a = 0x6a09e667
+                    this._b = 0xbb67ae85
+                    this._c = 0x3c6ef372
+                    this._d = 0xa54ff53a
+                    this._e = 0x510e527f
+                    this._f = 0x9b05688c
+                    this._g = 0x1f83d9ab
+                    this._h = 0x5be0cd19
+
+                    return this
+                }
+
+                function ch(x, y, z) {
+                    return z ^ (x & (y ^ z))
+                }
+
+                function maj(x, y, z) {
+                    return (x & y) | (z & (x | y))
+                }
+
+                function sigma0(x) {
+                    return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)
+                }
+
+                function sigma1(x) {
+                    return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)
+                }
+
+                function gamma0(x) {
+                    return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)
+                }
+
+                function gamma1(x) {
+                    return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)
+                }
+
+                Sha256.prototype._update = function (M) {
+                    var W = this._w
+
+                    var a = this._a | 0
+                    var b = this._b | 0
+                    var c = this._c | 0
+                    var d = this._d | 0
+                    var e = this._e | 0
+                    var f = this._f | 0
+                    var g = this._g | 0
+                    var h = this._h | 0
+
+                    for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)
+                    for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i -
+                        16]) | 0
+
+                    for (var j = 0; j < 64; ++j) {
+                        var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0
+                        var T2 = (sigma0(a) + maj(a, b, c)) | 0
+
+                        h = g
+                        g = f
+                        f = e
+                        e = (d + T1) | 0
+                        d = c
+                        c = b
+                        b = a
+                        a = (T1 + T2) | 0
+                    }
+
+                    this._a = (a + this._a) | 0
+                    this._b = (b + this._b) | 0
+                    this._c = (c + this._c) | 0
+                    this._d = (d + this._d) | 0
+                    this._e = (e + this._e) | 0
+                    this._f = (f + this._f) | 0
+                    this._g = (g + this._g) | 0
+                    this._h = (h + this._h) | 0
+                }
+
+                Sha256.prototype._hash = function () {
+                    var H = Buffer.allocUnsafe(32)
+
+                    H.writeInt32BE(this._a, 0)
+                    H.writeInt32BE(this._b, 4)
+                    H.writeInt32BE(this._c, 8)
+                    H.writeInt32BE(this._d, 12)
+                    H.writeInt32BE(this._e, 16)
+                    H.writeInt32BE(this._f, 20)
+                    H.writeInt32BE(this._g, 24)
+                    H.writeInt32BE(this._h, 28)
+
+                    return H
+                }
+
+                module.exports = Sha256
+
+            }, {
+                "./hash": 149,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            155: [function (require, module, exports) {
+                var inherits = require('inherits')
+                var SHA512 = require('./sha512')
+                var Hash = require('./hash')
+                var Buffer = require('safe-buffer').Buffer
+
+                var W = new Array(160)
+
+                function Sha384() {
+                    this.init()
+                    this._w = W
+
+                    Hash.call(this, 128, 112)
+                }
+
+                inherits(Sha384, SHA512)
+
+                Sha384.prototype.init = function () {
+                    this._ah = 0xcbbb9d5d
+                    this._bh = 0x629a292a
+                    this._ch = 0x9159015a
+                    this._dh = 0x152fecd8
+                    this._eh = 0x67332667
+                    this._fh = 0x8eb44a87
+                    this._gh = 0xdb0c2e0d
+                    this._hh = 0x47b5481d
+
+                    this._al = 0xc1059ed8
+                    this._bl = 0x367cd507
+                    this._cl = 0x3070dd17
+                    this._dl = 0xf70e5939
+                    this._el = 0xffc00b31
+                    this._fl = 0x68581511
+                    this._gl = 0x64f98fa7
+                    this._hl = 0xbefa4fa4
+
+                    return this
+                }
+
+                Sha384.prototype._hash = function () {
+                    var H = Buffer.allocUnsafe(48)
+
+                    function writeInt64BE(h, l, offset) {
+                        H.writeInt32BE(h, offset)
+                        H.writeInt32BE(l, offset + 4)
+                    }
+
+                    writeInt64BE(this._ah, this._al, 0)
+                    writeInt64BE(this._bh, this._bl, 8)
+                    writeInt64BE(this._ch, this._cl, 16)
+                    writeInt64BE(this._dh, this._dl, 24)
+                    writeInt64BE(this._eh, this._el, 32)
+                    writeInt64BE(this._fh, this._fl, 40)
+
+                    return H
+                }
+
+                module.exports = Sha384
+
+            }, {
+                "./hash": 149,
+                "./sha512": 156,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            156: [function (require, module, exports) {
+                var inherits = require('inherits')
+                var Hash = require('./hash')
+                var Buffer = require('safe-buffer').Buffer
+
+                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
+                ]
+
+                var W = new Array(160)
+
+                function Sha512() {
+                    this.init()
+                    this._w = W
+
+                    Hash.call(this, 128, 112)
+                }
+
+                inherits(Sha512, Hash)
+
+                Sha512.prototype.init = function () {
+                    this._ah = 0x6a09e667
+                    this._bh = 0xbb67ae85
+                    this._ch = 0x3c6ef372
+                    this._dh = 0xa54ff53a
+                    this._eh = 0x510e527f
+                    this._fh = 0x9b05688c
+                    this._gh = 0x1f83d9ab
+                    this._hh = 0x5be0cd19
+
+                    this._al = 0xf3bcc908
+                    this._bl = 0x84caa73b
+                    this._cl = 0xfe94f82b
+                    this._dl = 0x5f1d36f1
+                    this._el = 0xade682d1
+                    this._fl = 0x2b3e6c1f
+                    this._gl = 0xfb41bd6b
+                    this._hl = 0x137e2179
+
+                    return this
+                }
+
+                function Ch(x, y, z) {
+                    return z ^ (x & (y ^ z))
+                }
+
+                function maj(x, y, z) {
+                    return (x & y) | (z & (x | y))
+                }
+
+                function sigma0(x, xl) {
+                    return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)
+                }
+
+                function sigma1(x, xl) {
+                    return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)
+                }
+
+                function Gamma0(x, xl) {
+                    return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)
+                }
+
+                function Gamma0l(x, xl) {
+                    return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)
+                }
+
+                function Gamma1(x, xl) {
+                    return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)
+                }
+
+                function Gamma1l(x, xl) {
+                    return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)
+                }
+
+                function getCarry(a, b) {
+                    return (a >>> 0) < (b >>> 0) ? 1 : 0
+                }
+
+                Sha512.prototype._update = function (M) {
+                    var W = this._w
+
+                    var ah = this._ah | 0
+                    var bh = this._bh | 0
+                    var ch = this._ch | 0
+                    var dh = this._dh | 0
+                    var eh = this._eh | 0
+                    var fh = this._fh | 0
+                    var gh = this._gh | 0
+                    var hh = this._hh | 0
+
+                    var al = this._al | 0
+                    var bl = this._bl | 0
+                    var cl = this._cl | 0
+                    var dl = this._dl | 0
+                    var el = this._el | 0
+                    var fl = this._fl | 0
+                    var gl = this._gl | 0
+                    var hl = this._hl | 0
+
+                    for (var i = 0; i < 32; i += 2) {
+                        W[i] = M.readInt32BE(i * 4)
+                        W[i + 1] = M.readInt32BE(i * 4 + 4)
+                    }
+                    for (; i < 160; i += 2) {
+                        var xh = W[i - 15 * 2]
+                        var xl = W[i - 15 * 2 + 1]
+                        var gamma0 = Gamma0(xh, xl)
+                        var gamma0l = Gamma0l(xl, xh)
+
+                        xh = W[i - 2 * 2]
+                        xl = W[i - 2 * 2 + 1]
+                        var gamma1 = Gamma1(xh, xl)
+                        var gamma1l = Gamma1l(xl, xh)
+
+                        // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
+                        var Wi7h = W[i - 7 * 2]
+                        var Wi7l = W[i - 7 * 2 + 1]
+
+                        var Wi16h = W[i - 16 * 2]
+                        var Wi16l = W[i - 16 * 2 + 1]
+
+                        var Wil = (gamma0l + Wi7l) | 0
+                        var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0
+                        Wil = (Wil + gamma1l) | 0
+                        Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0
+                        Wil = (Wil + Wi16l) | 0
+                        Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0
+
+                        W[i] = Wih
+                        W[i + 1] = Wil
+                    }
+
+                    for (var j = 0; j < 160; j += 2) {
+                        Wih = W[j]
+                        Wil = W[j + 1]
+
+                        var majh = maj(ah, bh, ch)
+                        var majl = maj(al, bl, cl)
+
+                        var sigma0h = sigma0(ah, al)
+                        var sigma0l = sigma0(al, ah)
+                        var sigma1h = sigma1(eh, el)
+                        var sigma1l = sigma1(el, eh)
+
+                        // t1 = h + sigma1 + ch + K[j] + W[j]
+                        var Kih = K[j]
+                        var Kil = K[j + 1]
+
+                        var chh = Ch(eh, fh, gh)
+                        var chl = Ch(el, fl, gl)
+
+                        var t1l = (hl + sigma1l) | 0
+                        var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0
+                        t1l = (t1l + chl) | 0
+                        t1h = (t1h + chh + getCarry(t1l, chl)) | 0
+                        t1l = (t1l + Kil) | 0
+                        t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0
+                        t1l = (t1l + Wil) | 0
+                        t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0
+
+                        // t2 = sigma0 + maj
+                        var t2l = (sigma0l + majl) | 0
+                        var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0
+
+                        hh = gh
+                        hl = gl
+                        gh = fh
+                        gl = fl
+                        fh = eh
+                        fl = el
+                        el = (dl + t1l) | 0
+                        eh = (dh + t1h + getCarry(el, dl)) | 0
+                        dh = ch
+                        dl = cl
+                        ch = bh
+                        cl = bl
+                        bh = ah
+                        bl = al
+                        al = (t1l + t2l) | 0
+                        ah = (t1h + t2h + getCarry(al, t1l)) | 0
+                    }
+
+                    this._al = (this._al + al) | 0
+                    this._bl = (this._bl + bl) | 0
+                    this._cl = (this._cl + cl) | 0
+                    this._dl = (this._dl + dl) | 0
+                    this._el = (this._el + el) | 0
+                    this._fl = (this._fl + fl) | 0
+                    this._gl = (this._gl + gl) | 0
+                    this._hl = (this._hl + hl) | 0
+
+                    this._ah = (this._ah + ah + getCarry(this._al, al)) | 0
+                    this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0
+                    this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0
+                    this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0
+                    this._eh = (this._eh + eh + getCarry(this._el, el)) | 0
+                    this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0
+                    this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0
+                    this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0
+                }
+
+                Sha512.prototype._hash = function () {
+                    var H = Buffer.allocUnsafe(64)
+
+                    function writeInt64BE(h, l, offset) {
+                        H.writeInt32BE(h, offset)
+                        H.writeInt32BE(l, offset + 4)
+                    }
+
+                    writeInt64BE(this._ah, this._al, 0)
+                    writeInt64BE(this._bh, this._bl, 8)
+                    writeInt64BE(this._ch, this._cl, 16)
+                    writeInt64BE(this._dh, this._dl, 24)
+                    writeInt64BE(this._eh, this._el, 32)
+                    writeInt64BE(this._fh, this._fl, 40)
+                    writeInt64BE(this._gh, this._gl, 48)
+                    writeInt64BE(this._hh, this._hl, 56)
+
+                    return H
+                }
+
+                module.exports = Sha512
+
+            }, {
+                "./hash": 149,
+                "inherits": 107,
+                "safe-buffer": 148
+            }],
+            157: [function (require, module, exports) {
+                // Copyright Joyent, Inc. and other Node contributors.
+                //
+                // Permission is hereby granted, free of charge, to any person obtaining a
+                // copy of this software and associated documentation files (the
+                // "Software"), to deal in the Software without restriction, including
+                // without limitation the rights to use, copy, modify, merge, publish,
+                // distribute, sublicense, and/or sell copies of the Software, and to permit
+                // persons to whom the Software is furnished to do so, subject to the
+                // following conditions:
+                //
+                // The above copyright notice and this permission notice shall be included
+                // in all copies or substantial portions of the Software.
+                //
+                // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                module.exports = Stream;
+
+                var EE = require('events').EventEmitter;
+                var inherits = require('inherits');
+
+                inherits(Stream, EE);
+                Stream.Readable = require('readable-stream/readable.js');
+                Stream.Writable = require('readable-stream/writable.js');
+                Stream.Duplex = require('readable-stream/duplex.js');
+                Stream.Transform = require('readable-stream/transform.js');
+                Stream.PassThrough = require('readable-stream/passthrough.js');
+
+                // Backwards-compat with node 0.4.x
+                Stream.Stream = Stream;
+
+
+
+                // old-style streams.  Note that the pipe method (the only relevant
+                // part of this class) is overridden in the Readable class.
+
+                function Stream() {
+                    EE.call(this);
+                }
+
+                Stream.prototype.pipe = function (dest, options) {
+                    var source = this;
+
+                    function ondata(chunk) {
+                        if (dest.writable) {
+                            if (false === dest.write(chunk) && source.pause) {
+                                source.pause();
+                            }
+                        }
+                    }
+
+                    source.on('data', ondata);
+
+                    function ondrain() {
+                        if (source.readable && source.resume) {
+                            source.resume();
+                        }
+                    }
+
+                    dest.on('drain', ondrain);
+
+                    // If the 'end' option is not supplied, dest.end() will be called when
+                    // source gets the 'end' or 'close' events.  Only dest.end() once.
+                    if (!dest._isStdio && (!options || options.end !== false)) {
+                        source.on('end', onend);
+                        source.on('close', onclose);
+                    }
+
+                    var didOnEnd = false;
+
+                    function onend() {
+                        if (didOnEnd) return;
+                        didOnEnd = true;
+
+                        dest.end();
+                    }
+
+
+                    function onclose() {
+                        if (didOnEnd) return;
+                        didOnEnd = true;
+
+                        if (typeof dest.destroy === 'function') dest.destroy();
+                    }
+
+                    // don't leave dangling pipes when there are errors.
+                    function onerror(er) {
+                        cleanup();
+                        if (EE.listenerCount(this, 'error') === 0) {
+                            throw er; // Unhandled stream error in pipe.
+                        }
+                    }
+
+                    source.on('error', onerror);
+                    dest.on('error', onerror);
+
+                    // remove all the event listeners that were added.
+                    function cleanup() {
+                        source.removeListener('data', ondata);
+                        dest.removeListener('drain', ondrain);
+
+                        source.removeListener('end', onend);
+                        source.removeListener('close', onclose);
+
+                        source.removeListener('error', onerror);
+                        dest.removeListener('error', onerror);
+
+                        source.removeListener('end', cleanup);
+                        source.removeListener('close', cleanup);
+
+                        dest.removeListener('close', cleanup);
+                    }
+
+                    source.on('end', cleanup);
+                    source.on('close', cleanup);
+
+                    dest.on('close', cleanup);
+
+                    dest.emit('pipe', source);
+
+                    // Allow for unix-like usage: A.pipe(B).pipe(C)
+                    return dest;
+                };
+
+            }, {
+                "events": 90,
+                "inherits": 107,
+                "readable-stream/duplex.js": 134,
+                "readable-stream/passthrough.js": 143,
+                "readable-stream/readable.js": 144,
+                "readable-stream/transform.js": 145,
+                "readable-stream/writable.js": 146
+            }],
+            158: [function (require, module, exports) {
+                // Copyright Joyent, Inc. and other Node contributors.
+                //
+                // Permission is hereby granted, free of charge, to any person obtaining a
+                // copy of this software and associated documentation files (the
+                // "Software"), to deal in the Software without restriction, including
+                // without limitation the rights to use, copy, modify, merge, publish,
+                // distribute, sublicense, and/or sell copies of the Software, and to permit
+                // persons to whom the Software is furnished to do so, subject to the
+                // following conditions:
+                //
+                // The above copyright notice and this permission notice shall be included
+                // in all copies or substantial portions of the Software.
+                //
+                // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                'use strict';
+
+                /*<replacement>*/
+
+                var Buffer = require('safe-buffer').Buffer;
+                /*</replacement>*/
+
+                var isEncoding = Buffer.isEncoding || function (encoding) {
+                    encoding = '' + encoding;
+                    switch (encoding && encoding.toLowerCase()) {
+                        case 'hex':
+                        case 'utf8':
+                        case 'utf-8':
+                        case 'ascii':
+                        case 'binary':
+                        case 'base64':
+                        case 'ucs2':
+                        case 'ucs-2':
+                        case 'utf16le':
+                        case 'utf-16le':
+                        case 'raw':
+                            return true;
+                        default:
+                            return false;
+                    }
+                };
+
+                function _normalizeEncoding(enc) {
+                    if (!enc) return 'utf8';
+                    var retried;
+                    while (true) {
+                        switch (enc) {
+                            case 'utf8':
+                            case 'utf-8':
+                                return 'utf8';
+                            case 'ucs2':
+                            case 'ucs-2':
+                            case 'utf16le':
+                            case 'utf-16le':
+                                return 'utf16le';
+                            case 'latin1':
+                            case 'binary':
+                                return 'latin1';
+                            case 'base64':
+                            case 'ascii':
+                            case 'hex':
+                                return enc;
+                            default:
+                                if (retried) return; // undefined
+                                enc = ('' + enc).toLowerCase();
+                                retried = true;
+                        }
+                    }
+                };
+
+                // Do not cache `Buffer.isEncoding` when checking encoding names as some
+                // modules monkey-patch it to support additional encodings
+                function normalizeEncoding(enc) {
+                    var nenc = _normalizeEncoding(enc);
+                    if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc)))
+                        throw new Error('Unknown encoding: ' + enc);
+                    return nenc || enc;
+                }
+
+                // StringDecoder provides an interface for efficiently splitting a series of
+                // buffers into a series of JS strings without breaking apart multi-byte
+                // characters.
+                exports.StringDecoder = StringDecoder;
+
+                function StringDecoder(encoding) {
+                    this.encoding = normalizeEncoding(encoding);
+                    var nb;
+                    switch (this.encoding) {
+                        case 'utf16le':
+                            this.text = utf16Text;
+                            this.end = utf16End;
+                            nb = 4;
+                            break;
+                        case 'utf8':
+                            this.fillLast = utf8FillLast;
+                            nb = 4;
+                            break;
+                        case 'base64':
+                            this.text = base64Text;
+                            this.end = base64End;
+                            nb = 3;
+                            break;
+                        default:
+                            this.write = simpleWrite;
+                            this.end = simpleEnd;
+                            return;
+                    }
+                    this.lastNeed = 0;
+                    this.lastTotal = 0;
+                    this.lastChar = Buffer.allocUnsafe(nb);
+                }
+
+                StringDecoder.prototype.write = function (buf) {
+                    if (buf.length === 0) return '';
+                    var r;
+                    var i;
+                    if (this.lastNeed) {
+                        r = this.fillLast(buf);
+                        if (r === undefined) return '';
+                        i = this.lastNeed;
+                        this.lastNeed = 0;
+                    } else {
+                        i = 0;
+                    }
+                    if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+                    return r || '';
+                };
+
+                StringDecoder.prototype.end = utf8End;
+
+                // Returns only complete characters in a Buffer
+                StringDecoder.prototype.text = utf8Text;
+
+                // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+                StringDecoder.prototype.fillLast = function (buf) {
+                    if (this.lastNeed <= buf.length) {
+                        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+                        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+                    }
+                    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+                    this.lastNeed -= buf.length;
+                };
+
+                // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+                // continuation byte. If an invalid byte is detected, -2 is returned.
+                function utf8CheckByte(byte) {
+                    if (byte <= 0x7F) return 0;
+                    else if (byte >> 5 === 0x06) return 2;
+                    else if (byte >> 4 === 0x0E) return 3;
+                    else if (byte >> 3 === 0x1E) return 4;
+                    return byte >> 6 === 0x02 ? -1 : -2;
+                }
+
+                // Checks at most 3 bytes at the end of a Buffer in order to detect an
+                // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+                // needed to complete the UTF-8 character (if applicable) are returned.
+                function utf8CheckIncomplete(self, buf, i) {
+                    var j = buf.length - 1;
+                    if (j < i) return 0;
+                    var nb = utf8CheckByte(buf[j]);
+                    if (nb >= 0) {
+                        if (nb > 0) self.lastNeed = nb - 1;
+                        return nb;
+                    }
+                    if (--j < i || nb === -2) return 0;
+                    nb = utf8CheckByte(buf[j]);
+                    if (nb >= 0) {
+                        if (nb > 0) self.lastNeed = nb - 2;
+                        return nb;
+                    }
+                    if (--j < i || nb === -2) return 0;
+                    nb = utf8CheckByte(buf[j]);
+                    if (nb >= 0) {
+                        if (nb > 0) {
+                            if (nb === 2) nb = 0;
+                            else self.lastNeed = nb - 3;
+                        }
+                        return nb;
+                    }
+                    return 0;
+                }
+
+                // Validates as many continuation bytes for a multi-byte UTF-8 character as
+                // needed or are available. If we see a non-continuation byte where we expect
+                // one, we "replace" the validated continuation bytes we've seen so far with
+                // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+                // behavior. The continuation byte check is included three times in the case
+                // where all of the continuation bytes for a character exist in the same buffer.
+                // It is also done this way as a slight performance increase instead of using a
+                // loop.
+                function utf8CheckExtraBytes(self, buf, p) {
+                    if ((buf[0] & 0xC0) !== 0x80) {
+                        self.lastNeed = 0;
+                        return '\ufffd';
+                    }
+                    if (self.lastNeed > 1 && buf.length > 1) {
+                        if ((buf[1] & 0xC0) !== 0x80) {
+                            self.lastNeed = 1;
+                            return '\ufffd';
+                        }
+                        if (self.lastNeed > 2 && buf.length > 2) {
+                            if ((buf[2] & 0xC0) !== 0x80) {
+                                self.lastNeed = 2;
+                                return '\ufffd';
+                            }
+                        }
+                    }
+                }
+
+                // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+                function utf8FillLast(buf) {
+                    var p = this.lastTotal - this.lastNeed;
+                    var r = utf8CheckExtraBytes(this, buf, p);
+                    if (r !== undefined) return r;
+                    if (this.lastNeed <= buf.length) {
+                        buf.copy(this.lastChar, p, 0, this.lastNeed);
+                        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+                    }
+                    buf.copy(this.lastChar, p, 0, buf.length);
+                    this.lastNeed -= buf.length;
+                }
+
+                // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+                // partial character, the character's bytes are buffered until the required
+                // number of bytes are available.
+                function utf8Text(buf, i) {
+                    var total = utf8CheckIncomplete(this, buf, i);
+                    if (!this.lastNeed) return buf.toString('utf8', i);
+                    this.lastTotal = total;
+                    var end = buf.length - (total - this.lastNeed);
+                    buf.copy(this.lastChar, 0, end);
+                    return buf.toString('utf8', i, end);
+                }
+
+                // For UTF-8, a replacement character is added when ending on a partial
+                // character.
+                function utf8End(buf) {
+                    var r = buf && buf.length ? this.write(buf) : '';
+                    if (this.lastNeed) return r + '\ufffd';
+                    return r;
+                }
+
+                // UTF-16LE typically needs two bytes per character, but even if we have an even
+                // number of bytes available, we need to check if we end on a leading/high
+                // surrogate. In that case, we need to wait for the next two bytes in order to
+                // decode the last character properly.
+                function utf16Text(buf, i) {
+                    if ((buf.length - i) % 2 === 0) {
+                        var r = buf.toString('utf16le', i);
+                        if (r) {
+                            var c = r.charCodeAt(r.length - 1);
+                            if (c >= 0xD800 && c <= 0xDBFF) {
+                                this.lastNeed = 2;
+                                this.lastTotal = 4;
+                                this.lastChar[0] = buf[buf.length - 2];
+                                this.lastChar[1] = buf[buf.length - 1];
+                                return r.slice(0, -1);
+                            }
+                        }
+                        return r;
+                    }
+                    this.lastNeed = 1;
+                    this.lastTotal = 2;
+                    this.lastChar[0] = buf[buf.length - 1];
+                    return buf.toString('utf16le', i, buf.length - 1);
+                }
+
+                // For UTF-16LE we do not explicitly append special replacement characters if we
+                // end on a partial character, we simply let v8 handle that.
+                function utf16End(buf) {
+                    var r = buf && buf.length ? this.write(buf) : '';
+                    if (this.lastNeed) {
+                        var end = this.lastTotal - this.lastNeed;
+                        return r + this.lastChar.toString('utf16le', 0, end);
+                    }
+                    return r;
+                }
+
+                function base64Text(buf, i) {
+                    var n = (buf.length - i) % 3;
+                    if (n === 0) return buf.toString('base64', i);
+                    this.lastNeed = 3 - n;
+                    this.lastTotal = 3;
+                    if (n === 1) {
+                        this.lastChar[0] = buf[buf.length - 1];
+                    } else {
+                        this.lastChar[0] = buf[buf.length - 2];
+                        this.lastChar[1] = buf[buf.length - 1];
+                    }
+                    return buf.toString('base64', i, buf.length - n);
+                }
+
+                function base64End(buf) {
+                    var r = buf && buf.length ? this.write(buf) : '';
+                    if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
+                    return r;
+                }
+
+                // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
+                function simpleWrite(buf) {
+                    return buf.toString(this.encoding);
+                }
+
+                function simpleEnd(buf) {
+                    return buf && buf.length ? this.write(buf) : '';
+                }
+            }, {
+                "safe-buffer": 148
+            }],
+            159: [function (require, module, exports) {
+                (function (setImmediate, clearImmediate) {
+                    var nextTick = require('process/browser.js').nextTick;
+                    var apply = Function.prototype.apply;
+                    var slice = Array.prototype.slice;
+                    var immediateIds = {};
+                    var nextImmediateId = 0;
+
+                    // DOM APIs, for completeness
+
+                    exports.setTimeout = function () {
+                        return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
+                    };
+                    exports.setInterval = function () {
+                        return new Timeout(apply.call(setInterval, window, arguments),
+                            clearInterval);
+                    };
+                    exports.clearTimeout =
+                        exports.clearInterval = function (timeout) {
+                            timeout.close();
+                        };
+
+                    function Timeout(id, clearFn) {
+                        this._id = id;
+                        this._clearFn = clearFn;
+                    }
+                    Timeout.prototype.unref = Timeout.prototype.ref = function () {};
+                    Timeout.prototype.close = function () {
+                        this._clearFn.call(window, this._id);
+                    };
+
+                    // Does not start the time, just sets up the members needed.
+                    exports.enroll = function (item, msecs) {
+                        clearTimeout(item._idleTimeoutId);
+                        item._idleTimeout = msecs;
+                    };
+
+                    exports.unenroll = function (item) {
+                        clearTimeout(item._idleTimeoutId);
+                        item._idleTimeout = -1;
+                    };
+
+                    exports._unrefActive = exports.active = function (item) {
+                        clearTimeout(item._idleTimeoutId);
+
+                        var msecs = item._idleTimeout;
+                        if (msecs >= 0) {
+                            item._idleTimeoutId = setTimeout(function onTimeout() {
+                                if (item._onTimeout)
+                                    item._onTimeout();
+                            }, msecs);
+                        }
+                    };
+
+                    // That's not how node.js implements it but the exposed api is the same.
+                    exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function (
+                        fn) {
+                        var id = nextImmediateId++;
+                        var args = arguments.length < 2 ? false : slice.call(arguments, 1);
+
+                        immediateIds[id] = true;
+
+                        nextTick(function onNextTick() {
+                            if (immediateIds[id]) {
+                                // fn.call() is faster so we optimize for the common use-case
+                                // @see http://jsperf.com/call-apply-segu
+                                if (args) {
+                                    fn.apply(null, args);
+                                } else {
+                                    fn.call(null);
+                                }
+                                // Prevent ids from leaking
+                                exports.clearImmediate(id);
+                            }
+                        });
+
+                        return id;
+                    };
+
+                    exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate :
+                        function (id) {
+                            delete immediateIds[id];
+                        };
+                }).call(this, require("timers").setImmediate, require("timers").clearImmediate)
+            }, {
+                "process/browser.js": 125,
+                "timers": 159
+            }],
+            160: [function (require, module, exports) {
+                (function (global) {
+
+                    /**
+                    * Module exports.
+                    */
+
+                    module.exports = deprecate;
+
+                    /**
+                    * Mark that a method should not be used.
+                    * Returns a modified function which warns once by default.
+                    *
+                    * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+                    *
+                    * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+                    * will throw an Error when invoked.
+                    *
+                    * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+                    * will invoke `console.trace()` instead of `console.error()`.
+                    *
+                    * @param {Function} fn - the function to deprecate
+                    * @param {String} msg - the string to print to the console when `fn` is invoked
+                    * @returns {Function} a new "deprecated" version of `fn`
+                    * @api public
+                    */
+
+                    function deprecate(fn, msg) {
+                        if (config('noDeprecation')) {
+                            return fn;
+                        }
+
+                        var warned = false;
+
+                        function deprecated() {
+                            if (!warned) {
+                                if (config('throwDeprecation')) {
+                                    throw new Error(msg);
+                                } else if (config('traceDeprecation')) {
+                                    console.trace(msg);
+                                } else {
+                                    console.warn(msg);
+                                }
+                                warned = true;
+                            }
+                            return fn.apply(this, arguments);
+                        }
+
+                        return deprecated;
+                    }
+
+                    /**
+                    * Checks `localStorage` for boolean values for the given `name`.
+                    *
+                    * @param {String} name
+                    * @returns {Boolean}
+                    * @api private
+                    */
+
+                    function config(name) {
+                        // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+                        try {
+                            if (!global.localStorage) return false;
+                        } catch (_) {
+                            return false;
+                        }
+                        var val = global.localStorage[name];
+                        if (null == val) return false;
+                        return String(val).toLowerCase() === 'true';
+                    }
+
+                }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self :
+                    typeof window !== "undefined" ? window : {})
+            }, {}],
+            161: [function (require, module, exports) {
+                module.exports = function isBuffer(arg) {
+                    return arg && typeof arg === 'object' &&
+                        typeof arg.copy === 'function' &&
+                        typeof arg.fill === 'function' &&
+                        typeof arg.readUInt8 === 'function';
+                }
+            }, {}],
+            162: [function (require, module, exports) {
+                (function (process, global) {
+                    // Copyright Joyent, Inc. and other Node contributors.
+                    //
+                    // Permission is hereby granted, free of charge, to any person obtaining a
+                    // copy of this software and associated documentation files (the
+                    // "Software"), to deal in the Software without restriction, including
+                    // without limitation the rights to use, copy, modify, merge, publish,
+                    // distribute, sublicense, and/or sell copies of the Software, and to permit
+                    // persons to whom the Software is furnished to do so, subject to the
+                    // following conditions:
+                    //
+                    // The above copyright notice and this permission notice shall be included
+                    // in all copies or substantial portions of the Software.
+                    //
+                    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+                    // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+                    // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+                    // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+                    // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+                    // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+                    // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+                    var formatRegExp = /%[sdj%]/g;
+                    exports.format = function (f) {
+                        if (!isString(f)) {
+                            var objects = [];
+                            for (var i = 0; i < arguments.length; i++) {
+                                objects.push(inspect(arguments[i]));
+                            }
+                            return objects.join(' ');
+                        }
+
+                        var i = 1;
+                        var args = arguments;
+                        var len = args.length;
+                        var str = String(f).replace(formatRegExp, function (x) {
+                            if (x === '%%') return '%';
+                            if (i >= len) return x;
+                            switch (x) {
+                                case '%s':
+                                    return String(args[i++]);
+                                case '%d':
+                                    return Number(args[i++]);
+                                case '%j':
+                                    try {
+                                        return JSON.stringify(args[i++]);
+                                    } catch (_) {
+                                        return '[Circular]';
+                                    }
+                                default:
+                                    return x;
+                            }
+                        });
+                        for (var x = args[i]; i < len; x = args[++i]) {
+                            if (isNull(x) || !isObject(x)) {
+                                str += ' ' + x;
+                            } else {
+                                str += ' ' + inspect(x);
+                            }
+                        }
+                        return str;
+                    };
+
+
+                    // Mark that a method should not be used.
+                    // Returns a modified function which warns once by default.
+                    // If --no-deprecation is set, then it is a no-op.
+                    exports.deprecate = function (fn, msg) {
+                        // Allow for deprecating things in the process of starting up.
+                        if (isUndefined(global.process)) {
+                            return function () {
+                                return exports.deprecate(fn, msg).apply(this, arguments);
+                            };
+                        }
+
+                        if (process.noDeprecation === true) {
+                            return fn;
+                        }
+
+                        var warned = false;
+
+                        function deprecated() {
+                            if (!warned) {
+                                if (process.throwDeprecation) {
+                                    throw new Error(msg);
+                                } else if (process.traceDeprecation) {
+                                    console.trace(msg);
+                                } else {
+                                    console.error(msg);
+                                }
+                                warned = true;
+                            }
+                            return fn.apply(this, arguments);
+                        }
+
+                        return deprecated;
+                    };
+
+
+                    var debugs = {};
+                    var debugEnviron;
+                    exports.debuglog = function (set) {
+                        if (isUndefined(debugEnviron))
+                            debugEnviron = process.env.NODE_DEBUG || '';
+                        set = set.toUpperCase();
+                        if (!debugs[set]) {
+                            if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+                                var pid = process.pid;
+                                debugs[set] = function () {
+                                    var msg = exports.format.apply(exports, arguments);
+                                    console.error('%s %d: %s', set, pid, msg);
+                                };
+                            } else {
+                                debugs[set] = function () {};
+                            }
+                        }
+                        return debugs[set];
+                    };
+
+
+                    /**
+                    * Echos the value of a value. Trys to print the value out
+                    * in the best way possible given the different types.
+                    *
+                    * @param {Object} obj The object to print out.
+                    * @param {Object} opts Optional options object that alters the output.
+                    */
+                    /* legacy: obj, showHidden, depth, colors*/
+                    function inspect(obj, opts) {
+                        // default options
+                        var ctx = {
+                            seen: [],
+                            stylize: stylizeNoColor
+                        };
+                        // legacy...
+                        if (arguments.length >= 3) ctx.depth = arguments[2];
+                        if (arguments.length >= 4) ctx.colors = arguments[3];
+                        if (isBoolean(opts)) {
+                            // legacy...
+                            ctx.showHidden = opts;
+                        } else if (opts) {
+                            // got an "options" object
+                            exports._extend(ctx, opts);
+                        }
+                        // set default options
+                        if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+                        if (isUndefined(ctx.depth)) ctx.depth = 2;
+                        if (isUndefined(ctx.colors)) ctx.colors = false;
+                        if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+                        if (ctx.colors) ctx.stylize = stylizeWithColor;
+                        return formatValue(ctx, obj, ctx.depth);
+                    }
+                    exports.inspect = inspect;
+
+
+                    // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+                    inspect.colors = {
+                        'bold': [1, 22],
+                        'italic': [3, 23],
+                        'underline': [4, 24],
+                        'inverse': [7, 27],
+                        'white': [37, 39],
+                        'grey': [90, 39],
+                        'black': [30, 39],
+                        'blue': [34, 39],
+                        'cyan': [36, 39],
+                        'green': [32, 39],
+                        'magenta': [35, 39],
+                        'red': [31, 39],
+                        'yellow': [33, 39]
+                    };
+
+                    // Don't use 'blue' not visible on cmd.exe
+                    inspect.styles = {
+                        'special': 'cyan',
+                        'number': 'yellow',
+                        'boolean': 'yellow',
+                        'undefined': 'grey',
+                        'null': 'bold',
+                        'string': 'green',
+                        'date': 'magenta',
+                        // "name": intentionally not styling
+                        'regexp': 'red'
+                    };
+
+
+                    function stylizeWithColor(str, styleType) {
+                        var style = inspect.styles[styleType];
+
+                        if (style) {
+                            return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+                                '\u001b[' + inspect.colors[style][1] + 'm';
+                        } else {
+                            return str;
+                        }
+                    }
+
+
+                    function stylizeNoColor(str, styleType) {
+                        return str;
+                    }
+
+
+                    function arrayToHash(array) {
+                        var hash = {};
+
+                        array.forEach(function (val, idx) {
+                            hash[val] = true;
+                        });
+
+                        return hash;
+                    }
+
+
+                    function formatValue(ctx, value, recurseTimes) {
+                        // Provide a hook for user-specified inspect functions.
+                        // Check that value is an object with an inspect function on it
+                        if (ctx.customInspect &&
+                            value &&
+                            isFunction(value.inspect) &&
+                            // Filter out the util module, it's inspect function is special
+                            value.inspect !== exports.inspect &&
+                            // Also filter out any prototype objects using the circular check.
+                            !(value.constructor && value.constructor.prototype === value)) {
+                            var ret = value.inspect(recurseTimes, ctx);
+                            if (!isString(ret)) {
+                                ret = formatValue(ctx, ret, recurseTimes);
+                            }
+                            return ret;
+                        }
+
+                        // Primitive types cannot have properties
+                        var primitive = formatPrimitive(ctx, value);
+                        if (primitive) {
+                            return primitive;
+                        }
+
+                        // Look up the keys of the object.
+                        var keys = Object.keys(value);
+                        var visibleKeys = arrayToHash(keys);
+
+                        if (ctx.showHidden) {
+                            keys = Object.getOwnPropertyNames(value);
+                        }
+
+                        // IE doesn't make error fields non-enumerable
+                        // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+                        if (isError(value) &&
+                            (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+                            return formatError(value);
+                        }
+
+                        // Some type of object without properties can be shortcutted.
+                        if (keys.length === 0) {
+                            if (isFunction(value)) {
+                                var name = value.name ? ': ' + value.name : '';
+                                return ctx.stylize('[Function' + name + ']', 'special');
+                            }
+                            if (isRegExp(value)) {
+                                return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+                            }
+                            if (isDate(value)) {
+                                return ctx.stylize(Date.prototype.toString.call(value), 'date');
+                            }
+                            if (isError(value)) {
+                                return formatError(value);
+                            }
+                        }
+
+                        var base = '',
+                            array = false,
+                            braces = ['{', '}'];
+
+                        // Make Array say that they are Array
+                        if (isArray(value)) {
+                            array = true;
+                            braces = ['[', ']'];
+                        }
+
+                        // Make functions say that they are functions
+                        if (isFunction(value)) {
+                            var n = value.name ? ': ' + value.name : '';
+                            base = ' [Function' + n + ']';
+                        }
+
+                        // Make RegExps say that they are RegExps
+                        if (isRegExp(value)) {
+                            base = ' ' + RegExp.prototype.toString.call(value);
+                        }
+
+                        // Make dates with properties first say the date
+                        if (isDate(value)) {
+                            base = ' ' + Date.prototype.toUTCString.call(value);
+                        }
+
+                        // Make error with message first say the error
+                        if (isError(value)) {
+                            base = ' ' + formatError(value);
+                        }
+
+                        if (keys.length === 0 && (!array || value.length == 0)) {
+                            return braces[0] + base + braces[1];
+                        }
+
+                        if (recurseTimes < 0) {
+                            if (isRegExp(value)) {
+                                return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+                            } else {
+                                return ctx.stylize('[Object]', 'special');
+                            }
+                        }
+
+                        ctx.seen.push(value);
+
+                        var output;
+                        if (array) {
+                            output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+                        } else {
+                            output = keys.map(function (key) {
+                                return formatProperty(ctx, value, recurseTimes, visibleKeys,
+                                    key, array);
+                            });
+                        }
+
+                        ctx.seen.pop();
+
+                        return reduceToSingleString(output, base, braces);
+                    }
+
+
+                    function formatPrimitive(ctx, value) {
+                        if (isUndefined(value))
+                            return ctx.stylize('undefined', 'undefined');
+                        if (isString(value)) {
+                            var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                .replace(/'/g, "\\'")
+                                .replace(/\\"/g, '"') + '\'';
+                            return ctx.stylize(simple, 'string');
+                        }
+                        if (isNumber(value))
+                            return ctx.stylize('' + value, 'number');
+                        if (isBoolean(value))
+                            return ctx.stylize('' + value, 'boolean');
+                        // For some reason typeof null is "object", so special case here.
+                        if (isNull(value))
+                            return ctx.stylize('null', 'null');
+                    }
+
+
+                    function formatError(value) {
+                        return '[' + Error.prototype.toString.call(value) + ']';
+                    }
+
+
+                    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+                        var output = [];
+                        for (var i = 0, l = value.length; i < l; ++i) {
+                            if (hasOwnProperty(value, String(i))) {
+                                output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                                    String(i), true));
+                            } else {
+                                output.push('');
+                            }
+                        }
+                        keys.forEach(function (key) {
+                            if (!key.match(/^\d+$/)) {
+                                output.push(formatProperty(ctx, value, recurseTimes,
+                                    visibleKeys,
+                                    key, true));
+                            }
+                        });
+                        return output;
+                    }
+
+
+                    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+                        var name, str, desc;
+                        desc = Object.getOwnPropertyDescriptor(value, key) || {
+                            value: value[key]
+                        };
+                        if (desc.get) {
+                            if (desc.set) {
+                                str = ctx.stylize('[Getter/Setter]', 'special');
+                            } else {
+                                str = ctx.stylize('[Getter]', 'special');
+                            }
+                        } else {
+                            if (desc.set) {
+                                str = ctx.stylize('[Setter]', 'special');
+                            }
+                        }
+                        if (!hasOwnProperty(visibleKeys, key)) {
+                            name = '[' + key + ']';
+                        }
+                        if (!str) {
+                            if (ctx.seen.indexOf(desc.value) < 0) {
+                                if (isNull(recurseTimes)) {
+                                    str = formatValue(ctx, desc.value, null);
+                                } else {
+                                    str = formatValue(ctx, desc.value, recurseTimes - 1);
+                                }
+                                if (str.indexOf('\n') > -1) {
+                                    if (array) {
+                                        str = str.split('\n').map(function (line) {
+                                            return '  ' + line;
+                                        }).join('\n').substr(2);
+                                    } else {
+                                        str = '\n' + str.split('\n').map(function (line) {
+                                            return '   ' + line;
+                                        }).join('\n');
+                                    }
+                                }
+                            } else {
+                                str = ctx.stylize('[Circular]', 'special');
+                            }
+                        }
+                        if (isUndefined(name)) {
+                            if (array && key.match(/^\d+$/)) {
+                                return str;
+                            }
+                            name = JSON.stringify('' + key);
+                            if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+                                name = name.substr(1, name.length - 2);
+                                name = ctx.stylize(name, 'name');
+                            } else {
+                                name = name.replace(/'/g, "\\'")
+                                    .replace(/\\"/g, '"')
+                                    .replace(/(^"|"$)/g, "'");
+                                name = ctx.stylize(name, 'string');
+                            }
+                        }
+
+                        return name + ': ' + str;
+                    }
+
+
+                    function reduceToSingleString(output, base, braces) {
+                        var numLinesEst = 0;
+                        var length = output.reduce(function (prev, cur) {
+                            numLinesEst++;
+                            if (cur.indexOf('\n') >= 0) numLinesEst++;
+                            return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+                        }, 0);
+
+                        if (length > 60) {
+                            return braces[0] +
+                                (base === '' ? '' : base + '\n ') +
+                                ' ' +
+                                output.join(',\n  ') +
+                                ' ' +
+                                braces[1];
+                        }
+
+                        return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+                    }
+
+
+                    // NOTE: These type checking functions intentionally don't use `instanceof`
+                    // because it is fragile and can be easily faked with `Object.create()`.
+                    function isArray(ar) {
+                        return Array.isArray(ar);
+                    }
+                    exports.isArray = isArray;
+
+                    function isBoolean(arg) {
+                        return typeof arg === 'boolean';
+                    }
+                    exports.isBoolean = isBoolean;
+
+                    function isNull(arg) {
+                        return arg === null;
+                    }
+                    exports.isNull = isNull;
+
+                    function isNullOrUndefined(arg) {
+                        return arg == null;
+                    }
+                    exports.isNullOrUndefined = isNullOrUndefined;
+
+                    function isNumber(arg) {
+                        return typeof arg === 'number';
+                    }
+                    exports.isNumber = isNumber;
+
+                    function isString(arg) {
+                        return typeof arg === 'string';
+                    }
+                    exports.isString = isString;
+
+                    function isSymbol(arg) {
+                        return typeof arg === 'symbol';
+                    }
+                    exports.isSymbol = isSymbol;
+
+                    function isUndefined(arg) {
+                        return arg === void 0;
+                    }
+                    exports.isUndefined = isUndefined;
+
+                    function isRegExp(re) {
+                        return isObject(re) && objectToString(re) === '[object RegExp]';
+                    }
+                    exports.isRegExp = isRegExp;
+
+                    function isObject(arg) {
+                        return typeof arg === 'object' && arg !== null;
+                    }
+                    exports.isObject = isObject;
+
+                    function isDate(d) {
+                        return isObject(d) && objectToString(d) === '[object Date]';
+                    }
+                    exports.isDate = isDate;
+
+                    function isError(e) {
+                        return isObject(e) &&
+                            (objectToString(e) === '[object Error]' || e instanceof Error);
+                    }
+                    exports.isError = isError;
+
+                    function isFunction(arg) {
+                        return typeof arg === 'function';
+                    }
+                    exports.isFunction = isFunction;
+
+                    function isPrimitive(arg) {
+                        return arg === null ||
+                            typeof arg === 'boolean' ||
+                            typeof arg === 'number' ||
+                            typeof arg === 'string' ||
+                            typeof arg === 'symbol' || // ES6 symbol
+                            typeof arg === 'undefined';
+                    }
+                    exports.isPrimitive = isPrimitive;
+
+                    exports.isBuffer = require('./support/isBuffer');
+
+                    function objectToString(o) {
+                        return Object.prototype.toString.call(o);
+                    }
+
+
+                    function pad(n) {
+                        return n < 10 ? '0' + n.toString(10) : n.toString(10);
+                    }
+
+
+                    var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+                        'Oct', 'Nov', 'Dec'
+                    ];
+
+                    // 26 Feb 16:19:34
+                    function timestamp() {
+                        var d = new Date();
+                        var time = [pad(d.getHours()),
+                            pad(d.getMinutes()),
+                            pad(d.getSeconds())
+                        ].join(':');
+                        return [d.getDate(), months[d.getMonth()], time].join(' ');
+                    }
+
+
+                    // log is just a thin wrapper to console.log that prepends a timestamp
+                    exports.log = function () {
+                        console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+                    };
+
+
+                    /**
+                    * Inherit the prototype methods from one constructor into another.
+                    *
+                    * The Function.prototype.inherits from lang.js rewritten as a standalone
+                    * function (not on Function.prototype). NOTE: If this file is to be loaded
+                    * during bootstrapping this function needs to be rewritten using some native
+                    * functions as prototype setup using normal JavaScript does not work as
+                    * expected during bootstrapping (see mirror.js in r114903).
+                    *
+                    * @param {function} ctor Constructor function which needs to inherit the
+                    *     prototype.
+                    * @param {function} superCtor Constructor function to inherit prototype from.
+                    */
+                    exports.inherits = require('inherits');
+
+                    exports._extend = function (origin, add) {
+                        // Don't do anything if add isn't an object
+                        if (!add || !isObject(add)) return origin;
+
+                        var keys = Object.keys(add);
+                        var i = keys.length;
+                        while (i--) {
+                            origin[keys[i]] = add[keys[i]];
+                        }
+                        return origin;
+                    };
+
+                    function hasOwnProperty(obj, prop) {
+                        return Object.prototype.hasOwnProperty.call(obj, prop);
+                    }
+
+                }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !==
+                    "undefined" ? self : typeof window !== "undefined" ? window : {})
+            }, {
+                "./support/isBuffer": 161,
+                "_process": 125,
+                "inherits": 107
+            }],
+            163: [function (require, module, exports) {
+                var indexOf = function (xs, item) {
+                    if (xs.indexOf) return xs.indexOf(item);
+                    else
+                        for (var i = 0; i < xs.length; i++) {
+                            if (xs[i] === item) return i;
+                        }
+                    return -1;
+                };
+                var Object_keys = function (obj) {
+                    if (Object.keys) return Object.keys(obj)
+                    else {
+                        var res = [];
+                        for (var key in obj) res.push(key)
+                        return res;
+                    }
+                };
+
+                var forEach = function (xs, fn) {
+                    if (xs.forEach) return xs.forEach(fn)
+                    else
+                        for (var i = 0; i < xs.length; i++) {
+                            fn(xs[i], i, xs);
+                        }
+                };
+
+                var defineProp = (function () {
+                    try {
+                        Object.defineProperty({}, '_', {});
+                        return function (obj, name, value) {
+                            Object.defineProperty(obj, name, {
+                                writable: true,
+                                enumerable: false,
+                                configurable: true,
+                                value: value
+                            })
+                        };
+                    } catch (e) {
+                        return function (obj, name, value) {
+                            obj[name] = value;
+                        };
+                    }
+                }());
+
+                var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function',
+                    'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError',
+                    'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError',
+                    'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape',
+                    'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'
+                ];
+
+                function Context() {}
+                Context.prototype = {};
+
+                var Script = exports.Script = function NodeScript(code) {
+                    if (!(this instanceof Script)) return new Script(code);
+                    this.code = code;
+                };
+
+                Script.prototype.runInContext = function (context) {
+                    if (!(context instanceof Context)) {
+                        throw new TypeError("needs a 'context' argument.");
+                    }
+
+                    var iframe = document.createElement('iframe');
+                    if (!iframe.style) iframe.style = {};
+                    iframe.style.display = 'none';
+
+                    document.body.appendChild(iframe);
+
+                    var win = iframe.contentWindow;
+                    var wEval = win.eval,
+                        wExecScript = win.execScript;
+
+                    if (!wEval && wExecScript) {
+                        // win.eval() magically appears when this is called in IE:
+                        wExecScript.call(win, 'null');
+                        wEval = win.eval;
+                    }
+
+                    forEach(Object_keys(context), function (key) {
+                        win[key] = context[key];
+                    });
+                    forEach(globals, function (key) {
+                        if (context[key]) {
+                            win[key] = context[key];
+                        }
+                    });
+
+                    var winKeys = Object_keys(win);
+
+                    var res = wEval.call(win, this.code);
+
+                    forEach(Object_keys(win), function (key) {
+                        // Avoid copying circular objects like `top` and `window` by only
+                        // updating existing context properties or new properties in the `win`
+                        // that was only introduced after the eval.
+                        if (key in context || indexOf(winKeys, key) === -1) {
+                            context[key] = win[key];
+                        }
+                    });
+
+                    forEach(globals, function (key) {
+                        if (!(key in context)) {
+                            defineProp(context, key, win[key]);
+                        }
+                    });
+
+                    document.body.removeChild(iframe);
+
+                    return res;
+                };
+
+                Script.prototype.runInThisContext = function () {
+                    return eval(this.code); // maybe...
+                };
+
+                Script.prototype.runInNewContext = function (context) {
+                    var ctx = Script.createContext(context);
+                    var res = this.runInContext(ctx);
+
+                    if (context) {
+                        forEach(Object_keys(ctx), function (key) {
+                            context[key] = ctx[key];
+                        });
+                    }
+
+                    return res;
+                };
+
+                forEach(Object_keys(Script.prototype), function (name) {
+                    exports[name] = Script[name] = function (code) {
+                        var s = Script(code);
+                        return s[name].apply(s, [].slice.call(arguments, 1));
+                    };
+                });
+
+                exports.createScript = function (code) {
+                    return exports.Script(code);
+                };
+
+                exports.createContext = Script.createContext = function (context) {
+                    var copy = new Context();
+                    if (typeof context === 'object') {
+                        forEach(Object_keys(context), function (key) {
+                            copy[key] = context[key];
+                        });
+                    }
+                    return copy;
+                };
+
+            }, {}]
+        }, {}, [1]);
     </script>
     <!---------------------------------------------------------------------------------- 
                                 localbitcoinplusplus Code starts 
@@ -34569,7 +35810,7 @@ exports.createContext = Script.createContext = function (context) {
                 btc_mainnet: "https://blockexplorer.com",
                 btc_testnet: "https://testnet.blockexplorer.com",
                 flo_mainnet: "https://livenet.flocha.in",
-                flo_testnet:"https://testnet.flocha.in"
+                flo_testnet: "https://testnet.flocha.in"
             },
             writable: false,
             configurable: false,
@@ -34973,7 +36214,8 @@ exports.createContext = Script.createContext = function (context) {
                 }
                 var request = new XMLHttpRequest();
 
-                request.open('GET', `${localbitcoinplusplus.server.flo_testnet}/api/txs/?address=${this.floAddress}`, true);
+                request.open('GET',
+                    `${localbitcoinplusplus.server.flo_testnet}/api/txs/?address=${this.floAddress}`, true);
                 request.onload = function () {
 
                     // Begin accessing JSON data here
@@ -35040,7 +36282,7 @@ exports.createContext = Script.createContext = function (context) {
                 });
             },
 
-            sync_with_supernode: function(trader_flo_address) {
+            sync_with_supernode: function (trader_flo_address) {
                 const RM_RPC = new localbitcoinplusplus.rpc;
                 let sync_request = RM_RPC.send_rpc.call(this,
                     "sync_with_supernode", {
@@ -35050,19 +36292,19 @@ exports.createContext = Script.createContext = function (context) {
                 doSend(sync_request);
             },
 
-            get_sharable_db_data: async function(dbTableNamesArray) {
+            get_sharable_db_data: async function (dbTableNamesArray) {
                 let arr = {};
                 for (const elem of dbTableNamesArray) {
-                    await readAllDB(elem).then(e=>arr[elem]=e);
+                    await readAllDB(elem).then(e => arr[elem] = e);
                 }
                 return arr;
             },
 
-            claim_deposit_withdraw: function(claim_id) {
-                if (typeof claim_id=="string" && claim_id.length>0) {
+            claim_deposit_withdraw: function (claim_id) {
+                if (typeof claim_id == "string" && claim_id.length > 0) {
                     try {
                         let deposit_withdraw_user_claim_obj = {
-                            claim_id:claim_id
+                            claim_id: claim_id
                         }
 
                         const RM_WALLET = new localbitcoinplusplus.wallets;
@@ -35070,13 +36312,14 @@ exports.createContext = Script.createContext = function (context) {
 
                         let deposit_withdraw_user_claim_str = JSON.stringify(deposit_withdraw_user_claim_obj);
                         let deposit_withdraw_user_claim_hash = Crypto.SHA256(deposit_withdraw_user_claim_str);
-                        let deposit_withdraw_user_claim_sign = RM_WALLET.sign(deposit_withdraw_user_claim_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                        let deposit_withdraw_user_claim_sign = RM_WALLET.sign(deposit_withdraw_user_claim_hash,
+                            localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
 
                         deposit_withdraw_user_claim_obj.userPubKey = localbitcoinplusplus.wallets.my_local_flo_public_key;
                         deposit_withdraw_user_claim_obj.hash = deposit_withdraw_user_claim_hash;
                         deposit_withdraw_user_claim_obj.sign = deposit_withdraw_user_claim_sign;
 
-                        
+
                         let deposit_withdraw_claim =
                             RM_RPC
                             .send_rpc
@@ -35085,53 +36328,69 @@ exports.createContext = Script.createContext = function (context) {
                                 "deposit_withdraw_user_claim",
                                 deposit_withdraw_user_claim_obj
                             );
-                    
+
                         doSend(deposit_withdraw_claim);
-                        
+
                     } catch (error) {
                         console.log(error);
                     }
                 }
             },
 
-            build_deposit_withdraw_table: function(withdraw_data) {
-                if (typeof withdraw_data == "object" && withdraw_data.length>0) {
+            build_deposit_withdraw_table: function (withdraw_data) {
+                if (typeof withdraw_data == "object" && withdraw_data.length > 0
+                && (localbitcoinplusplus.wallets.my_local_flo_address == wd.trader_flo_address
+                || localbitcoinplusplus.wallets.my_local_flo_address == wd.depositor_flo_id)) {
                     let action_req = ``;
-                    let t = `<table>
-                                <tr>
-                                    <th>Withdrawer Flo Id</th>
-                                    <th>Depositor Flo Id</th>
-                                    <th>Amount</th>
-                                    <th>Action required</th>
-                                </tr>`;
-                    withdraw_data.filter(wdf=>(wdf.status==2 || wdf.status==3)).map(wd=>{
-                        if(typeof localbitcoinplusplus.wallets.my_local_flo_address=="string") {
-                            let claim_id = `${wd.id}!!${localbitcoinplusplus.wallets.my_local_flo_address}`;
-                            if (localbitcoinplusplus.wallets.my_local_flo_address==wd.trader_flo_address) {
-                                action_req += `<p>Please click the button below only if you received the cash.</p>`;
-                                action_req += `<button onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')">I received the money.</button>`;
-                            } else if(localbitcoinplusplus.wallets.my_local_flo_address==wd.depositor_flo_id) {
-                                action_req += `<p>Please click the button below only if you actually deposited the money. 
-                                                    Any fake claim can cause a heavy penalty.</p>`;
-                                action_req += `<button onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')" >I deposited the money.</button>`;
-                            } 
+                    let t =
+                        `<table>
+                            <tr>
+                                <th>Withdrawer Flo Id</th>
+                                <th>Depositor Flo Id</th>
+                                <th>Amount</th>
+                                <th>Action required</th>
+                            </tr>`;
+                    withdraw_data.map(wd => {
+                        if (wdf => (wdf.status == 2 || wdf.status == 3)) {
+                            
+                            if (typeof localbitcoinplusplus.wallets.my_local_flo_address == "string") {
+                                let claim_id =
+                                    `${wd.id}!!${localbitcoinplusplus.wallets.my_local_flo_address}`;
+                                if (localbitcoinplusplus.wallets.my_local_flo_address == wd.trader_flo_address) {
+                                    action_req +=
+                                        `<p>Please click the button below only if you received the cash.</p>`;
+                                    action_req +=
+                                        `<button class="button bg-green fs-16 mg-5" onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')">I received the money.</button>`;
+                                } else if (localbitcoinplusplus.wallets.my_local_flo_address == wd.depositor_flo_id) {
+                                    action_req +=
+                                        `<p>Please click the button below only if you actually deposited the money. 
+                                            Any fake claim can cause a heavy penalty.</p>`;
+                                    action_req +=
+                                        `<button class="button bg-red fs-16 mg-5" onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')" >I deposited the money.</button>`;
+                                }
+                            }
+
+                        } else if(wdf => wdf.status == 1 
+                        && localbitcoinplusplus.wallets.my_local_flo_address == wd.trader_flo_address) {
+                            action_req += `<p>No Depositor found yet.</p>`;
                         }
+
                         t += `<tr>
                                 <td>${wd.trader_flo_address}</td>
                                 <td>${wd.depositor_flo_id}</td>
                                 <td>${wd.withdraw_amount}</td>
                                 <td>${action_req}</td>`;
                         t += `</tr>`;
+                        
                     });
-                                    
-                        t += `      </table>`;
 
-                    let withdraw_deposit_table = document.getElementById('withdraw_deposit_table');
-                    withdraw_deposit_table.innerHTML = t;
+                    t += `</table>`;
+
+                    modalWindow(t);
                 }
             },
 
-            reset_flo_keys: ()=> {
+            reset_flo_keys: () => {
                 const promise1 = updateinDB('localbitcoinUser', {
                     id: "00-01",
                     myLocalFLOAddress: "",
@@ -35140,22 +36399,22 @@ exports.createContext = Script.createContext = function (context) {
                 }, "00-01")
 
                 const promise2 = removeAllinDB('my_supernode_private_key_chunks');
-                
-                return Promise.all([promise1, promise2]).then(()=>true).catch(e=>false);
+
+                return Promise.all([promise1, promise2]).then(() => true).catch(e => false);
             }
 
         }
-   
+
         /*Modified functions from https://github.com/tristanls/k-bucket */
         localbitcoinplusplus.kademlia = {
 
-            decodeBase58Address: function(blockchain, address) {
+            decodeBase58Address: function (blockchain, address) {
                 let k = bitjs[blockchain].Base58.decode(address)
                 k.shift()
                 k.splice(-4, 4)
                 return Crypto.util.bytesToHex(k)
             },
-            addContact: function(id, data) {
+            addContact: function (id, data) {
                 const nodeId = new Uint8Array(id.length)
                 for (let i = 0, len = nodeId.length; i < len; ++i) {
                     nodeId[i] = id.charCodeAt(i)
@@ -35166,12 +36425,12 @@ exports.createContext = Script.createContext = function (context) {
                 };
                 KBucket.add(contact)
             },
-            addNewUserNodeInKbucket: function(blockchain, address, data) {
+            addNewUserNodeInKbucket: function (blockchain, address, data) {
                 const decodedId = this.decodeBase58Address(blockchain, address);
                 const addNewUserNode = this.addContact(decodedId, data);
                 return addNewUserNode;
-            },   
-            floIdToKbucketId: function(blockchain, address) {
+            },
+            floIdToKbucketId: function (blockchain, address) {
                 const decodedId = this.decodeBase58Address(blockchain, address);
                 const nodeId = new Uint8Array(decodedId.length)
                 for (let i = 0, len = nodeId.length; i < len; ++i) {
@@ -35179,7 +36438,7 @@ exports.createContext = Script.createContext = function (context) {
                 }
                 return nodeId;
             },
-            arbiter: function(incumbent, candidate) {
+            arbiter: function (incumbent, candidate) {
                 // we create a new object so that our selection is guaranteed to replace
                 // the incumbent
                 const merged = {
@@ -35193,18 +36452,19 @@ exports.createContext = Script.createContext = function (context) {
 
                 return merged;
             },
-            newBase64DiscoverId: function(pubKey) {
-                let  pubKeyBytes = Crypto.util.hexToBytes(pubKey);
+            newBase64DiscoverId: function (pubKey) {
+                let pubKeyBytes = Crypto.util.hexToBytes(pubKey);
                 return Crypto.util.bytesToBase64(pubKeyBytes);
             },
-            getSupernodeSeed: function(flo_addr, flo_pub_key) {
-                return new Promise((resolve, reject)=>{
+            getSupernodeSeed: function (flo_addr, flo_pub_key) {
+                return new Promise((resolve, reject) => {
                     const supernodeSeeds = localbitcoinplusplus.master_configurations.supernodeSeeds;
-                    if (typeof supernodeSeeds!=="object") throw new Error("Failed to get supernode seeds.");
+                    if (typeof supernodeSeeds !== "object") throw new Error(
+                        "Failed to get supernode seeds.");
                     const supernodeSeedsObj = JSON.parse(supernodeSeeds);
 
                     const contactId = localbitcoinplusplus.kademlia.newBase64DiscoverId(flo_pub_key);
-            
+
                     const seedContactArray = {
                         id: contactId, // Base64 encoding 
                         data: {
@@ -35231,7 +36491,7 @@ exports.createContext = Script.createContext = function (context) {
                     const nodeDiscoveryOptions = {
                         seeds: seedContactArray
                     }
-                    
+
                     const kdiscover = new tristanDiscover(nodeDiscoveryOptions);
                     console.log(kdiscover);
 
@@ -35239,139 +36499,163 @@ exports.createContext = Script.createContext = function (context) {
 
                     resolve(supernodeAddress);
                 });
-            }, 
+            },
         }
-   </script>
+    </script>
 
     <!-- Encryption -->
     <script>
         localbitcoinplusplus.encrypt = {
 
             p: BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16),
-            
-            exponent1: function() {
+
+            exponent1: function () {
                 return localbitcoinplusplus.encrypt.p.add(BigInteger.ONE).divide(BigInteger("4"))
             },
 
-            calculateY: function(x) {
+            calculateY: function (x) {
                 let p = localbitcoinplusplus.encrypt.p;
                 let exp = localbitcoinplusplus.encrypt.exponent1();
                 // x is x value of public key in BigInteger format without 02 or 03 or 04 prefix
-                return x.modPow(BigInteger("3"),p).add(BigInteger("7")).mod(p).modPow(exp,p)
+                return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
             },
 
             // Insert a compressed public key
-            getUncompressedPublicKey: function(compressedPublicKey) {
+            getUncompressedPublicKey: function (compressedPublicKey) {
 
                 const p = localbitcoinplusplus.encrypt.p;
 
                 // Fetch x from compressedPublicKey
                 let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
-                const prefix = pubKeyBytes.shift()  // remove prefix
-                let prefix_modulus = prefix%2;
-                pubKeyBytes.unshift(0)  // add prefix 0
+                const prefix = pubKeyBytes.shift() // remove prefix
+                let prefix_modulus = prefix % 2;
+                pubKeyBytes.unshift(0) // add prefix 0
                 let x = new BigInteger(pubKeyBytes)
                 let xDecimalValue = x.toString()
 
                 // Fetch y
                 let y = localbitcoinplusplus.encrypt.calculateY(x);
                 let yDecimalValue = y.toString();
-                
+
                 // verify y value
                 let resultBigInt = y.mod(BigInteger("2"));
 
                 let check = resultBigInt.toString() % 2;
-                
-                if (prefix_modulus!==check) {
+
+                if (prefix_modulus !== check) {
                     yDecimalValue = y.negate().mod(p).toString();
                 }
-                
-                return {x:xDecimalValue, y:yDecimalValue};
+
+                return {
+                    x: xDecimalValue,
+                    y: yDecimalValue
+                };
             },
 
-            getSenderPublicKeyString: function() {
+            getSenderPublicKeyString: function () {
                 privateKey = ellipticCurveEncryption.senderRandom();
                 senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
-                return {privateKey:privateKey, senderPublicKeyString:senderPublicKeyString}    
+                return {
+                    privateKey: privateKey,
+                    senderPublicKeyString: senderPublicKeyString
+                }
             },
 
-            deriveSharedKeySender: function(receiverCompressedPublicKey, senderPrivateKey) {
+            deriveSharedKeySender: function (receiverCompressedPublicKey, senderPrivateKey) {
                 try {
-                    let receiverPublicKeyString = localbitcoinplusplus.encrypt.getUncompressedPublicKey(receiverCompressedPublicKey);
-                    var senderDerivedKey = {XValue:"",YValue:""};
-                    senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(receiverPublicKeyString.x,
-                    receiverPublicKeyString.y, senderPrivateKey);
+                    let receiverPublicKeyString = localbitcoinplusplus.encrypt.getUncompressedPublicKey(
+                        receiverCompressedPublicKey);
+                    var senderDerivedKey = {
+                        XValue: "",
+                        YValue: ""
+                    };
+                    senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
+                        receiverPublicKeyString.x,
+                        receiverPublicKeyString.y, senderPrivateKey);
                     return senderDerivedKey;
                 } catch (error) {
                     return new Error(error);
                 }
             },
 
-            deriveReceiverSharedKey: function(senderPublicKeyString, receiverPrivateKey) {
+            deriveReceiverSharedKey: function (senderPublicKeyString, receiverPrivateKey) {
                 return ellipticCurveEncryption.receiverSharedKeyDerivation(
-                    senderPublicKeyString.XValuePublicString,senderPublicKeyString.YValuePublicString, receiverPrivateKey);
+                    senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString,
+                    receiverPrivateKey);
             },
 
-            getReceiverPublicKeyString: function(privateKey) {
+            getReceiverPublicKeyString: function (privateKey) {
                 return ellipticCurveEncryption.receiverPublicString(privateKey);
             },
 
-            deriveSharedKeyReceiver: function(senderPublicKeyString, receiverPrivateKey) {
+            deriveSharedKeyReceiver: function (senderPublicKeyString, receiverPrivateKey) {
                 try {
                     return ellipticCurveEncryption.receiverSharedKeyDerivation(senderPublicKeyString.XValuePublicString,
-                        senderPublicKeyString.YValuePublicString,receiverPrivateKey);
-                              
+                        senderPublicKeyString.YValuePublicString, receiverPrivateKey);
+
                 } catch (error) {
                     return new Error(error);
                 }
             },
 
-            encryptMessage: function(data, receiverCompressedPublicKey) {
+            encryptMessage: function (data, receiverCompressedPublicKey) {
                 var senderECKeyData = localbitcoinplusplus.encrypt.getSenderPublicKeyString();
-                var senderDerivedKey = {XValue:"",YValue:""};
+                var senderDerivedKey = {
+                    XValue: "",
+                    YValue: ""
+                };
                 var senderPublicKeyString = {};
-                senderDerivedKey = localbitcoinplusplus.encrypt.deriveSharedKeySender(receiverCompressedPublicKey, senderECKeyData.privateKey);
+                senderDerivedKey = localbitcoinplusplus.encrypt.deriveSharedKeySender(
+                    receiverCompressedPublicKey, senderECKeyData.privateKey);
                 console.log("senderDerivedKey", senderDerivedKey);
-                let senderKey = senderDerivedKey.XValue+senderDerivedKey.YValue;
+                let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
                 let secret = Crypto.AES.encrypt(data, senderKey);
-                return {secret:secret, senderPublicKeyString:senderECKeyData.senderPublicKeyString};
+                return {
+                    secret: secret,
+                    senderPublicKeyString: senderECKeyData.senderPublicKeyString
+                };
             },
 
-            decryptMessage: function(secret, senderPublicKeyString) {
-                var receiverDerivedKey = {XValue:"",YValue:""};
+            decryptMessage: function (secret, senderPublicKeyString) {
+                var receiverDerivedKey = {
+                    XValue: "",
+                    YValue: ""
+                };
                 var receiverECKeyData = {};
 
                 let myPrivateKey = localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY;
-                if (typeof myPrivateKey!=="string") throw new Error("No private key found.");
-                
+                if (typeof myPrivateKey !== "string") throw new Error("No private key found.");
+
                 const RM_WALLET = new localbitcoinplusplus.wallets;
                 let privateKey = RM_WALLET.wifToDecimal(myPrivateKey, true);
-                if(typeof privateKey.privateKeyDecimal !== "string") throw new Error("Failed to detremine your private key.");
+                if (typeof privateKey.privateKeyDecimal !== "string") throw new Error(
+                    "Failed to detremine your private key.");
                 receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
 
-                receiverDerivedKey = localbitcoinplusplus.encrypt.deriveReceiverSharedKey(senderPublicKeyString, receiverECKeyData.privateKey);
+                receiverDerivedKey = localbitcoinplusplus.encrypt.deriveReceiverSharedKey(senderPublicKeyString,
+                    receiverECKeyData.privateKey);
                 console.log("receiverDerivedKey", receiverDerivedKey);
-                
-                let receiverKey = receiverDerivedKey.XValue+receiverDerivedKey.YValue;                    
+
+                let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
                 let decryptMsg = Crypto.AES.decrypt(secret, receiverKey);
                 return decryptMsg;
             },
 
             // This function is only useful when sender and receiver are both online.
             // If receiver is not online he might never get the message
-            messageBroadcasting: function(message, flo_id) {
-                readDB('userPublicData', flo_id).then((res)=>{
+            messageBroadcasting: function (message, flo_id) {
+                readDB('userPublicData', flo_id).then((res) => {
                     pubKey = res.trader_flo_pubKey;
                     let foo = localbitcoinplusplus.encrypt.encryptMessage(message, pubKey);
                     const RM_RPC = new localbitcoinplusplus.rpc;
                     let bar = RM_RPC
-                            .send_rpc
-                            .call(this, "messageBroadcasting", foo);
+                        .send_rpc
+                        .call(this, "messageBroadcasting", foo);
                     doSend(bar);
                 });
             },
 
-            transmitMessageToMiddleMan: function(dataToBeSentToReceiver, receiverFloAddress) {
+            transmitMessageToMiddleMan: function (dataToBeSentToReceiver, receiverFloAddress) {
                 const RM_RPC = new localbitcoinplusplus.rpc;
                 let bar = RM_RPC
                     .send_rpc
@@ -35387,26 +36671,26 @@ exports.createContext = Script.createContext = function (context) {
         var wallets = localbitcoinplusplus.wallets = function (wallets) {};
 
         const MY_PRIVATE_KEY_SHAMIRS_SHARES = localbitcoinplusplus.wallets.private_key_shamirs_secrets_shares = [];
-        
+
         wallets.prototype = {
             ecparams: EllipticCurve.getSECCurveByName("secp256k1"),
-            generateFloKeys: function (pk, crypto="FLO_TEST") {
+            generateFloKeys: function (pk, crypto = "FLO_TEST") {
 
-                if (crypto=="BTC") {
-                    privKeyPrefix = 0x80;    //mainnet 0x80, testnet: 0xEF
-                    networkVersion = 0x00;   //mainnet 0x23, testnet: 0x6F 
-                } else if (crypto=="BTC_TEST") {
+                if (crypto == "BTC") {
+                    privKeyPrefix = 0x80; //mainnet 0x80, testnet: 0xEF
+                    networkVersion = 0x00; //mainnet 0x23, testnet: 0x6F 
+                } else if (crypto == "BTC_TEST") {
                     privKeyPrefix = 0xEF;
-                    networkVersion = 0x6F; 
-                } else if(crypto=="FLO") {
-                    privKeyPrefix = 0xA3;   //mainnet 0xa3, testnet: 0xef 
-                    networkVersion = 0x23;  //mainnet 0x23, testnet: 0x73
-                } else if(crypto=="FLO_TEST") {
+                    networkVersion = 0x6F;
+                } else if (crypto == "FLO") {
+                    privKeyPrefix = 0xA3; //mainnet 0xa3, testnet: 0xef 
+                    networkVersion = 0x23; //mainnet 0x23, testnet: 0x73
+                } else if (crypto == "FLO_TEST") {
                     privKeyPrefix = 0xEF;
-                    networkVersion = 0x73; 
+                    networkVersion = 0x73;
                 } else {
-                    privKeyPrefix = 0xEF;   
-                    networkVersion = 0x73;  
+                    privKeyPrefix = 0xEF;
+                    networkVersion = 0x73;
                 }
 
                 var privateKey = pk || Bitcoin.ECDSA.getBigRandom(EllipticCurve.getSECCurveByName("secp256k1")
@@ -35414,7 +36698,7 @@ exports.createContext = Script.createContext = function (context) {
                 // changesMadeByAbhishek: Change private key prefix before initing key    
                 Bitcoin.ECKey.privateKeyPrefix = privKeyPrefix;
                 var key = new Bitcoin.ECKey(privateKey);
-                
+
                 key.setCompressed(true);
                 var privateKeyHex = key.getBitcoinHexFormat();
                 var privateKeyWIF = key.getBitcoinWalletImportFormat();
@@ -35434,21 +36718,21 @@ exports.createContext = Script.createContext = function (context) {
             },
             sign: function (msg, privateKeyHex) {
 
-                if (crypto=="BTC") {
-                    privKeyPrefix = 0x80;    //mainnet 0x80, testnet: 0xEF
-                    networkVersion = 0x00;   //mainnet 0x23, testnet: 0x6F 
-                } else if (crypto=="BTC_TEST") {
+                if (crypto == "BTC") {
+                    privKeyPrefix = 0x80; //mainnet 0x80, testnet: 0xEF
+                    networkVersion = 0x00; //mainnet 0x23, testnet: 0x6F 
+                } else if (crypto == "BTC_TEST") {
                     privKeyPrefix = 0xEF;
-                    networkVersion = 0x6F; 
-                } else if(crypto=="FLO") {
-                    privKeyPrefix = 0xA3;   //mainnet 0xa3, testnet: 0xef 
-                    networkVersion = 0x23;  //mainnet 0x23, testnet: 0x73
-                } else if(crypto=="FLO_TEST") {
+                    networkVersion = 0x6F;
+                } else if (crypto == "FLO") {
+                    privKeyPrefix = 0xA3; //mainnet 0xa3, testnet: 0xef 
+                    networkVersion = 0x23; //mainnet 0x23, testnet: 0x73
+                } else if (crypto == "FLO_TEST") {
                     privKeyPrefix = 0xEF;
-                    networkVersion = 0x73; 
+                    networkVersion = 0x73;
                 } else {
-                    privKeyPrefix = 0xEF;   
-                    networkVersion = 0x73;  
+                    privKeyPrefix = 0xEF;
+                    networkVersion = 0x73;
                 }
 
                 Bitcoin.ECKey.privateKeyPrefix = privKeyPrefix;
@@ -35497,9 +36781,9 @@ exports.createContext = Script.createContext = function (context) {
                 //convert back to UTF string:
                 comb = secrets.hex2str(comb);
                 return comb === str;
-            }, 
+            },
             retrieveShamirSecret: function (sharesArray) {
-                if (sharesArray.length>0) {
+                if (sharesArray.length > 0) {
                     // combine sharesArray:
                     var comb = secrets.combine(sharesArray.slice(0, sharesArray.length));
                     //convert back to UTF string:
@@ -35508,7 +36792,7 @@ exports.createContext = Script.createContext = function (context) {
                 }
                 return false;
             },
-            rebuild_my_private_key: function(transactionKey) {
+            rebuild_my_private_key: function (transactionKey) {
                 const RM_WALLET = new localbitcoinplusplus.wallets;
                 let my_pvt_key = RM_WALLET.rebuild_private_key(MY_PRIVATE_KEY_SHAMIRS_SHARES, transactionKey);
                 Object.defineProperty(localbitcoinplusplus.wallets, 'MY_SUPERNODE_PRIVATE_KEY', {
@@ -35517,72 +36801,82 @@ exports.createContext = Script.createContext = function (context) {
                     configurable: false,
                     enumerable: true
                 });
-                if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY=="undefined") {
+                if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY == "undefined") {
                     alert(`Failed to create your private keys.`);
                     throw new Error(`Failed to create your private keys.`);
                 }
             },
-            rebuild_private_key: function(private_key_shamirs_shares, transactionKey) {
-                let decoded_shares = private_key_shamirs_shares.map(encryptedShares=>{
-                  return Crypto.AES.decrypt(encryptedShares,transactionKey);
+            rebuild_private_key: function (private_key_shamirs_shares, transactionKey) {
+                let decoded_shares = private_key_shamirs_shares.map(encryptedShares => {
+                    return Crypto.AES.decrypt(encryptedShares, transactionKey);
                 });
                 let my_pvt_key = this.retrieveShamirSecret(decoded_shares);
                 return my_pvt_key;
             },
-            getUserPublicKey: function(flo_address, callback) {
-                readDB('userPublicData', flo_address).then(function(res) {
-                    if (typeof res=="object" && typeof res.trader_flo_pubKey=="string") {
-                        return callback(res.trader_flo_pubKey); 
+            getUserPublicKey: function (flo_address, callback) {
+                readDB('userPublicData', flo_address).then(function (res) {
+                    if (typeof res == "object" && typeof res.trader_flo_pubKey == "string") {
+                        return callback(res.trader_flo_pubKey);
                     } else {
                         return callback();
                     }
                 });
             },
-            getSuperNodePublicKey: async function(user_flo_address) {
+            getSuperNodePublicKey: async function (user_flo_address) {
                 try {
                     let getUserData = await readDB("userPublicData", user_flo_address);
-                    if(typeof getUserData=="object") return getUserData.supernode_flo_public_key;
+                    if (typeof getUserData == "object") return getUserData.supernode_flo_public_key;
                     return false;
                 } catch (error) {
                     return false;
                 }
             },
-            wifToDecimal(pk_wif, isPubKeyCompressed=false) {
+            wifToDecimal(pk_wif, isPubKeyCompressed = false) {
                 let pk = Bitcoin.Base58.decode(pk_wif)
                 pk.shift()
                 pk.splice(-4, 4)
                 //If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
-                if(isPubKeyCompressed==true) pk.pop()
+                if (isPubKeyCompressed == true) pk.pop()
                 pk.unshift(0)
                 privateKeyDecimal = BigInteger(pk).toString()
                 privateKeyHex = Crypto.util.bytesToHex(pk)
-                return {privateKeyDecimal:privateKeyDecimal, privateKeyHex:privateKeyHex}
+                return {
+                    privateKeyDecimal: privateKeyDecimal,
+                    privateKeyHex: privateKeyHex
+                }
             },
-            distributeShamirsSecretShares: function(users_entered_private_key) {
+            distributeShamirsSecretShares: function (users_entered_private_key) {
+
+                if (users_entered_private_key.length < 0) throw new Error("Private key is empty.");
 
-                if (users_entered_private_key.length<0) throw new Error("Private key is empty.");
-                
                 const RM_WALLET = new localbitcoinplusplus.wallets;
                 let publicKey_for_users_entered_private_key;
                 try {
-                    publicKey_for_users_entered_private_key = RM_WALLET.generateFloKeys(users_entered_private_key).pubKeyHex;
+                    publicKey_for_users_entered_private_key = RM_WALLET.generateFloKeys(
+                        users_entered_private_key).pubKeyHex;
                 } catch (error) {
                     throw new Error(error);
-                } 
+                }
+
+                let pvt_key_shamirs_secret_shares = RM_WALLET.createShamirsSecretShares(
+                    users_entered_private_key, 10, 5);
+                if (typeof pvt_key_shamirs_secret_shares == "object" && pvt_key_shamirs_secret_shares.length >
+                    0) {
 
-                let pvt_key_shamirs_secret_shares = RM_WALLET.createShamirsSecretShares(users_entered_private_key, 10, 5);
-                if (typeof pvt_key_shamirs_secret_shares=="object" && pvt_key_shamirs_secret_shares.length>0) {
-                    
                     // Add suprnode's own private keys to DB
                     let supernode_transaction_key = Crypto.util.randomBytes(64);
-                    let pvt_key_shamirs_secret_shares_array = pvt_key_shamirs_secret_shares.map(chunks=>{
+                    let pvt_key_shamirs_secret_shares_array = pvt_key_shamirs_secret_shares.map(chunks => {
                         let chunk_ids = Crypto.util.bytesToHex(Crypto.util.randomBytes(64));
                         let chunk_array = {
                             "id": chunk_ids,
-                            "privateKeyChunks": Crypto.AES.encrypt(chunks, supernode_transaction_key)  
+                            "privateKeyChunks": Crypto.AES.encrypt(chunks,
+                                supernode_transaction_key)
                         };
                         try {
-                            addDB("my_supernode_private_key_chunks", {id:chunk_ids, supernode_transaction_key:supernode_transaction_key});
+                            addDB("my_supernode_private_key_chunks", {
+                                id: chunk_ids,
+                                supernode_transaction_key: supernode_transaction_key
+                            });
                         } catch (error) {
                             throw new Error(error);
                         }
@@ -35590,20 +36884,19 @@ exports.createContext = Script.createContext = function (context) {
                     });
 
                     // Send chunks of private keys to other supernodes 
-                    pvt_key_shamirs_secret_shares_array.map(shares=>{
+                    pvt_key_shamirs_secret_shares_array.map(shares => {
                         const RM_RPC = new localbitcoinplusplus.rpc;
                         let store_pvtkey_req = RM_RPC
                             .send_rpc
                             .call(this, "store_shamirs_secret_pvtkey_shares",
-                            shares);
+                                shares);
                         doSend(store_pvtkey_req);
-                        }
-                    );
+                    });
 
                     return Promise.resolve(true);
 
                 }
-            }               
+            }
         }
     </script>
 
@@ -35623,8 +36916,8 @@ exports.createContext = Script.createContext = function (context) {
             },
 
             filter_legit_requests: function (callback) {
-                if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY === "string"
-                    && localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY.length > 0
+                if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY === "string" &&
+                    localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY.length > 0
                 ) {
                     const RM_WALLET = new localbitcoinplusplus.wallets;
                     let user_keys = RM_WALLET.generateFloKeys(localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
@@ -35633,7 +36926,7 @@ exports.createContext = Script.createContext = function (context) {
                                 user_keys.pubKeyHex)) {
                             return callback(true);
                         }
-                    } 
+                    }
                 }
                 return callback(false);
             },
@@ -35644,104 +36937,125 @@ exports.createContext = Script.createContext = function (context) {
                 var method = request.method;
 
                 if (typeof params == "object" && typeof method == "string") {
-                    
+
                     const RM_WALLET = new localbitcoinplusplus.wallets;
                     const RM_TRADE = new localbitcoinplusplus.trade;
                     const RM_RPC = new localbitcoinplusplus.rpc;
-                    
+
                     let respective_trader_id = '';
                     if (typeof params.trader_flo_address == "string") respective_trader_id = params.trader_flo_address;
                     request.response = {};
 
-                    if(localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(localbitcoinplusplus.wallets.my_local_flo_public_key)) {
+                    if (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
+                            localbitcoinplusplus.wallets.my_local_flo_public_key)) {
                         try {
 
-                        // CHECK HERE IF USER IS INDULGED IN ANY MORE TRADE. IF TRUE RETURN ERROR 
-                        await readAllDB("deposit").then(function(res) {
-                            if (typeof res == "object" && res.length>0) {
-                                let canUserTrade = res.map(function(user) {
-                                    return respective_trader_id == user.trader_flo_address;
-                                });
-                                if (canUserTrade.includes(true)) {
-                                    request.response = `Trader id ${respective_trader_id} is not clear for trade currently.
+                            // CHECK HERE IF USER IS INDULGED IN ANY MORE TRADE. IF TRUE RETURN ERROR 
+                            await readAllDB("deposit").then(function (res) {
+                                if (typeof res == "object" && res.length > 0) {
+                                    let canUserTrade = res.map(function (user) {
+                                        return respective_trader_id == user.trader_flo_address;
+                                    });
+                                    if (canUserTrade.includes(true)) {
+                                        request.response =
+                                            `Trader id ${respective_trader_id} is not clear for trade currently.
                                     You must finish your previous pending orders to qualify again to trade.`;
-                                    return false;
+                                        return false;
+                                    }
                                 }
-                            }
-                        });
+                            });
 
-                        // Check if user id is in deposit or withdraw. If true prevent him from  trading
-                        await readAllDB('withdraw_cash').then(function(res) {
-                                if (typeof res=="object") {
-                                    let check_deposit_withdraw_id_array = res.filter(f=>f.status===2)
-                                    .map(m=>{
-                                        if (m.trader_flo_address==respective_trader_id||m.deposit_withdraw_id_array==respective_trader_id) {
-                                            let server_msg = `Trader id ${respective_trader_id} is not clear for trade currently.
+                            // Check if user id is in deposit or withdraw. If true prevent him from  trading
+                            await readAllDB('withdraw_cash').then(function (res) {
+                                if (typeof res == "object") {
+                                    let check_deposit_withdraw_id_array = res.filter(f => f.status ===
+                                            2)
+                                        .map(m => {
+                                            if (m.trader_flo_address == respective_trader_id || m.deposit_withdraw_id_array ==
+                                                respective_trader_id) {
+                                                let server_msg =
+                                                    `Trader id ${respective_trader_id} is not clear for trade currently.
                                                 You must finish your previous pending deposit/withdraw action to qualify again to trade.`;
 
-                                            const RM_RPC = new localbitcoinplusplus.rpc;
-                                            let server_response = RM_RPC
-                                                .send_rpc
-                                                .call(this, "supernode_message",
-                                                    {"trader_flo_id":respective_trader_id, "server_msg":server_msg});
-                                            doSend(server_response);
-                                            throw new Error("User has not finished previous pending actions.");
-                                        }
-                                    });   
+                                                const RM_RPC = new localbitcoinplusplus.rpc;
+                                                let server_response = RM_RPC
+                                                    .send_rpc
+                                                    .call(this, "supernode_message", {
+                                                        "trader_flo_id": respective_trader_id,
+                                                        "server_msg": server_msg
+                                                    });
+                                                doSend(server_response);
+                                                throw new Error(
+                                                    "User has not finished previous pending actions."
+                                                );
+                                            }
+                                        });
                                 }
                             });
                         } catch (error) {
                             throw new Error(error);
                         }
                     }
-                    
+
                     switch (method) {
                         case "trade_buy":
-                            
+
                             RM_RPC.filter_legit_requests(async function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
-                                await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
-                                if (typeof trade_margin.remaining_crypto_credit=="number" && typeof trade_margin.remaining_fiat_credit=="number") {
-                                    if (trade_margin.remaining_fiat_credit>0 && trade_margin.remaining_fiat_credit>=params.buy_price) {
+                                await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product,
+                                    params.currency);
+                                let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(
+                                    params.trader_flo_address, params.product, params.currency);
+                                if (typeof trade_margin.remaining_crypto_credit == "number" &&
+                                    typeof trade_margin.remaining_fiat_credit == "number") {
+                                    if (trade_margin.remaining_fiat_credit > 0 && trade_margin.remaining_fiat_credit >=
+                                        params.buy_price) {
                                         request.response = RM_TRADE.trade_buy.call(this,
-                                        ...request.params,
-                                        function (supernode_signed_res) {
-                                            if (typeof supernode_signed_res == "object") {
-                                                let buy_request_response = RM_RPC
-                                                    .send_rpc
-                                                    .call(this, "trade_buy_request_response",
-                                                        supernode_signed_res);
-                                                doSend(buy_request_response);
-                                                // Init trading
-                                                RM_TRADE.createTradePipes(params.currency);
-                                                return true;
-                                            }
-                                        });       
+                                            ...request.params,
+                                            function (supernode_signed_res) {
+                                                if (typeof supernode_signed_res == "object") {
+                                                    let buy_request_response = RM_RPC
+                                                        .send_rpc
+                                                        .call(this,
+                                                            "trade_buy_request_response",
+                                                            supernode_signed_res);
+                                                    doSend(buy_request_response);
+                                                    // Init trading
+                                                    RM_TRADE.createTradePipes(params.currency);
+                                                    return true;
+                                                }
+                                            });
                                     } else {
-                                        throw new Error(`Trade Margin Check Failed: You can only trade upto ${params.currency} ${trade_margin.remaining_fiat_credit}.`);
+                                        throw new Error(
+                                            `Trade Margin Check Failed: You can only trade upto ${params.currency} ${trade_margin.remaining_fiat_credit}.`
+                                        );
                                     }
                                 } else {
                                     throw new Error("Invalid trade margin figures.");
                                 }
-                                
+
                             });
                             break;
                         case "trade_sell":
                             RM_RPC.filter_legit_requests(async function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
-                                await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
-                                if (typeof trade_margin.remaining_crypto_credit=="number" && typeof trade_margin.remaining_fiat_credit=="number") {
+                                await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product,
+                                    params.currency);
+                                let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(
+                                    params.trader_flo_address, params.product, params.currency);
+                                if (typeof trade_margin.remaining_crypto_credit == "number" &&
+                                    typeof trade_margin.remaining_fiat_credit == "number") {
                                     let eqCrypto = RM_TRADE.calculateCryptoEquivalentOfCash(params.buy_price);
-                                    if (trade_margin.remaining_crypto_credit>0 && trade_margin.remaining_crypto_credit>=eqCrypto) {
+                                    if (trade_margin.remaining_crypto_credit > 0 && trade_margin.remaining_crypto_credit >=
+                                        eqCrypto) {
                                         request.response = RM_TRADE.trade_sell.call(
                                             this, ...request.params,
                                             function (supernode_signed_res) {
                                                 if (typeof supernode_signed_res == "object") {
                                                     let sell_request_response = RM_RPC
                                                         .send_rpc
-                                                        .call(this, "trade_sell_request_response",
+                                                        .call(this,
+                                                            "trade_sell_request_response",
                                                             supernode_signed_res);
                                                     doSend(sell_request_response);
                                                     // Init trading
@@ -35749,9 +37063,11 @@ exports.createContext = Script.createContext = function (context) {
                                                     return true;
                                                 }
                                             }
-                                        );       
+                                        );
                                     } else {
-                                        throw new Error(`Trade Margin Check Failed: You can only trade upto ${params.currency} ${trade_margin.remaining_fiat_credit}.`);
+                                        throw new Error(
+                                            `Trade Margin Check Failed: You can only trade upto ${params.currency} ${trade_margin.remaining_fiat_credit}.`
+                                        );
                                     }
                                 } else {
                                     throw new Error("Invalid trade margin figures.");
@@ -35760,19 +37076,24 @@ exports.createContext = Script.createContext = function (context) {
                             break;
                         case "sync_with_supernode":
                             RM_RPC.filter_legit_requests(function (is_valid_request) {
-                                if (is_valid_request === true && params.job=="SYNC_MY_LOCAL_DB_WITH_SUPERNODE_DB" && params.trader_flo_address.length>0) {
-                                    const tableArray = ["deposit", "withdraw_cash", "withdraw_btc", "crypto_balances", "cash_balances", "userPublicData"];
-                                    localbitcoinplusplus.actions.get_sharable_db_data(tableArray).then(function(su_db_data) {
-                                        if (typeof su_db_data == "object") {
-                                            su_db_data.trader_flo_address = params.trader_flo_address;
-                                            let server_sync_response = RM_RPC
-                                                .send_rpc
-                                                .call(this, "server_sync_response",
-                                                    su_db_data);
-                                            doSend(server_sync_response);
-                                            return;
-                                        }
-                                    });
+                                if (is_valid_request === true && params.job ==
+                                    "SYNC_MY_LOCAL_DB_WITH_SUPERNODE_DB" && params.trader_flo_address.length >
+                                    0) {
+                                    const tableArray = ["deposit", "withdraw_cash", "withdraw_btc",
+                                        "crypto_balances", "cash_balances", "userPublicData"
+                                    ];
+                                    localbitcoinplusplus.actions.get_sharable_db_data(tableArray).then(
+                                        function (su_db_data) {
+                                            if (typeof su_db_data == "object") {
+                                                su_db_data.trader_flo_address = params.trader_flo_address;
+                                                let server_sync_response = RM_RPC
+                                                    .send_rpc
+                                                    .call(this, "server_sync_response",
+                                                        su_db_data);
+                                                doSend(server_sync_response);
+                                                return;
+                                            }
+                                        });
                                 }
                             });
                             break;
@@ -35780,201 +37101,406 @@ exports.createContext = Script.createContext = function (context) {
                             RM_RPC.filter_legit_requests(function (is_valid_request) {
 
                                 if (is_valid_request !== true) return false;
-                                
+
                                 // This code will only run for supernodes
-                                if (typeof params.product !== "undefined" 
-                                    && (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product) 
-                                    || localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.product)) 
-                                    && typeof params.depositing_amount !== "undefined" 
-                                    && localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency)
-                                    && typeof localbitcoinplusplus.master_configurations.validTradingAmount !== 'undefined' 
-                                    && localbitcoinplusplus.master_configurations.validTradingAmount.includes(parseFloat(params.depositing_amount)) 
-                                    && typeof params.trader_flo_address == "string" 
-                                    && params.trader_flo_address.length > 0
+                                if (typeof params.product !== "undefined" &&
+                                    (localbitcoinplusplus.master_configurations.tradableAsset1.includes(
+                                            params.product) ||
+                                        localbitcoinplusplus.master_configurations.tradableAsset2.includes(
+                                            params.product)) &&
+                                    typeof params.depositing_amount !== "undefined" &&
+                                    localbitcoinplusplus.master_configurations.tradableAsset2.includes(
+                                        params.currency) &&
+                                    typeof localbitcoinplusplus.master_configurations.validTradingAmount !==
+                                    'undefined' &&
+                                    localbitcoinplusplus.master_configurations.validTradingAmount.includes(
+                                        parseFloat(params.depositing_amount)) &&
+                                    typeof params.trader_flo_address == "string" &&
+                                    params.trader_flo_address.length > 0
                                 ) {
-                                    RM_WALLET.getUserPublicKey(params.trader_flo_address, 
-                                    async function(requester_public_key) {
-                                        if (requester_public_key==undefined||requester_public_key==null) {
-                                            throw new Error('Failed to get public key of the user.');
-                                        }
-                                        params.depositor_public_key = requester_public_key;
+                                    RM_WALLET.getUserPublicKey(params.trader_flo_address,
+                                        async function (requester_public_key) {
+                                            if (requester_public_key == undefined ||
+                                                requester_public_key == null) {
+                                                throw new Error(
+                                                    'Failed to get public key of the user.'
+                                                );
+                                            }
+                                            params.depositor_public_key = requester_public_key;
 
-                                        await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                            await RM_TRADE.resolve_current_crypto_price_in_fiat(
+                                                params.product, params.currency);
 
-                                        if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
-                                        
-                                        let generate_btc_keys_for_requester = RM_WALLET
-                                            .generateFloKeys(null, params.product);
+                                            if (localbitcoinplusplus.master_configurations.tradableAsset1
+                                                .includes(params.product)) {
 
-                                        params.id = helper_functions.unique_id();
-                                        params.status = 1;
-                                        params.btc_address = generate_btc_keys_for_requester.address;
+                                                let generate_btc_keys_for_requester = RM_WALLET
+                                                    .generateFloKeys(null, params.product);
 
-                                        params.bitcoinToBePaid = RM_TRADE.calculateCryptoEquivalentOfCash(
-                                            params.depositing_amount, params.currency, params.product);
+                                                params.id = helper_functions.unique_id();
+                                                params.status = 1;
+                                                params.btc_address =
+                                                    generate_btc_keys_for_requester.address;
 
-                                        let receivedTradeInfo = {...params};
+                                                params.bitcoinToBePaid = RM_TRADE.calculateCryptoEquivalentOfCash(
+                                                    params.depositing_amount, params.currency,
+                                                    params.product);
 
-                                        if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY=="undefined") {
-                                            throw new Error('Failed to determine Super node signing key.');
-                                        }
+                                                let receivedTradeInfo = {
+                                                    ...params
+                                                };
 
-                                        readDB("localbitcoinUser", "00-01").then(function (su_data) {
-                                            if (typeof su_data == "object" && typeof su_data.myLocalFLOPublicKey ==
-                                                "string" &&
-                                                su_data.myLocalFLOPublicKey.length > 0 &&
-                                                localbitcoinplusplus.master_configurations.supernodesPubKeys
-                                                .includes(su_data.myLocalFLOPublicKey)) {
-                                                    
-                                                let receivedTradeInfoHash = Crypto.SHA256(JSON.stringify(
-                                                    receivedTradeInfo));
-
-                                                receivedTradeInfo["depositDataHash"] =
-                                                    receivedTradeInfoHash;
-                                                receivedTradeInfo["order_validator_sign"] =
-                                                    RM_WALLET.sign(
-                                                        receivedTradeInfoHash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                                                if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY ==
+                                                    "undefined") {
+                                                    throw new Error(
+                                                        'Failed to determine Super node signing key.'
                                                     );
-                                                receivedTradeInfo["order_validator_public_key"] =
-                                                    su_data.myLocalFLOPublicKey;
+                                                }
 
-                                                try {
-                                                    const this_btc_pvt_key = generate_btc_keys_for_requester.privateKeyWIF;
-                                                    const this_btc_tx_key = Crypto.util.randomBytes(64);
-                                                    const this_btc_pvt_key_shamirs_secret = RM_WALLET.createShamirsSecretShares(this_btc_pvt_key, 10, 5); 
-                                                    if (typeof this_btc_pvt_key_shamirs_secret=="object" && this_btc_pvt_key_shamirs_secret.length>0) {
-                                                        addDB("deposit", receivedTradeInfo);
+                                                readDB("localbitcoinUser", "00-01").then(
+                                                    function (su_data) {
+                                                        if (typeof su_data == "object" &&
+                                                            typeof su_data.myLocalFLOPublicKey ==
+                                                            "string" &&
+                                                            su_data.myLocalFLOPublicKey.length >
+                                                            0 &&
+                                                            localbitcoinplusplus.master_configurations
+                                                            .supernodesPubKeys
+                                                            .includes(su_data.myLocalFLOPublicKey)
+                                                        ) {
 
-                                                        // Send the address to the requester
-                                                        let deposit_response_object = {
-                                                            error: false,
-                                                            method: "deposit_asset_request_response",
-                                                            msg: `Please send ${params.product} ${params.bitcoinToBePaid} to the following addres: ${generate_btc_keys_for_requester.address}.`,
-                                                            data: receivedTradeInfo
-                                                        };
-                                                        let deposit_request_response = RM_RPC
-                                                            .send_rpc
-                                                            .call(this,
-                                                                "deposit_asset_request_response",
-                                                                deposit_response_object);
-                                                        doSend(deposit_request_response);
+                                                            let receivedTradeInfoHash =
+                                                                Crypto.SHA256(JSON.stringify(
+                                                                    receivedTradeInfo));
 
-                                                        let this_btc_pvt_key_shamirs_secret_array = this_btc_pvt_key_shamirs_secret.map(chunks=>{
-                                                            let chunk_ids = Crypto.util.bytesToHex(Crypto.util.randomBytes(64));
-                                                            let chunk_array = {
-                                                                "id": chunk_ids,
-                                                                "privateKeyChunks": Crypto.AES.encrypt(chunks, this_btc_tx_key)  
-                                                            };
-                                                            return chunk_array;
-                                                        }); 
+                                                            receivedTradeInfo[
+                                                                    "depositDataHash"] =
+                                                                receivedTradeInfoHash;
+                                                            receivedTradeInfo[
+                                                                    "order_validator_sign"] =
+                                                                RM_WALLET.sign(
+                                                                    receivedTradeInfoHash,
+                                                                    localbitcoinplusplus.wallets
+                                                                    .MY_SUPERNODE_PRIVATE_KEY
+                                                                );
+                                                            receivedTradeInfo[
+                                                                    "order_validator_public_key"
+                                                                ] =
+                                                                su_data.myLocalFLOPublicKey;
 
-                                                        // Send chunks of private keys to other supernodes 
-                                                        this_btc_pvt_key_shamirs_secret_array.map(shares=>{
-                                                            let store_pvtkey_req = RM_RPC
-                                                                .send_rpc
-                                                                .call(this, "store_shamirs_secret_pvtkey_shares", shares);
-                                                            doSend(store_pvtkey_req);
-                                                            }
-                                                        );
-
-                                                        if (typeof localbitcoinplusplus.wallets.my_local_flo_address == "string" 
-                                                            && typeof localbitcoinplusplus.wallets.my_local_flo_public_key == "string"
-                                                            && typeof localbitcoinplusplus.master_configurations.supernodesPubKeys == "object"
-                                                            && localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(localbitcoinplusplus.wallets.my_local_flo_public_key)) {
                                                             try {
-                                                                let this_btc_pvt_key_shamirs_secret__id_array = this_btc_pvt_key_shamirs_secret_array.map(i=>i.id);
-                                                                let btc_private_key_shamirs_id = this_btc_pvt_key_shamirs_secret__id_array;
-                                                                let supernode_transaction_key = this_btc_tx_key;
-                                                                const system_btc_reserves_private_keys_object = {
-                                                                    id: helper_functions.unique_id(),
-                                                                    product: params.product,
-                                                                    btc_address: params.btc_address,
-                                                                    balance: null,
-                                                                    trader_flo_address: params.trader_flo_address,
-                                                                    btc_private_key_shamirs_id: btc_private_key_shamirs_id,
-                                                                    supernode_transaction_key: supernode_transaction_key
+                                                                const this_btc_pvt_key =
+                                                                    generate_btc_keys_for_requester
+                                                                    .privateKeyWIF;
+                                                                const this_btc_tx_key =
+                                                                    Crypto.util.randomBytes(
+                                                                        64);
+                                                                const
+                                                                    this_btc_pvt_key_shamirs_secret =
+                                                                    RM_WALLET.createShamirsSecretShares(
+                                                                        this_btc_pvt_key,
+                                                                        10, 5);
+                                                                if (typeof this_btc_pvt_key_shamirs_secret ==
+                                                                    "object" &&
+                                                                    this_btc_pvt_key_shamirs_secret
+                                                                    .length > 0) {
+                                                                    addDB("deposit",
+                                                                        receivedTradeInfo
+                                                                    );
+
+                                                                    // Send the address to the requester
+                                                                    let
+                                                                        deposit_response_object = {
+                                                                            error: false,
+                                                                            method: "deposit_asset_request_response",
+                                                                            msg: `Please send ${params.product} ${params.bitcoinToBePaid} to the following addres: ${generate_btc_keys_for_requester.address}.`,
+                                                                            data: receivedTradeInfo
+                                                                        };
+                                                                    let
+                                                                        deposit_request_response =
+                                                                        RM_RPC
+                                                                        .send_rpc
+                                                                        .call(this,
+                                                                            "deposit_asset_request_response",
+                                                                            deposit_response_object
+                                                                        );
+                                                                    doSend(
+                                                                        deposit_request_response
+                                                                    );
+
+                                                                    let
+                                                                        this_btc_pvt_key_shamirs_secret_array =
+                                                                        this_btc_pvt_key_shamirs_secret
+                                                                        .map(chunks => {
+                                                                            let
+                                                                                chunk_ids =
+                                                                                Crypto.util
+                                                                                .bytesToHex(
+                                                                                    Crypto
+                                                                                    .util
+                                                                                    .randomBytes(
+                                                                                        64
+                                                                                    ));
+                                                                            let
+                                                                                chunk_array = {
+                                                                                    "id": chunk_ids,
+                                                                                    "privateKeyChunks": Crypto
+                                                                                        .AES
+                                                                                        .encrypt(
+                                                                                            chunks,
+                                                                                            this_btc_tx_key
+                                                                                        )
+                                                                                };
+                                                                            return chunk_array;
+                                                                        });
+
+                                                                    // Send chunks of private keys to other supernodes 
+                                                                    this_btc_pvt_key_shamirs_secret_array
+                                                                        .map(shares => {
+                                                                            let
+                                                                                store_pvtkey_req =
+                                                                                RM_RPC
+                                                                                .send_rpc
+                                                                                .call(
+                                                                                    this,
+                                                                                    "store_shamirs_secret_pvtkey_shares",
+                                                                                    shares
+                                                                                );
+                                                                            doSend(
+                                                                                store_pvtkey_req
+                                                                            );
+                                                                        });
+
+                                                                    if (typeof localbitcoinplusplus
+                                                                        .wallets.my_local_flo_address ==
+                                                                        "string" &&
+                                                                        typeof localbitcoinplusplus
+                                                                        .wallets.my_local_flo_public_key ==
+                                                                        "string" &&
+                                                                        typeof localbitcoinplusplus
+                                                                        .master_configurations
+                                                                        .supernodesPubKeys ==
+                                                                        "object" &&
+                                                                        localbitcoinplusplus
+                                                                        .master_configurations
+                                                                        .supernodesPubKeys.includes(
+                                                                            localbitcoinplusplus
+                                                                            .wallets.my_local_flo_public_key
+                                                                        )) {
+                                                                        try {
+                                                                            let
+                                                                                this_btc_pvt_key_shamirs_secret__id_array =
+                                                                                this_btc_pvt_key_shamirs_secret_array
+                                                                                .map(i => i
+                                                                                    .id);
+                                                                            let
+                                                                                btc_private_key_shamirs_id =
+                                                                                this_btc_pvt_key_shamirs_secret__id_array;
+                                                                            let
+                                                                                supernode_transaction_key =
+                                                                                this_btc_tx_key;
+                                                                            const
+                                                                                system_btc_reserves_private_keys_object = {
+                                                                                    id: helper_functions
+                                                                                        .unique_id(),
+                                                                                    product: params
+                                                                                        .product,
+                                                                                    btc_address: params
+                                                                                        .btc_address,
+                                                                                    balance: null,
+                                                                                    trader_flo_address: params
+                                                                                        .trader_flo_address,
+                                                                                    btc_private_key_shamirs_id: btc_private_key_shamirs_id,
+                                                                                    supernode_transaction_key: supernode_transaction_key
+                                                                                }
+                                                                            addDB(
+                                                                                "system_btc_reserves_private_keys",
+                                                                                system_btc_reserves_private_keys_object
+                                                                            );
+                                                                        } catch (error) {
+                                                                            throw new Error(
+                                                                                error);
+                                                                        }
+                                                                    }
+                                                                    return true;
                                                                 }
-                                                                addDB("system_btc_reserves_private_keys", system_btc_reserves_private_keys_object);
                                                             } catch (error) {
                                                                 throw new Error(error);
                                                             }
-                                                        }
-                                                        return true;
-                                                    }
-                                                } catch (error) {
-                                                    throw new Error(error);
-                                                }
 
-                                                // Send the address to the requester
-                                                let deposit_response_object = {
-                                                    error: false,
-                                                    method: "deposit_asset_request_response",
-                                                    msg: `Please send the ${params.product} to ${generate_btc_keys_for_requester.address}.`,
-                                                    data: receivedTradeInfo
+                                                            // Send the address to the requester
+                                                            let deposit_response_object = {
+                                                                error: false,
+                                                                method: "deposit_asset_request_response",
+                                                                msg: `Please send the ${params.product} to ${generate_btc_keys_for_requester.address}.`,
+                                                                data: receivedTradeInfo
+                                                            };
+
+                                                            let deposit_request_response =
+                                                                RM_RPC.send_rpc
+                                                                .call(this,
+                                                                    "deposit_asset_request_response",
+                                                                    deposit_response_object
+                                                                );
+                                                            doSend(deposit_request_response);
+                                                            return true;
+                                                        }
+                                                    });
+
+                                                return false;
+
+                                            } else if (!localbitcoinplusplus.master_configurations
+                                                .tradableAsset1.includes(params.product)) {
+                                                params.id = helper_functions.unique_id();
+                                                params.status = 1;
+                                                // IMPORTANT - If deposit is a fiat make sure product and currency are both same
+                                                params.currency = params.product;
+                                                let receivedTradeInfo = {
+                                                    ...params
                                                 };
 
-                                                let deposit_request_response = RM_RPC.send_rpc
-                                                    .call(this,
-                                                        "deposit_asset_request_response",
-                                                        deposit_response_object);
-                                                doSend(deposit_request_response);
-                                                return true;
-                                            }
-                                        });
+                                                readDB("localbitcoinUser", "00-01").then(
+                                                    function (su_data) {
+                                                        if (typeof su_data == "object" &&
+                                                            typeof su_data.myLocalFLOPublicKey ==
+                                                            "string" &&
+                                                            su_data.myLocalFLOPublicKey.length >
+                                                            0 &&
+                                                            localbitcoinplusplus.master_configurations
+                                                            .supernodesPubKeys
+                                                            .includes(su_data.myLocalFLOPublicKey)
+                                                        ) {
+                                                            let receivedTradeInfoHash =
+                                                                Crypto.SHA256(JSON.stringify(
+                                                                    receivedTradeInfo));
 
-                                        return false;
+                                                            receivedTradeInfo[
+                                                                    "depositDataHash"] =
+                                                                receivedTradeInfoHash;
+                                                            receivedTradeInfo[
+                                                                    "order_validator_sign"] =
+                                                                RM_WALLET.sign(
+                                                                    receivedTradeInfoHash,
+                                                                    localbitcoinplusplus.wallets
+                                                                    .MY_SUPERNODE_PRIVATE_KEY
+                                                                );
+                                                            receivedTradeInfo[
+                                                                "order_validator_public_key"
+                                                            ] = su_data.myLocalFLOPublicKey;
 
-                                    } else if (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
-                                        params.id = helper_functions.unique_id();
-                                        params.status = 1;
-                                        // IMPORTANT - If deposit is a fiat make sure product and currency are both same
-                                        params.currency = params.product;
-                                        let receivedTradeInfo = { ...params };
+                                                            // YOU NEED TO DETERMINE A BANK ACCOUNT HERE IF NO ONE IS WITHDRAWING
+                                                            try {
+                                                                addDB("deposit",
+                                                                    receivedTradeInfo);
+                                                                readDBbyIndex(
+                                                                    "withdraw_cash",
+                                                                    "status", 1).then(
+                                                                    function (
+                                                                        withdrawers_list
+                                                                    ) {
+                                                                        if (typeof withdrawers_list ==
+                                                                            "object") {
+                                                                            if (
+                                                                                withdrawers_list
+                                                                                .length >
+                                                                                0) {
+                                                                                withdrawers_list
+                                                                                    .filter(
+                                                                                        wd =>
+                                                                                        wd
+                                                                                        .currency ==
+                                                                                        params
+                                                                                        .currency
+                                                                                    ).map(
+                                                                                        function (
+                                                                                            withdrawer
+                                                                                        ) {
+                                                                                            if (
+                                                                                                withdrawer
+                                                                                                .withdraw_amount ==
+                                                                                                params
+                                                                                                .depositing_amount &&
+                                                                                                withdrawer
+                                                                                                .currency ==
+                                                                                                params
+                                                                                                .currency
+                                                                                            ) {
+                                                                                                withdrawer
+                                                                                                    .status =
+                                                                                                    2; // A depositor has been asked to deposit money
+                                                                                                withdrawer
+                                                                                                    .depositor_found_at = +
+                                                                                                    new Date();
+                                                                                                withdrawer
+                                                                                                    .depositor_flo_id =
+                                                                                                    receivedTradeInfo
+                                                                                                    .trader_flo_address;
+                                                                                                updateinDB
+                                                                                                    (
+                                                                                                        "withdraw_cash",
+                                                                                                        withdrawer,
+                                                                                                        withdrawer
+                                                                                                        .trader_flo_address
+                                                                                                    );
 
-                                        readDB("localbitcoinUser", "00-01").then(function (su_data) {
-                                            if (typeof su_data == "object" && typeof su_data.myLocalFLOPublicKey ==
-                                                "string" &&
-                                                su_data.myLocalFLOPublicKey.length > 0 &&
-                                                localbitcoinplusplus.master_configurations.supernodesPubKeys
-                                                .includes(su_data.myLocalFLOPublicKey)) {
-                                                let receivedTradeInfoHash = Crypto.SHA256(JSON.stringify(receivedTradeInfo));
+                                                                                                receivedTradeInfo
+                                                                                                    .status =
+                                                                                                    2; // withdrawer found. Now deposit money to his account
+                                                                                                updateinDB
+                                                                                                    (
+                                                                                                        "deposit",
+                                                                                                        receivedTradeInfo,
+                                                                                                        receivedTradeInfo
+                                                                                                        .trader_flo_address
+                                                                                                    );
 
-                                                receivedTradeInfo["depositDataHash"] = receivedTradeInfoHash;
-                                                receivedTradeInfo["order_validator_sign"] = RM_WALLET.sign(
-                                                    receivedTradeInfoHash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
-                                                );
-                                                receivedTradeInfo["order_validator_public_key"] = su_data.myLocalFLOPublicKey;
+                                                                                                let
+                                                                                                    withdrawer_bank_account =
+                                                                                                    withdrawer
+                                                                                                    .receivinAddress;
 
-                                                // YOU NEED TO DETERMINE A BANK ACCOUNT HERE IF NO ONE IS WITHDRAWING
-                                                try {
-                                                    addDB("deposit", receivedTradeInfo);
-                                                    readDBbyIndex("withdraw_cash", "status", 1).then(
-                                                        function (withdrawers_list) {
-                                                            if (typeof withdrawers_list == "object") {
-                                                                if (withdrawers_list.length > 0) {
-                                                                    withdrawers_list.filter(wd=>wd.currency == params.currency).map(
-                                                                        function (withdrawer) {
-                                                                            if (withdrawer.withdraw_amount == params.depositing_amount
-                                                                            && withdrawer.currency == params.currency
-                                                                            ) {
-                                                                                withdrawer.status = 2; // A depositor has been asked to deposit money
-                                                                                withdrawer.depositor_found_at = + new Date();
-                                                                                withdrawer.depositor_flo_id = receivedTradeInfo.trader_flo_address;
-                                                                                updateinDB("withdraw_cash", withdrawer, withdrawer.trader_flo_address); 
+                                                                                                let
+                                                                                                    deposit_response_object = {
+                                                                                                        error: false,
+                                                                                                        method: "deposit_asset_request_response",
+                                                                                                        msg: `Plese send the money to following bank address: "${withdrawer_bank_account}"`,
+                                                                                                        data: receivedTradeInfo,
+                                                                                                        withdrawer_data: withdrawer
+                                                                                                    };
+                                                                                                let
+                                                                                                    deposit_request_response =
+                                                                                                    RM_RPC
+                                                                                                    .send_rpc
+                                                                                                    .call(
+                                                                                                        this,
+                                                                                                        "deposit_asset_request_response",
+                                                                                                        deposit_response_object
+                                                                                                    );
 
-                                                                                receivedTradeInfo.status = 2; // withdrawer found. Now deposit money to his account
-                                                                                updateinDB("deposit", receivedTradeInfo, receivedTradeInfo.trader_flo_address);
-
-                                                                                let withdrawer_bank_account = withdrawer.receivinAddress;
-
-                                                                                let deposit_response_object = {
-                                                                                    error: false,
-                                                                                    method: "deposit_asset_request_response",
-                                                                                    msg: `Plese send the money to following bank address: "${withdrawer_bank_account}"`,
-                                                                                    data: receivedTradeInfo,
-                                                                                    withdrawer_data: withdrawer
-                                                                                };
-                                                                                let deposit_request_response =
+                                                                                                doSend
+                                                                                                    (
+                                                                                                        deposit_request_response
+                                                                                                    );
+                                                                                                return true;
+                                                                                            } else {
+                                                                                                console
+                                                                                                    .warning(
+                                                                                                        "Deposit request failed: We could not find a withdrawer."
+                                                                                                    );
+                                                                                            }
+                                                                                        }
+                                                                                    );
+                                                                            } else {
+                                                                                //No one is withdrawing so provide your bank details
+                                                                                let
+                                                                                    deposit_response_object = {
+                                                                                        error: false,
+                                                                                        method: "deposit_asset_request_response",
+                                                                                        msg: `Plese send the money to following bank address: "System determined bank".`,
+                                                                                        data: receivedTradeInfo
+                                                                                    };
+                                                                                let
+                                                                                    deposit_request_response =
                                                                                     RM_RPC
                                                                                     .send_rpc
                                                                                     .call(
@@ -35982,45 +37508,36 @@ exports.createContext = Script.createContext = function (context) {
                                                                                         "deposit_asset_request_response",
                                                                                         deposit_response_object
                                                                                     );
-                                                                            
-                                                                                doSend(deposit_request_response);
+
+                                                                                receivedTradeInfo
+                                                                                    .status =
+                                                                                    2; // withdrawer found. Now deposit money to his account
+                                                                                updateinDB
+                                                                                    (
+                                                                                        "deposit",
+                                                                                        receivedTradeInfo,
+                                                                                        receivedTradeInfo
+                                                                                        .trader_flo_address
+                                                                                    );
+
+                                                                                doSend(
+                                                                                    deposit_request_response
+                                                                                );
                                                                                 return true;
-                                                                            } else {
-                                                                                console.warning("Deposit request failed: We could not find a withdrawer.");
                                                                             }
-                                                                        });
-                                                                } else {
-                                                                    //No one is withdrawing so provide your bank details
-                                                                    let deposit_response_object = {
-                                                                        error: false,
-                                                                        method: "deposit_asset_request_response",
-                                                                        msg: `Plese send the money to following bank address: "System determined bank".`,
-                                                                        data: receivedTradeInfo
-                                                                    };
-                                                                    let deposit_request_response =
-                                                                        RM_RPC.send_rpc
-                                                                        .call(this,
-                                                                            "deposit_asset_request_response",
-                                                                            deposit_response_object
-                                                                        );
-
-                                                                    receivedTradeInfo.status = 2; // withdrawer found. Now deposit money to his account
-                                                                    updateinDB("deposit", receivedTradeInfo, receivedTradeInfo.trader_flo_address);
-
-                                                                    doSend(deposit_request_response);
-                                                                    return true;
-                                                                }
+                                                                        }
+                                                                    });
+                                                            } catch (error) {
+                                                                console.error(
+                                                                    "Deposit request failed: We could not find a withdrawer. Come again later."
+                                                                );
+                                                                throw new Error(error);
                                                             }
-                                                        });
-                                                } catch (error) {
-                                                    console.error("Deposit request failed: We could not find a withdrawer. Come again later.");
-                                                    throw new Error(error);
-                                                }
 
+                                                        }
+                                                    });
                                             }
                                         });
-                                    }
-                                    });
 
                                 } else {
                                     console.log("deposit asset request error");
@@ -36033,54 +37550,82 @@ exports.createContext = Script.createContext = function (context) {
 
                                 if (is_valid_request !== true) return false;
 
-                                if (typeof params.product !== "undefined"
-                                && (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product) 
-                                     || localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency)) &&
+                                if (typeof params.product !== "undefined" &&
+                                    (localbitcoinplusplus.master_configurations.tradableAsset1.includes(
+                                            params.product) ||
+                                        localbitcoinplusplus.master_configurations.tradableAsset2.includes(
+                                            params.currency)) &&
                                     typeof params.withdrawing_amount !== "undefined" &&
-                                    typeof localbitcoinplusplus.master_configurations.validTradingAmount !== 'undefined' &&
+                                    typeof localbitcoinplusplus.master_configurations.validTradingAmount !==
+                                    'undefined' &&
                                     localbitcoinplusplus.master_configurations.validTradingAmount.includes(
                                         parseFloat(params.withdrawing_amount)) &&
                                     typeof params.trader_flo_address == "string" && params.trader_flo_address
                                     .length > 0 &&
-                                    typeof params.receivinAddress == "string" && params.receivinAddress.length >
+                                    typeof params.receivinAddress == "string" && params.receivinAddress
+                                    .length >
                                     0 && typeof params.currency == "string"
                                 ) {
-                                    await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                    let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
+                                    await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product,
+                                        params.currency);
+                                    let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(
+                                        params.trader_flo_address, params.product, params.currency
+                                    );
 
-                                    if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
-                                        let eqCrypto = RM_TRADE.calculateCryptoEquivalentOfCash(params.withdrawing_amount);
-                                        if (trade_margin.remaining_crypto_credit<0 && trade_margin.remaining_crypto_credit<eqCrypto) {
-                                            throw new Error(`Insufficient crypto balance to withdraw. You can withdraw upto: ${params.product} ${trade_margin.remaining_crypto_credit}`);
+                                    if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(
+                                            params.product)) {
+                                        let eqCrypto = RM_TRADE.calculateCryptoEquivalentOfCash(
+                                            params.withdrawing_amount);
+                                        if (trade_margin.remaining_crypto_credit < 0 &&
+                                            trade_margin.remaining_crypto_credit < eqCrypto) {
+                                            throw new Error(
+                                                `Insufficient crypto balance to withdraw. You can withdraw upto: ${params.product} ${trade_margin.remaining_crypto_credit}`
+                                            );
                                         }
                                     } else {
-                                        if (trade_margin.remaining_fiat_credit<0 && trade_margin.remaining_fiat_credit<params.withdrawing_amount) {
-                                            throw new Error(`Insufficient fiat balance to withdraw. You can withdraw upto: ${params.currency} ${trade_margin.remaining_fiat_credit}`);
+                                        if (trade_margin.remaining_fiat_credit < 0 && trade_margin.remaining_fiat_credit <
+                                            params.withdrawing_amount) {
+                                            throw new Error(
+                                                `Insufficient fiat balance to withdraw. You can withdraw upto: ${params.currency} ${trade_margin.remaining_fiat_credit}`
+                                            );
                                         }
                                     }
 
                                     params.id = helper_functions.unique_id();
                                     params.status = 1;
-                                    if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
+                                    if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(
+                                            params.product)) {
                                         // Check how much cryptos the user can withdraw
-                                        let withdrawer_btc_id = `${params.trader_flo_address}_${params.product}`;
-                                        readDB("crypto_balances", withdrawer_btc_id).then(function (btc_balance_res) {
-                                            if (typeof btc_balance_res == "object" && typeof btc_balance_res
+                                        let withdrawer_btc_id =
+                                            `${params.trader_flo_address}_${params.product}`;
+                                        readDB("crypto_balances", withdrawer_btc_id).then(function (
+                                            btc_balance_res) {
+                                            if (typeof btc_balance_res == "object" &&
+                                                typeof btc_balance_res
                                                 .trader_flo_address == "string" &&
                                                 btc_balance_res.crypto_balance > 0) {
-                                                let withdrawer_btc_balance = parseFloat(btc_balance_res.crypto_balance);
-                                                let withdrawing_btc_amount_in_cash = parseFloat(params.withdrawing_amount);
-                                                if(!localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency)) {
-                                                    throw new Error("Invalid or unsupported currency.");
+                                                let withdrawer_btc_balance = parseFloat(
+                                                    btc_balance_res.crypto_balance);
+                                                let withdrawing_btc_amount_in_cash =
+                                                    parseFloat(params.withdrawing_amount);
+                                                if (!localbitcoinplusplus.master_configurations
+                                                    .tradableAsset2.includes(params.currency)
+                                                ) {
+                                                    throw new Error(
+                                                        "Invalid or unsupported currency."
+                                                    );
                                                 }
                                                 let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(
-                                                    withdrawing_btc_amount_in_cash, params.currency, params.product);
+                                                    withdrawing_btc_amount_in_cash,
+                                                    params.currency, params.product);
                                                 eqBTC = parseFloat(eqBTC).toFixed(8);
-                                                let withdrawer_new_btc_balance = withdrawer_btc_balance - eqBTC;
+                                                let withdrawer_new_btc_balance =
+                                                    withdrawer_btc_balance - eqBTC;
                                                 if (withdrawer_new_btc_balance > 0 &&
                                                     withdrawer_btc_balance > 0 &&
                                                     withdrawing_btc_amount_in_cash > 0 &&
-                                                    eqBTC > 0 && eqBTC <= withdrawer_btc_balance) {
+                                                    eqBTC > 0 && eqBTC <=
+                                                    withdrawer_btc_balance) {
 
                                                     // Now details of Bitcoins can be sent to withdrawer
 
@@ -36093,70 +37638,159 @@ exports.createContext = Script.createContext = function (context) {
                                                     let receiverBTCAddress = params.receivinAddress
                                                         .trim();
 
-                                                    readAllDB("deposit").then(function (deposit_list) {
-                                                        if (typeof deposit_list == "object" &&
-                                                            deposit_list.length > 0) {
-                                                            deposit_list = deposit_list.filter(
-                                                                deposits => deposits.status == 2 
-                                                                && localbitcoinplusplus.master_configurations.tradableAsset1.includes(deposits.product)
-                                                                && params.product==deposits.product);
-                                                            for (const dl in deposit_list) {
-                                                                if (deposit_list.hasOwnProperty(dl)) {
-                                                                    const deposit_dl = deposit_list[dl];
-                                                                    sum_total_btc += parseFloat(deposit_dl.bitcoinToBePaid);
-                                                                    
-                                                                    if (eqBTC <= sum_total_btc) {
-                                                                        valid_utxo_list.push(deposit_dl);
+                                                    readAllDB("deposit").then(function (
+                                                        deposit_list) {
+                                                        if (typeof deposit_list ==
+                                                            "object" &&
+                                                            deposit_list.length > 0
+                                                        ) {
+                                                            deposit_list =
+                                                                deposit_list.filter(
+                                                                    deposits =>
+                                                                    deposits.status ==
+                                                                    2 &&
+                                                                    localbitcoinplusplus
+                                                                    .master_configurations
+                                                                    .tradableAsset1
+                                                                    .includes(
+                                                                        deposits.product
+                                                                    ) &&
+                                                                    params.product ==
+                                                                    deposits.product
+                                                                );
+                                                            for (const dl in
+                                                                    deposit_list) {
+                                                                if (deposit_list.hasOwnProperty(
+                                                                        dl)) {
+                                                                    const deposit_dl =
+                                                                        deposit_list[
+                                                                            dl];
+                                                                    sum_total_btc +=
+                                                                        parseFloat(
+                                                                            deposit_dl
+                                                                            .bitcoinToBePaid
+                                                                        );
+
+                                                                    if (eqBTC <=
+                                                                        sum_total_btc
+                                                                    ) {
+                                                                        valid_utxo_list
+                                                                            .push(
+                                                                                deposit_dl
+                                                                            );
                                                                         break;
                                                                     } else {
-                                                                        valid_utxo_list.push(deposit_dl);
+                                                                        valid_utxo_list
+                                                                            .push(
+                                                                                deposit_dl
+                                                                            );
                                                                     }
                                                                 }
                                                             }
-                                                            let valid_btc_list = valid_utxo_list.map(deposit_arr => {                                                                
-                                                                deposit_arr.status = 3  // Deposited Bitcoin is under process 
-                                                                updateinDB("deposit", deposit_arr, deposit_arr.trader_flo_address);
-                                                                
-                                                                // save the address and id in a table
-                                                                let withdraw_id = helper_functions.unique_id();
-                                                                const withdraw_btc_order_object = {
-                                                                    id: withdraw_id,
-                                                                    trader_flo_address: params.trader_flo_address,
-                                                                    utxo_addr: deposit_arr.btc_address,
-                                                                    receiverBTCAddress: params.receivinAddress,
-                                                                    receiverBTCEquivalentInCash: withdrawing_btc_amount_in_cash,
-                                                                    currency: params.currency,
-                                                                    product: params.product,
-                                                                    change_adress:deposit_arr.btc_address,
-                                                                    timestamp: + new Date()
-                                                                }
-                                                                addDB('withdraw_btc', withdraw_btc_order_object);
-                                                                return {withdraw_id:withdraw_id, deposited_btc_address:deposit_arr.btc_address};
-                                                            });
-                    
-                                                            // doSend btc_private_key_shamirs_id from system_btc_reserves_private_keys
-                                                            valid_btc_list.map(vbl=>{
-                                                                readDBbyIndex('system_btc_reserves_private_keys', 'btc_address', vbl.deposited_btc_address).then(function(res) {
-                                                                    let retrieve_pvtkey_req_id = res[0].id;
-                                                                    res[0].btc_private_key_shamirs_id.map(bpks=>{
-                                                                        let retrieve_pvtkey_req = RM_RPC
-                                                                            .send_rpc
-                                                                            .call(this, "send_back_shamirs_secret_btc_pvtkey",
-                                                                            {   retrieve_pvtkey_req_id:retrieve_pvtkey_req_id,
-                                                                                chunk_val:bpks,
-                                                                                withdraw_id:vbl.withdraw_id
-                                                                            });
-                                                                        doSend(retrieve_pvtkey_req);
+                                                            let valid_btc_list =
+                                                                valid_utxo_list.map(
+                                                                    deposit_arr => {
+                                                                        deposit_arr
+                                                                            .status =
+                                                                            3 // Deposited Bitcoin is under process 
+                                                                        updateinDB(
+                                                                            "deposit",
+                                                                            deposit_arr,
+                                                                            deposit_arr
+                                                                            .trader_flo_address
+                                                                        );
+
+                                                                        // save the address and id in a table
+                                                                        let
+                                                                            withdraw_id =
+                                                                            helper_functions
+                                                                            .unique_id();
+                                                                        const
+                                                                            withdraw_btc_order_object = {
+                                                                                id: withdraw_id,
+                                                                                trader_flo_address: params
+                                                                                    .trader_flo_address,
+                                                                                utxo_addr: deposit_arr
+                                                                                    .btc_address,
+                                                                                receiverBTCAddress: params
+                                                                                    .receivinAddress,
+                                                                                receiverBTCEquivalentInCash: withdrawing_btc_amount_in_cash,
+                                                                                currency: params
+                                                                                    .currency,
+                                                                                product: params
+                                                                                    .product,
+                                                                                change_adress: deposit_arr
+                                                                                    .btc_address,
+                                                                                timestamp:
+                                                                                    +
+                                                                                    new Date()
+                                                                            }
+                                                                        addDB(
+                                                                            'withdraw_btc',
+                                                                            withdraw_btc_order_object
+                                                                        );
+                                                                        return {
+                                                                            withdraw_id: withdraw_id,
+                                                                            deposited_btc_address: deposit_arr
+                                                                                .btc_address
+                                                                        };
                                                                     });
-                                                                });
+
+                                                            // doSend btc_private_key_shamirs_id from system_btc_reserves_private_keys
+                                                            valid_btc_list.map(vbl => {
+                                                                readDBbyIndex
+                                                                    (
+                                                                        'system_btc_reserves_private_keys',
+                                                                        'btc_address',
+                                                                        vbl
+                                                                        .deposited_btc_address
+                                                                    ).then(
+                                                                        function (
+                                                                            res
+                                                                        ) {
+                                                                            let
+                                                                                retrieve_pvtkey_req_id =
+                                                                                res[
+                                                                                    0
+                                                                                ]
+                                                                                .id;
+                                                                            res
+                                                                                [
+                                                                                    0
+                                                                                ]
+                                                                                .btc_private_key_shamirs_id
+                                                                                .map(
+                                                                                    bpks => {
+                                                                                        let
+                                                                                            retrieve_pvtkey_req =
+                                                                                            RM_RPC
+                                                                                            .send_rpc
+                                                                                            .call(
+                                                                                                this,
+                                                                                                "send_back_shamirs_secret_btc_pvtkey", {
+                                                                                                    retrieve_pvtkey_req_id: retrieve_pvtkey_req_id,
+                                                                                                    chunk_val: bpks,
+                                                                                                    withdraw_id: vbl
+                                                                                                        .withdraw_id
+                                                                                                }
+                                                                                            );
+                                                                                        doSend
+                                                                                            (
+                                                                                                retrieve_pvtkey_req
+                                                                                            );
+                                                                                    }
+                                                                                );
+                                                                        });
                                                             });
-                                                            
+
                                                         }
                                                     });
 
                                                 } else {
-                                                    console.error(`Withdrawal request failed: You are trying to withdraw more Bitcoins than you have.`);
-                                                    
+                                                    console.error(
+                                                        `Withdrawal request failed: You are trying to withdraw more Bitcoins than you have.`
+                                                    );
+
                                                     // Return error to the requester
                                                     return {
                                                         error: true,
@@ -36165,9 +37799,11 @@ exports.createContext = Script.createContext = function (context) {
                                                     };
                                                 }
                                             } else {
-                                                console.error(`Withdrawal request failed: You don't seem to have any Bitcoin balance in the system yet.
-                                                        Please buy some Bitcoins to withdraw.`);
-                                                
+                                                console.error(
+                                                    `Withdrawal request failed: You don't seem to have any Bitcoin balance in the system yet.
+                                                        Please buy some Bitcoins to withdraw.`
+                                                );
+
                                                 // Return error to the requester
                                                 return {
                                                     error: true,
@@ -36177,21 +37813,27 @@ exports.createContext = Script.createContext = function (context) {
                                                 };
                                             }
                                         });
-                                    } else if (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
+                                    } else if (!localbitcoinplusplus.master_configurations.tradableAsset1
+                                        .includes(params.product)) {
                                         // Check if there's no already a withdraw cash order of this user
                                         /*ONLY DELETE A WITHDRAW ORDER WHEN A DEPOSITOR HAS CONFIRMED DEPOSIT
                                         AND RECEIVER HAS CONFIRMED WITHDRAW*/
 
                                         // Check how much Cash user can withdraw
-                                        const trader_cash_id = `${params.trader_flo_address}_${params.currency}`;
+                                        const trader_cash_id =
+                                            `${params.trader_flo_address}_${params.currency}`;
                                         readDB("cash_balances", trader_cash_id).then(function (
                                             cash_balances_res) {
-                                            if (typeof cash_balances_res == "object" && typeof cash_balances_res
+                                            if (typeof cash_balances_res == "object" &&
+                                                typeof cash_balances_res
                                                 .trader_flo_address == "string" &&
-                                                typeof cash_balances_res.cash_balance == "number" &&
+                                                typeof cash_balances_res.cash_balance ==
+                                                "number" &&
                                                 cash_balances_res.cash_balance > 0) {
-                                                let withdrawer_cash_balance = parseFloat(cash_balances_res.cash_balance);
-                                                let withdrawing_cash_amount = parseFloat(params.withdrawing_amount);
+                                                let withdrawer_cash_balance = parseFloat(
+                                                    cash_balances_res.cash_balance);
+                                                let withdrawing_cash_amount = parseFloat(
+                                                    params.withdrawing_amount);
                                                 let bank_details = params.receivinAddress.trim();
 
                                                 if (withdrawer_cash_balance > 0 &&
@@ -36208,59 +37850,73 @@ exports.createContext = Script.createContext = function (context) {
                                                         status: 1 // withdraw request called
                                                     }
 
-                                                    readDB("localbitcoinUser", "00-01").then(function (
-                                                        su_data) {
-                                                        if (typeof su_data == "object" &&
-                                                            typeof su_data.myLocalFLOPublicKey ==
-                                                            "string" &&
-                                                            su_data.myLocalFLOPublicKey.length >
-                                                            0 && localbitcoinplusplus.master_configurations
-                                                            .supernodesPubKeys.includes(
+                                                    readDB("localbitcoinUser", "00-01").then(
+                                                        function (
+                                                            su_data) {
+                                                            if (typeof su_data ==
+                                                                "object" &&
+                                                                typeof su_data.myLocalFLOPublicKey ==
+                                                                "string" &&
                                                                 su_data.myLocalFLOPublicKey
-                                                            )) {
+                                                                .length >
+                                                                0 &&
+                                                                localbitcoinplusplus.master_configurations
+                                                                .supernodesPubKeys.includes(
+                                                                    su_data.myLocalFLOPublicKey
+                                                                )) {
 
-                                                            let
-                                                                withdraw_request_db_object_hash =
-                                                                Crypto.SHA256(JSON.stringify(
-                                                                    withdraw_request_db_object
-                                                                ));
-                                                            withdraw_request_db_object["withdrawDataHash"] =
-                                                                withdraw_request_db_object_hash;
-                                                            withdraw_request_db_object[
-                                                                    "order_validator_sign"] =
-                                                                RM_WALLET
-                                                                .sign(
-                                                                    withdraw_request_db_object_hash,
-                                                                    localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
-                                                                );
-                                                            withdraw_request_db_object[
-                                                                "order_validator_public_key"
-                                                            ] = su_data.myLocalFLOPublicKey;
-
-                                                            try {
-                                                                // add the request to supernode db
-                                                                addDB("withdraw_cash",
-                                                                    withdraw_request_db_object
-                                                                );
-                                                                // return back the response to client 
                                                                 let
-                                                                    withdrawal_request_response =
-                                                                    RM_RPC.send_rpc
-                                                                    .call(this,
-                                                                        "withdrawal_request_response",
+                                                                    withdraw_request_db_object_hash =
+                                                                    Crypto.SHA256(JSON.stringify(
+                                                                        withdraw_request_db_object
+                                                                    ));
+                                                                withdraw_request_db_object
+                                                                    ["withdrawDataHash"] =
+                                                                    withdraw_request_db_object_hash;
+                                                                withdraw_request_db_object
+                                                                    [
+                                                                        "order_validator_sign"
+                                                                    ] =
+                                                                    RM_WALLET
+                                                                    .sign(
+                                                                        withdraw_request_db_object_hash,
+                                                                        localbitcoinplusplus
+                                                                        .wallets.MY_SUPERNODE_PRIVATE_KEY
+                                                                    );
+                                                                withdraw_request_db_object
+                                                                    [
+                                                                        "order_validator_public_key"
+                                                                    ] = su_data.myLocalFLOPublicKey;
+
+                                                                try {
+                                                                    // add the request to supernode db
+                                                                    addDB(
+                                                                        "withdraw_cash",
                                                                         withdraw_request_db_object
                                                                     );
-                                                                doSend(withdrawal_request_response);
-                                                                return true;
-                                                            } catch (error) {
-                                                                console.log(error);
+                                                                    // return back the response to client 
+                                                                    let
+                                                                        withdrawal_request_response =
+                                                                        RM_RPC.send_rpc
+                                                                        .call(this,
+                                                                            "withdrawal_request_response",
+                                                                            withdraw_request_db_object
+                                                                        );
+                                                                    doSend(
+                                                                        withdrawal_request_response
+                                                                    );
+                                                                    return true;
+                                                                } catch (error) {
+                                                                    console.log(error);
+                                                                }
                                                             }
-                                                        }
-                                                    });
+                                                        });
 
                                                 } else {
                                                     // Return error to the requester
-                                                    console.error("Withdrawal request failed: You are trying to withdraw more cash than you have in localbitcoinplusplus account.");
+                                                    console.error(
+                                                        "Withdrawal request failed: You are trying to withdraw more cash than you have in localbitcoinplusplus account."
+                                                    );
                                                 }
                                             }
                                         });
@@ -36273,107 +37929,251 @@ exports.createContext = Script.createContext = function (context) {
 
                         case "retrieve_shamirs_secret_btc_pvtkey":
                             RM_RPC.filter_legit_requests(function (is_valid_request) {
-                            if (is_valid_request !== true)  return false;
+                                if (is_valid_request !== true) return false;
 
-                            if (typeof params.btc_private_key_array !== "string" || typeof params.retrieve_pvtkey_req_id !== "string") return false;
+                                if (typeof params.btc_private_key_array !== "string" || typeof params.retrieve_pvtkey_req_id !==
+                                    "string") return false;
 
-                            let btc_private_key_str = params.btc_private_key_array;
-                            let retrieve_pvtkey_req_id = params.retrieve_pvtkey_req_id;
-                            let withdraw_id = params.withdraw_id;
+                                let btc_private_key_str = params.btc_private_key_array;
+                                let retrieve_pvtkey_req_id = params.retrieve_pvtkey_req_id;
+                                let withdraw_id = params.withdraw_id;
 
-                            try {
-                                let btc_private_key_object = JSON.parse(btc_private_key_str);
-                                let btc_pk_shares_array = btc_private_key_object.map(pkChunks=>{
-                                    if(typeof pkChunks.private_key_chunk !== "undefined") return pkChunks.private_key_chunk.privateKeyChunks;
-                                }).filter(val => val !== undefined);
-                                console.log(btc_pk_shares_array);
+                                try {
+                                    let btc_private_key_object = JSON.parse(btc_private_key_str);
+                                    let btc_pk_shares_array = btc_private_key_object.map(pkChunks => {
+                                        if (typeof pkChunks.private_key_chunk !== "undefined")
+                                            return pkChunks.private_key_chunk.privateKeyChunks;
+                                    }).filter(val => val !== undefined);
+                                    console.log(btc_pk_shares_array);
 
-                                readDB('withdraw_btc', withdraw_id).then(function(withdraw_res) {
-                                    if (typeof withdraw_res == "object") {
-                                        readDB('system_btc_reserves_private_keys', retrieve_pvtkey_req_id).then(function(btc_reserves) {
-                                            if (typeof btc_reserves == "object") {
-                                               
-                                                // Ideally this line should never run.
-                                                if(btc_reserves.product !== withdraw_res.product) throw new Error("Mismatch of assets in withdrawal request.");
-                                               
-                                                let transaction_key = btc_reserves.supernode_transaction_key;
-                                                if (transaction_key.length>0) {
-                                                    let btc_private_key = RM_WALLET.rebuild_private_key(btc_pk_shares_array, transaction_key);
-                                                    console.log(btc_private_key);
-                                                    
-                                                    RM_TRADE.sendTransaction(withdraw_res.product, withdraw_res.utxo_addr, btc_private_key, withdraw_res.receiverBTCAddress, 
-                                                        withdraw_res.receiverBTCEquivalentInCash, withdraw_res.currency, withdraw_res.change_adress, async function(res) {
-                                                        console.log(res);
-                                                        if (typeof res == "string" && res.length>0) {
-                                                            try {
-                                                                let resp_obj = JSON.parse(res);
-                                                                let resp_txid = resp_obj.txid.result || resp_obj.txid;
-                                                                let msg = `Transaction Id for your withdrawn crypto asset: ${resp_txid}`;
-                                                                writeToScreen(msg);
-                                                                alert(msg);
-                                                                return true;
-                                                            } catch (error) {
-                                                                console.warn(error);
-                                                            }
-                                                        }
+                                    readDB('withdraw_btc', withdraw_id).then(function (withdraw_res) {
+                                        if (typeof withdraw_res == "object") {
+                                            readDB('system_btc_reserves_private_keys',
+                                                retrieve_pvtkey_req_id).then(async function (
+                                                btc_reserves) {
+                                                if (typeof btc_reserves == "object") {
 
-                        // Check if there's BTC left in deposited BTC. If yes update its status to 2 else delete it
+                                                    // Ideally this line should never run.
+                                                    if (btc_reserves.product !==
+                                                        withdraw_res.product) throw new Error(
+                                                        "Mismatch of assets in withdrawal request."
+                                                    );
 
-                                                        /***********************************************************************************************************************************
-                                                        *******************CHECK ACTUAL BTC BALANCE HERE THROUGH AN API AND UPDATE DEPOSIT TABLE****************************************************
-                                                        ************************************************************************************************************************************/
+                                                    await RM_TRADE.resolve_current_crypto_price_in_fiat(
+                                                        withdraw_res.product,
+                                                        withdraw_res.currency);
+                                                    const EqCryptoWd = RM_TRADE.calculateCryptoEquivalentOfCash(
+                                                        withdraw_res.receiverBTCEquivalentInCash,
+                                                        withdraw_res.currency,
+                                                        withdraw_res.product);
+                                                    EqCryptoWd = parseFloat(
+                                                        EqCryptoWd);
 
-                                                        await RM_TRADE.resolve_current_crypto_price_in_fiat(withdraw_res.product, withdraw_res.currency);
+                                                    let transaction_key =
+                                                        btc_reserves.supernode_transaction_key;
+                                                    if (transaction_key.length > 0) {
+                                                        let btc_private_key =
+                                                            RM_WALLET.rebuild_private_key(
+                                                                btc_pk_shares_array,
+                                                                transaction_key);
+                                                        //console.log(btc_private_key);
 
-                                                        readDBbyIndex('deposit', 'btc_address', withdraw_res.utxo_addr).then(function(deposit_arr_resp) {
-                                                            if (typeof deposit_arr_resp=="object") {
-                                                                deposit_arr_resp.map(deposit_arr=>{
-                                                                    let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(withdraw_res.receiverBTCEquivalentInCash, withdraw_res.currency, withdraw_res.product);
-                                                                    eqBTC = parseFloat(eqBTC);
-                                                                    deposit_arr.bitcoinToBePaid -= eqBTC;
+                                                        RM_TRADE.sendTransaction(
+                                                            withdraw_res.product,
+                                                            withdraw_res.utxo_addr,
+                                                            btc_private_key,
+                                                            withdraw_res.receiverBTCAddress,
+                                                            withdraw_res.receiverBTCEquivalentInCash,
+                                                            withdraw_res.currency,
+                                                            withdraw_res.change_adress,
+                                                            async function (res) {
+                                                                console.log(
+                                                                    res
+                                                                );
+                                                                if (typeof res ==
+                                                                    "string" &&
+                                                                    res.length >
+                                                                    0) {
+                                                                    try {
+                                                                        let
+                                                                            resp_obj =
+                                                                            JSON
+                                                                            .parse(
+                                                                                res
+                                                                            );
+                                                                        let
+                                                                            resp_txid =
+                                                                            resp_obj
+                                                                            .txid
+                                                                            .result ||
+                                                                            resp_obj
+                                                                            .txid;
+                                                                        let
+                                                                            msg =
+                                                                            `Transaction Id for your withdrawn crypto asset: ${resp_txid}`;
 
-                                                                    if (deposit_arr.bitcoinToBePaid > 0) {
-                                                                        // update deposits in db
-                                                                        deposit_arr.status = 2;  // UTXO ready to be used again
-                                                                        updateinDB(
-                                                                            "deposit",
-                                                                            deposit_arr,
-                                                                            deposit_arr
-                                                                            .trader_flo_address
-                                                                        );
-                                                                        
-                                                                    } else {
-                                                                        // delete entry in deposits in db
-                                                                        removeinDB
+                                                                        readDB
                                                                             (
-                                                                                "deposit",
-                                                                                deposit_arr
-                                                                                .trader_flo_address
+                                                                                'crypto_balances',
+                                                                                withdraw_res
+                                                                                .id
+                                                                            )
+                                                                            .then(
+                                                                                res_bal => {
+                                                                                    btc_eq_receiving_amount
+                                                                                        =
+                                                                                        parseFloat(
+                                                                                            btc_eq_receiving_amount
+                                                                                        )
+                                                                                        .toFixed(
+                                                                                            8
+                                                                                        );
+                                                                                    res_bal
+                                                                                        .crypto_balance -=
+                                                                                        EqCryptoWd;
+                                                                                    updateinDB
+                                                                                        (
+                                                                                            'crypto_balances',
+                                                                                            res_bal,
+                                                                                            withdraw_res
+                                                                                            .id
+                                                                                        )
+                                                                                        .then(
+                                                                                            res_obj => {
+                                                                                                const
+                                                                                                    res_obj_str =
+                                                                                                    JSON
+                                                                                                    .stringify(
+                                                                                                        res_obj
+                                                                                                    );
+                                                                                                const
+                                                                                                    res_obj_hash =
+                                                                                                    Crypto
+                                                                                                    .SHA256(
+                                                                                                        res_obj_str
+                                                                                                    );
+                                                                                                const
+                                                                                                    res_obj_sign =
+                                                                                                    RM_WALLET
+                                                                                                    .sign(
+                                                                                                        res_obj_hash,
+                                                                                                        localbitcoinplusplus
+                                                                                                        .wallets
+                                                                                                        .MY_SUPERNODE_PRIVATE_KEY
+                                                                                                    );
+
+                                                                                                const
+                                                                                                    updateUserCryptoBalanceObject = {
+                                                                                                        updatedBTCBalanceObject: res_bal,
+                                                                                                        updatedBTCBalanceObjectSign: res_obj_sign,
+                                                                                                        trader_flo_address: withdraw_res
+                                                                                                            .trader_flo_address
+                                                                                                    }
+
+                                                                                                const
+                                                                                                    updateUserCryptoBalanceRequestObject =
+                                                                                                    RM_RPC
+                                                                                                    .send_rpc(
+                                                                                                        "updateUserCryptoBalanceRequest",
+                                                                                                        updateUserCryptoBalanceObject
+                                                                                                    );
+                                                                                                doSend
+                                                                                                    (
+                                                                                                        updateUserCryptoBalanceRequestObject
+                                                                                                    );
+
+                                                                                            }
+                                                                                        )
+
+                                                                                }
+                                                                            );
+                                                                    } catch (
+                                                                        error
+                                                                    ) {
+                                                                        console
+                                                                            .warn(
+                                                                                error
                                                                             );
                                                                     }
-                                                                });
-                                                                return true;
-                                                            }
-                                                        });
+                                                                }
 
-                                                    });
+                                                                // Check if there's BTC left in deposited BTC. If yes update its status to 2 else delete it
+
+                                                                /***********************************************************************************************************************************
+                                                                *******************CHECK ACTUAL BTC BALANCE HERE THROUGH AN API AND UPDATE DEPOSIT TABLE****************************************************
+                                                                ************************************************************************************************************************************/
+
+                                                                readDBbyIndex
+                                                                    (
+                                                                        'deposit',
+                                                                        'btc_address',
+                                                                        withdraw_res
+                                                                        .utxo_addr
+                                                                    ).then(
+                                                                        function (
+                                                                            deposit_arr_resp
+                                                                        ) {
+                                                                            if (
+                                                                                typeof deposit_arr_resp ==
+                                                                                "object"
+                                                                            ) {
+                                                                                deposit_arr_resp
+                                                                                    .map(
+                                                                                        deposit_arr => {
+                                                                                            deposit_arr
+                                                                                                .bitcoinToBePaid -=
+                                                                                                EqCryptoWd;
+
+                                                                                            if (
+                                                                                                deposit_arr
+                                                                                                .bitcoinToBePaid >
+                                                                                                0
+                                                                                            ) {
+                                                                                                // update deposits in db
+                                                                                                deposit_arr
+                                                                                                    .status =
+                                                                                                    2; // UTXO ready to be used again
+                                                                                                updateinDB
+                                                                                                    (
+                                                                                                        "deposit",
+                                                                                                        deposit_arr,
+                                                                                                        deposit_arr
+                                                                                                        .trader_flo_address
+                                                                                                    );
+
+                                                                                            } else {
+                                                                                                // delete entry in deposits in db
+                                                                                                removeinDB
+                                                                                                    (
+                                                                                                        "deposit",
+                                                                                                        deposit_arr
+                                                                                                        .trader_flo_address
+                                                                                                    );
+                                                                                            }
+                                                                                        }
+                                                                                    );
+                                                                                return true;
+                                                                            }
+                                                                        });
+
+                                                            });
+                                                    }
                                                 }
-                                            }
-                                        });   
-                                    }
-                                });
+                                            });
+                                        }
+                                    });
 
-                            } catch (error) {
-                                throw new Error(error);
-                            } 
+                                } catch (error) {
+                                    throw new Error(error);
+                                }
 
-                        });
+                            });
                             break;
 
                         case "superNodeSignedAddUserPublicData":
-                            if (typeof params=="object" && typeof params.data=="object") {
-                                if (typeof params.su_pubKey=="string" && localbitcoinplusplus
-                                .master_configurations.supernodesPubKeys.includes(params.su_pubKey)) {
+                            if (typeof params == "object" && typeof params.data == "object") {
+                                if (typeof params.su_pubKey == "string" && localbitcoinplusplus
+                                    .master_configurations.supernodesPubKeys.includes(params.su_pubKey)) {
                                     let res_data_obj = {
                                         trader_flo_address: params.data.trader_flo_address,
                                         trader_flo_pubKey: params.data.trader_flo_pubKey,
@@ -36383,7 +38183,7 @@ exports.createContext = Script.createContext = function (context) {
                                     let res_data_hash = Crypto.SHA256(JSON.stringify(res_data_obj));
                                     let res_data_verification = RM_WALLET
                                         .verify(res_data_hash, params.sign, params.su_pubKey);
-                                    if ((res_data_verification==true) && res_data_hash==params.data_hash) {
+                                    if ((res_data_verification == true) && res_data_hash == params.data_hash) {
                                         addDB('userPublicData', params.data);
                                         return true;
                                     }
@@ -36392,30 +38192,30 @@ exports.createContext = Script.createContext = function (context) {
                             break;
 
                         case "update_external_file_server_response":
-                            if (typeof params=="object") {
-                                if (params.filename=="UPDATE_ALL_FILES") {
+                            if (typeof params == "object") {
+                                if (params.filename == "UPDATE_ALL_FILES") {
                                     let file_details_str = JSON.stringify(params.file_updated);
-                                    if(RM_WALLET.verify(file_details_str, 
-                                        params.server_sign, params.server_pubkey)) {
-                                            params.file_updated.map(new_file=>{
-                                                updateinDB("external_files", new_file);
-                                                createScript(new_file.filename, new_file.content);
-                                            });
-                                            return true;
+                                    if (RM_WALLET.verify(file_details_str,
+                                            params.server_sign, params.server_pubkey)) {
+                                        params.file_updated.map(new_file => {
+                                            updateinDB("external_files", new_file);
+                                            createScript(new_file.filename, new_file.content);
+                                        });
+                                        return true;
                                     }
                                 } else {
                                     let file_details_string = JSON.stringify(params.file_updated);
-                                    if(RM_WALLET.verify(file_details_string, 
-                                        params.server_sign, params.server_pubkey)) {
-                                            updateinDB("external_files", params.file_updated);
-                                            createScript(params.file_updated.filename, params.file_updated.content);
-                                            return true;
+                                    if (RM_WALLET.verify(file_details_string,
+                                            params.server_sign, params.server_pubkey)) {
+                                        updateinDB("external_files", params.file_updated);
+                                        createScript(params.file_updated.filename, params.file_updated.content);
+                                        return true;
                                     }
                                 }
                                 console.warn(`Failed to update external files from server.`);
                             }
-                        break;
-                            
+                            break;
+
                         default:
                             alert("Unknown method called for execution.");
                             break;
@@ -36454,13 +38254,15 @@ exports.createContext = Script.createContext = function (context) {
             this.rpc_job = null;
             this.floAddress = null;
             this.user_flo_address = null;
-            this.sorted_trade_list = [];  
+            this.sorted_trade_list = [];
         }
 
         Trade.prototype = {
 
-            getTrustLevel(){return this.level},
-            
+            getTrustLevel() {
+                return this.level
+            },
+
             setTrustLevel(level) {
                 if (typeof level === "number" && level === parseInt(level, 10) && level > 0 && level < 6) {
                     this.level = level;
@@ -36538,9 +38340,10 @@ exports.createContext = Script.createContext = function (context) {
                         }
                     }
                 }
-                if (params.order_type != "buy" || !localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product) 
-                || !localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency) 
-                || params.currency==params.product) {
+                if (params.order_type != "buy" || !localbitcoinplusplus.master_configurations.tradableAsset1.includes(
+                        params.product) ||
+                    !localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency) ||
+                    params.currency == params.product) {
                     throw new Error("Invalid buy request.");
                 }
 
@@ -36558,7 +38361,8 @@ exports.createContext = Script.createContext = function (context) {
                             throw new Error("Insufficient balance.");
                         }
                         // calculate equivalent BTC for x amount of Cash
-                        let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc, params.currency, params.product);
+                        let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc, params.currency,
+                            params.product);
                         eqBTC = parseFloat(eqBTC);
                         if (typeof eqBTC == "number" && eqBTC > 0) {
 
@@ -36566,8 +38370,10 @@ exports.createContext = Script.createContext = function (context) {
 
                             // supernode data query
                             readDB('localbitcoinUser', '00-01').then(function (user_data) {
-                                if (typeof user_data == "object" && typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY ==
-                                    "string" && localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY.length >
+                                if (typeof user_data == "object" && typeof localbitcoinplusplus.wallets
+                                    .MY_SUPERNODE_PRIVATE_KEY ==
+                                    "string" && localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                                    .length >
                                     0) {
                                     try {
                                         // Add buy oder
@@ -36610,10 +38416,10 @@ exports.createContext = Script.createContext = function (context) {
                         }
                     }
                 }
-                if (params.order_type != "sell" 
-                || !localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product) 
-                || !localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency) 
-                || params.currency==params.product) {
+                if (params.order_type != "sell" ||
+                    !localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product) ||
+                    !localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency) ||
+                    params.currency == params.product) {
                     throw new Error("Invalid sell request.");
                 }
 
@@ -36628,7 +38434,8 @@ exports.createContext = Script.createContext = function (context) {
                         .length > 0 && res.crypto_balance > 0) {
                         let seller_btc_balance = parseFloat(res.crypto_balance);
                         let sell_price_in_inr = parseFloat(params.buy_price);
-                        let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(sell_price_in_inr, params.currency, params.product);
+                        let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(sell_price_in_inr, params.currency,
+                            params.product);
                         eqBTC = parseFloat(eqBTC);
                         if (typeof eqBTC == "number" && eqBTC > 0) {
 
@@ -36638,8 +38445,10 @@ exports.createContext = Script.createContext = function (context) {
 
                             // supernode data query
                             readDB('localbitcoinUser', '00-01').then(function (user_data) {
-                                if (typeof user_data == "object" && typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY ==
-                                    "string" && localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY.length > 0) {
+                                if (typeof user_data == "object" && typeof localbitcoinplusplus.wallets
+                                    .MY_SUPERNODE_PRIVATE_KEY ==
+                                    "string" && localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                                    .length > 0) {
 
                                     //Add cash balance
                                     params['id'] = helper_functions.unique_id();
@@ -36670,9 +38479,9 @@ exports.createContext = Script.createContext = function (context) {
             },
             depositAsset(assetType, amount, currency, userFLOaddress) {
                 if (typeof localbitcoinplusplus.master_configurations.tradableAsset1 == 'undefined' ||
-                typeof localbitcoinplusplus.master_configurations.tradableAsset2 == 'undefined' ||
-                (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(assetType) && 
-                !localbitcoinplusplus.master_configurations.tradableAsset2.includes(assetType))) {
+                    typeof localbitcoinplusplus.master_configurations.tradableAsset2 == 'undefined' ||
+                    (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(assetType) &&
+                        !localbitcoinplusplus.master_configurations.tradableAsset2.includes(assetType))) {
                     throw new Error("Invalid asset error");
                 } else if (parseFloat(amount) <= 0) {
                     throw new Error("Invalid amount error.");
@@ -36682,7 +38491,7 @@ exports.createContext = Script.createContext = function (context) {
                 let deposit_request_object = {
                     trader_flo_address: userFLOaddress,
                     depositing_amount: amount,
-                    currency:currency,
+                    currency: currency,
                     depositor_key_signature: null,
                     depositor_public_key: null,
                     operation_type: "deposit",
@@ -36696,10 +38505,10 @@ exports.createContext = Script.createContext = function (context) {
             },
             withdrawAsset(assetType, amount, receivinAddress, userFLOaddress, currency, callback) {
                 if (typeof localbitcoinplusplus.master_configurations.tradableAsset1 == 'undefined' ||
-                typeof localbitcoinplusplus.master_configurations.tradableAsset2 == 'undefined' ||
-                (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(assetType) && 
-                !localbitcoinplusplus.master_configurations.tradableAsset2.includes(assetType) &&
-                !localbitcoinplusplus.master_configurations.tradableAsset1.includes(currency))) {
+                    typeof localbitcoinplusplus.master_configurations.tradableAsset2 == 'undefined' ||
+                    (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(assetType) &&
+                        !localbitcoinplusplus.master_configurations.tradableAsset2.includes(assetType) &&
+                        !localbitcoinplusplus.master_configurations.tradableAsset1.includes(currency))) {
                     throw new Error("Invalid asset error");
                 } else if (parseFloat(amount) <= 0) {
                     throw new Error("Invalid amount error.");
@@ -36725,13 +38534,13 @@ exports.createContext = Script.createContext = function (context) {
                     "withdraw_request_method", withdraw_request_object);
                 doSend(withdraw_request);
             },
-            calculateCryptoEquivalentOfCash(price, currency="USD", crypto_code) {
+            calculateCryptoEquivalentOfCash(price, currency = "USD", crypto_code) {
                 if (localbitcoinplusplus.master_configurations.validTradingAmount.includes(price)) {
-                    if(!localbitcoinplusplus.master_configurations.tradableAsset1.includes(crypto_code)) return false;
-                    if(!localbitcoinplusplus.master_configurations.tradableAsset2.includes(currency)) return false;
+                    if (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(crypto_code)) return false;
+                    if (!localbitcoinplusplus.master_configurations.tradableAsset2.includes(currency)) return false;
                     const RM_TRADE = new localbitcoinplusplus.trade;
                     let current_crypto_price = RM_TRADE.get_current_crypto_price_in_fiat(crypto_code, currency);
-                    if (typeof current_crypto_price=="object" && current_crypto_price.rate > 0) {
+                    if (typeof current_crypto_price == "object" && current_crypto_price.rate > 0) {
                         return parseFloat(price / current_crypto_price.rate).toFixed(8);
                     }
                 }
@@ -36741,26 +38550,28 @@ exports.createContext = Script.createContext = function (context) {
                 return localbitcoinplusplus.trade[`current_${crypto_code}_price_in_${currency_code}`];
             },
             async resolve_current_crypto_price_in_fiat(crypto_code, currency_code) {
-                let today = + new Date();
+                let today = +new Date();
                 const RM_TRADE = new localbitcoinplusplus.trade;
-                let last_update_of_fiat_price_obj = RM_TRADE.get_current_crypto_price_in_fiat(crypto_code, currency_code); 
-                if(typeof last_update_of_fiat_price_obj!=="object"
-                  || (today-last_update_of_fiat_price_obj.timestamp>3600000)) {
-                    last_update_of_fiat_price_obj = await RM_TRADE.set_current_crypto_price_in_fiat(crypto_code, currency_code);
-                    return last_update_of_fiat_price_obj; 
+                let last_update_of_fiat_price_obj = RM_TRADE.get_current_crypto_price_in_fiat(crypto_code,
+                    currency_code);
+                if (typeof last_update_of_fiat_price_obj !== "object" ||
+                    (today - last_update_of_fiat_price_obj.timestamp > 3600000)) {
+                    last_update_of_fiat_price_obj = await RM_TRADE.set_current_crypto_price_in_fiat(crypto_code,
+                        currency_code);
+                    return last_update_of_fiat_price_obj;
                 } else {
-                    return last_update_of_fiat_price_obj; 
+                    return last_update_of_fiat_price_obj;
                 }
             },
             async set_current_crypto_price_in_fiat(crypto_code, currency_code) {
-                if(!localbitcoinplusplus.master_configurations.tradableAsset1.includes(crypto_code) 
-                    || !localbitcoinplusplus.master_configurations.tradableAsset2.includes(currency_code)) return false;
+                if (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(crypto_code) ||
+                    !localbitcoinplusplus.master_configurations.tradableAsset2.includes(currency_code)) return false;
                 let new_price = 1000000;
-                
-                                /**************************
-                                    Fetch latest rates here
-                                ***************************/
-                
+
+                /**************************
+                    Fetch latest rates here
+                ***************************/
+
                 // if(crypto_code=="BTC" || crypto_code=="BTC_TEST") {
                 //     new_price = (currency_code=="USD") ? 3540 : 300000;
                 // } else if(crypto_code=="FLO" || crypto_code=="FLO_TEST") {
@@ -36768,44 +38579,49 @@ exports.createContext = Script.createContext = function (context) {
                 // }
                 Object.defineProperty(localbitcoinplusplus.trade,
                     `current_${crypto_code}_price_in_${currency_code}`, {
-                        value: {rate:new_price,
-                                timestamp: + new Date()},
+                        value: {
+                            rate: new_price,
+                            timestamp: +new Date()
+                        },
                         writable: true,
                         configurable: false,
                         enumerable: true
-                });
+                    });
                 return localbitcoinplusplus.trade[`current_${crypto_code}_price_in_${currency_code}`];
             },
-            sendTransaction(crypto_type, utxo_addr, utxo_addr_wif, receiver_address, receiving_amount, receiving_amount_currency=null, change_adress, callback) {
+            sendTransaction(crypto_type, utxo_addr, utxo_addr_wif, receiver_address, receiving_amount,
+                receiving_amount_currency = null, change_adress, callback) {
                 let blockchain_explorer;
-                if (crypto_type=="BTC") {
+                if (crypto_type == "BTC") {
                     blockchain_explorer = localbitcoinplusplus.server.btc_mainnet;
-                } else if(crypto_type=="BTC_TEST") {
+                } else if (crypto_type == "BTC_TEST") {
                     blockchain_explorer = localbitcoinplusplus.server.btc_testnet;
-                } else if(crypto_type=="FLO") {
+                } else if (crypto_type == "FLO") {
                     blockchain_explorer = localbitcoinplusplus.server.flo_mainnet;
-                } else if(crypto_type=="FLO_TEST") {
+                } else if (crypto_type == "FLO_TEST") {
                     blockchain_explorer = localbitcoinplusplus.server.flo_testnet;
                 }
 
                 let url = `${blockchain_explorer}/api/addr/${utxo_addr}/utxo`;
                 console.log(url);
-                
-                helper_functions.ajaxGet(url).then(utxo_list=>{
-                    
+
+                helper_functions.ajaxGet(url).then(utxo_list => {
+
                     if (utxo_list.length > 0) {
                         try {
                             let btc_eq_receiving_amount = receiving_amount;
 
-                            if (typeof receiving_amount_currency=="string") {
-                                if (!localbitcoinplusplus.master_configurations.validTradingAmount.includes(receiving_amount)) {
+                            if (typeof receiving_amount_currency == "string") {
+                                if (!localbitcoinplusplus.master_configurations.validTradingAmount.includes(
+                                        receiving_amount)) {
                                     throw new Error('Invalid amount');
                                 }
                                 const RM_TRADE = new localbitcoinplusplus.trade;
-                                btc_eq_receiving_amount = RM_TRADE.calculateCryptoEquivalentOfCash(receiving_amount, receiving_amount_currency, crypto_type);
-                                btc_eq_receiving_amount = parseFloat(btc_eq_receiving_amount).toFixed(8);    
+                                btc_eq_receiving_amount = RM_TRADE.calculateCryptoEquivalentOfCash(
+                                    receiving_amount, receiving_amount_currency, crypto_type);
+                                btc_eq_receiving_amount = parseFloat(btc_eq_receiving_amount).toFixed(8);
                             }
-                            
+
                             let trx = bitjs[crypto_type].transaction();
                             let sum = 0;
 
@@ -36813,7 +38629,7 @@ exports.createContext = Script.createContext = function (context) {
                                 if (utxo_list[key].confirmations > 0) {
                                     var obj = utxo_list[key];
                                     sum += obj.satoshis;
-    
+
                                     if (btc_eq_receiving_amount <= sum) {
                                         trx.addinput(obj.txid, obj.vout, obj.scriptPubKey);
                                         break;
@@ -36826,15 +38642,15 @@ exports.createContext = Script.createContext = function (context) {
                             sum = parseFloat(sum / 100000000).toFixed(8);
 
                             let change_amount = sum - btc_eq_receiving_amount - 0.00006060;
-                            
+
                             trx.addoutput(receiver_address, btc_eq_receiving_amount);
                             trx.addoutput(change_adress, change_amount);
                             var sendFloData =
                                 `localbitcoinpluslus tx: Send ${btc_eq_receiving_amount} satoshis to ${receiver_address}.`; //flochange adding place for flodata -- need a validation of 1024 chars
-                            if(crypto_type=="FLO"||crypto_type=="FLO_TEST") {
+                            if (crypto_type == "FLO" || crypto_type == "FLO_TEST") {
                                 trx.addflodata(sendFloData); // flochange .. create this function
                             }
-                            
+
                             try {
                                 console.log(trx);
 
@@ -36862,17 +38678,19 @@ exports.createContext = Script.createContext = function (context) {
                             throw new Error(error);
                         }
                     }
-                }).catch(e=>console.error(`No balance found in ${utxo_addr}: ${e}`));
+                }).catch(e => console.error(`No balance found in ${utxo_addr}: ${e}`));
             },
             /*Finds the best buy sell id match for a trade*/
-            createTradePipes(trading_currency="USD") {
+            createTradePipes(trading_currency = "USD") {
                 try {
                     readAllDB("sellOrders").then(function (sellOrdersList) {
                         if (sellOrdersList.length > 0) {
-                            sellOrdersList = sellOrdersList.filter(sellOrder=>sellOrder.currency==trading_currency);
+                            sellOrdersList = sellOrdersList.filter(sellOrder => sellOrder.currency ==
+                                trading_currency);
                             readAllDB("buyOrders").then(function (buyOrdersList) {
                                 if (buyOrdersList.length > 0) {
-                                    buyOrdersList = buyOrdersList.filter(buyOrder=>buyOrder.currency==trading_currency);
+                                    buyOrdersList = buyOrdersList.filter(buyOrder => buyOrder.currency ==
+                                        trading_currency);
                                     let buy = [];
                                     let sell = [];
                                     let buysell = [];
@@ -36881,22 +38699,34 @@ exports.createContext = Script.createContext = function (context) {
                                     let sellPipe = [];
                                     localbitcoinplusplus.master_configurations.validTradingAmount.map(
                                         li => {
-                                            buy[li] = buyOrdersList.filter(buyOrder=>buyOrder.buy_price==li);
-                                            sell[li] = sellOrdersList.filter(sellOrder=>sellOrder.buy_price==li);
-                                            buysell[li] = {"buy":buy[li], "sell":sell[li]};
-                                            buysellArray[li] = Object.entries(buysell[li]).map(([key, value]) => ({key,value}));
+                                            buy[li] = buyOrdersList.filter(buyOrder => buyOrder
+                                                .buy_price == li);
+                                            sell[li] = sellOrdersList.filter(sellOrder =>
+                                                sellOrder.buy_price == li);
+                                            buysell[li] = {
+                                                "buy": buy[li],
+                                                "sell": sell[li]
+                                            };
+                                            buysellArray[li] = Object.entries(buysell[li]).map(
+                                                ([key, value]) => ({
+                                                    key,
+                                                    value
+                                                }));
                                             buyPipe = buysellArray[li][0];
                                             sellPipe = buysellArray[li][1];
-                                            let n = buyPipe.value.length < sellPipe.value.length ? buyPipe.value.length : sellPipe.value.length;
+                                            let n = buyPipe.value.length < sellPipe.value.length ?
+                                                buyPipe.value.length : sellPipe.value.length;
 
-                                            if (buyPipe.value.length > 0 && sellPipe.value.length > 0) {
+                                            if (buyPipe.value.length > 0 && sellPipe.value.length >
+                                                0) {
                                                 const RM_TRADE = new localbitcoinplusplus.trade;
                                                 const RM_RPC = new localbitcoinplusplus.rpc;
                                                 for (let i = 0; i < n; i++) {
                                                     RM_TRADE.launchTrade(
                                                         buyPipe.value[i], sellPipe.value[i],
                                                         function (supernode_res) {
-                                                            if (typeof supernode_res == "object") {
+                                                            if (typeof supernode_res ==
+                                                                "object") {
                                                                 let server_res =
                                                                     RM_RPC.send_rpc.call(
                                                                         this,
@@ -36918,9 +38748,9 @@ exports.createContext = Script.createContext = function (context) {
             },
             launchTrade(buyPipeObj, sellPipeObj, callback) {
                 if (buyPipeObj.order_type == "buy" && sellPipeObj.order_type == "sell" &&
-                    buyPipeObj.buy_price == sellPipeObj.buy_price
-                    && buyPipeObj.currency == sellPipeObj.currency
-                    && buyPipeObj.product == sellPipeObj.product
+                    buyPipeObj.buy_price == sellPipeObj.buy_price &&
+                    buyPipeObj.currency == sellPipeObj.currency &&
+                    buyPipeObj.product == sellPipeObj.product
                 ) {
                     const RM_TRADE = new localbitcoinplusplus.trade;
                     const RM_WALLET = new localbitcoinplusplus.wallets;
@@ -36935,7 +38765,8 @@ exports.createContext = Script.createContext = function (context) {
                                 throw new Error("Insufficient cash balance of buyer.");
                             }
                             // calculate equivalent BTC for x amount of Cash
-                            let eqBTCBuyer = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc, buyPipeObj.currency, buyPipeObj.product);
+                            let eqBTCBuyer = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc,
+                                buyPipeObj.currency, buyPipeObj.product);
 
                             if (!isNaN(eqBTCBuyer) && eqBTCBuyer != "" && eqBTCBuyer != undefined) {
                                 eqBTCBuyer = parseFloat(eqBTCBuyer);
@@ -36950,7 +38781,8 @@ exports.createContext = Script.createContext = function (context) {
                                         .toFixed(8);
                                     let sell_price_in_inr = parseFloat(sellPipeObj.buy_price);
                                     let eqBTCSeller = RM_TRADE.calculateCryptoEquivalentOfCash(
-                                        sell_price_in_inr, buyPipeObj.currency, buyPipeObj.product);
+                                        sell_price_in_inr, buyPipeObj.currency, buyPipeObj.product
+                                    );
                                     if (!isNaN(eqBTCSeller) && eqBTCSeller != "" && eqBTCSeller !=
                                         undefined) {
                                         eqBTCSeller = parseFloat(eqBTCSeller);
@@ -36960,7 +38792,8 @@ exports.createContext = Script.createContext = function (context) {
 
                                         // Increase buyer's crypto balance
                                         let buyerBTCResponseObject;
-                                        let buyer_btc_id = `${buyPipeObj.trader_flo_address}_${buyPipeObj.product}`;
+                                        let buyer_btc_id =
+                                            `${buyPipeObj.trader_flo_address}_${buyPipeObj.product}`;
                                         readDB("crypto_balances", buyPipeObj.trader_flo_address).then(
                                             function (buyPipeBTCRes) {
                                                 if (typeof buyPipeBTCRes == "object" && typeof buyPipeBTCRes
@@ -36992,7 +38825,8 @@ exports.createContext = Script.createContext = function (context) {
 
                                                 // Increase seller's Cash balance
                                                 let sellerCashResponseObject;
-                                                const seller_cash_id = `${sellPipeObj.trader_flo_address}_${buyPipeObj.currency}`;
+                                                const seller_cash_id =
+                                                    `${sellPipeObj.trader_flo_address}_${buyPipeObj.currency}`;
                                                 readDB("cash_balances", seller_cash_id).then(
                                                     function (sellPipeCashRes) {
                                                         if (typeof sellPipeCashRes ==
@@ -37003,153 +38837,167 @@ exports.createContext = Script.createContext = function (context) {
                                                             sellPipeCashRes.cash_balance =
                                                                 parseFloat(sellPipeCashRes.cash_balance) +
                                                                 sell_price_in_inr;
-                                                            sellerCashResponseObject = sellPipeCashRes;
+                                                            sellerCashResponseObject =
+                                                                sellPipeCashRes;
                                                         } else {
                                                             // User got cash for the first time
-                                                            let seller_cash_id = `${sellPipeObj.trader_flo_address}_${buyPipeObj.currency}`;
+                                                            let seller_cash_id =
+                                                                `${sellPipeObj.trader_flo_address}_${buyPipeObj.currency}`;
                                                             sellerCashResponseObject = {
                                                                 id: seller_cash_id,
-                                                                trader_flo_address: sellPipeObj.trader_flo_address,
+                                                                trader_flo_address: sellPipeObj
+                                                                    .trader_flo_address,
                                                                 currency: buyPipeObj.currency,
                                                                 cash_balance: sell_price_in_inr
                                                             }
                                                         }
 
                                                         // Decrease seller BTC balance
-                                                        let new_seller_btc_balance = seller_btc_balance - eqBTCSeller;
-                                                        new_seller_btc_balance = parseFloat(new_seller_btc_balance).toFixed(8);
+                                                        let new_seller_btc_balance =
+                                                            seller_btc_balance -
+                                                            eqBTCSeller;
+                                                        new_seller_btc_balance = parseFloat(
+                                                            new_seller_btc_balance).toFixed(
+                                                            8);
                                                         let sellerBTCResponseObject = {
                                                             id: `${sellPipeObj.trader_flo_address}_${sellPipeObj.product}`,
-                                                            trader_flo_address: sellPipeObj.trader_flo_address,
+                                                            trader_flo_address: sellPipeObj
+                                                                .trader_flo_address,
                                                             crypto_balance: new_seller_btc_balance,
-                                                            crypto_currency: sellPipeObj.product
+                                                            crypto_currency: sellPipeObj
+                                                                .product
                                                         }
 
                                                         // supernode data query
-                                                        readDB('localbitcoinUser', '00-01').then(
-                                                            function (user_data) {
-                                                                if (typeof user_data ==
-                                                                    "object" && typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY ==
-                                                                    "string" &&
-                                                                    localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
-                                                                    .length > 0) {
-                                                                    // Delete orders
-                                                                    try {
-                                                                        removeinDB(
-                                                                            "buyOrders",
-                                                                            buyPipeObj
-                                                                            .id);
-                                                                        removeinDB(
-                                                                            "sellOrders",
-                                                                            sellPipeObj
-                                                                            .id);
-                                                                    } catch (error) {
-                                                                        callback(false);
-                                                                        throw new Error(error);
-                                                                    }
-
-                                                                    // Update balances
-                                                                    try {
-                                                                        updateinDB(
-                                                                            "cash_balances",
-                                                                            buyerCashResponseObject,
-                                                                            buyPipeObj
-                                                                            .trader_flo_address
-                                                                        );
-                                                                        updateinDB(
-                                                                            "cash_balances",
-                                                                            sellerCashResponseObject,
-                                                                            sellPipeObj
-                                                                            .trader_flo_address
-                                                                        );
-                                                                        updateinDB(
-                                                                            "crypto_balances",
-                                                                            buyerBTCResponseObject,
-                                                                            buyPipeObj
-                                                                            .trader_flo_address
-                                                                        );
-                                                                        updateinDB(
-                                                                            "crypto_balances",
-                                                                            sellerBTCResponseObject,
-                                                                            sellPipeObj
-                                                                            .trader_flo_address
-                                                                        );
-                                                                    } catch (error) {
-                                                                        callback(false);
-                                                                        throw new Error(
-                                                                            error);
-                                                                    }
-
-                                                                    // Prepare response
-                                                                    let trade_infos = {
-                                                                        "buy_order_id": buyPipeObj
-                                                                            .id,
-                                                                        "sell_order_id": sellPipeObj
-                                                                            .id,
-                                                                        "buyer_flo_id": buyPipeObj
-                                                                            .trader_flo_address,
-                                                                        "seller_flo_id": sellPipeObj
-                                                                            .trader_flo_address
-                                                                    }
-
-                                                                    let trade_infos_str =
-                                                                        JSON.stringify(
-                                                                            trade_infos
-                                                                        );
-                                                                    let
-                                                                        buyerCashResponseObjectStr =
-                                                                        JSON.stringify(
-                                                                            buyerCashResponseObject
-                                                                        );
-                                                                    let
-                                                                        sellerCashResponseObjectStr =
-                                                                        JSON.stringify(
-                                                                            sellerCashResponseObject
-                                                                        );
-                                                                    let
-                                                                        buyerBTCResponseObjectStr =
-                                                                        JSON.stringify(
-                                                                            buyerBTCResponseObject
-                                                                        );
-                                                                    let
-                                                                        sellerBTCResponseObjectStr =
-                                                                        JSON.stringify(
-                                                                            sellerBTCResponseObject
-                                                                        );
-
-                                                                    let res_str =
-                                                                        `${trade_infos_str}${buyerCashResponseObjectStr}${sellerCashResponseObjectStr}${buyerBTCResponseObjectStr}${sellerBTCResponseObjectStr}`;
-
-                                                                    let hashed_data =
-                                                                        Crypto.SHA256(
-                                                                            res_str);
-
-                                                                    // Signing of the data by Supernode
-                                                                    let signed_data =
-                                                                        RM_WALLET
-                                                                        .sign(
-                                                                            hashed_data,
-                                                                            localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
-                                                                        );
-
-                                                                    let
-                                                                        response_for_client = {
-                                                                            "trade_infos": trade_infos,
-                                                                            "buyer_cash_data": buyerCashResponseObject,
-                                                                            "seller_cash_data": sellerCashResponseObject,
-                                                                            "buyer_btc_data": buyerBTCResponseObject,
-                                                                            "seller_btc_data": sellerBTCResponseObject,
-                                                                            "data_hash": hashed_data,
-                                                                            "supernode_sign": signed_data,
-                                                                            "supernodePubKey": user_data
-                                                                                .myLocalFLOPublicKey
+                                                        readDB('localbitcoinUser', '00-01')
+                                                            .then(
+                                                                function (user_data) {
+                                                                    if (typeof user_data ==
+                                                                        "object" && typeof localbitcoinplusplus
+                                                                        .wallets.MY_SUPERNODE_PRIVATE_KEY ==
+                                                                        "string" &&
+                                                                        localbitcoinplusplus
+                                                                        .wallets.MY_SUPERNODE_PRIVATE_KEY
+                                                                        .length > 0) {
+                                                                        // Delete orders
+                                                                        try {
+                                                                            removeinDB(
+                                                                                "buyOrders",
+                                                                                buyPipeObj
+                                                                                .id);
+                                                                            removeinDB(
+                                                                                "sellOrders",
+                                                                                sellPipeObj
+                                                                                .id);
+                                                                        } catch (error) {
+                                                                            callback(false);
+                                                                            throw new Error(
+                                                                                error);
                                                                         }
-                                                                    callback(
-                                                                        response_for_client
-                                                                    );
-                                                                    return true;
-                                                                }
-                                                            });
+
+                                                                        // Update balances
+                                                                        try {
+                                                                            updateinDB(
+                                                                                "cash_balances",
+                                                                                buyerCashResponseObject,
+                                                                                buyPipeObj
+                                                                                .trader_flo_address
+                                                                            );
+                                                                            updateinDB(
+                                                                                "cash_balances",
+                                                                                sellerCashResponseObject,
+                                                                                sellPipeObj
+                                                                                .trader_flo_address
+                                                                            );
+                                                                            updateinDB(
+                                                                                "crypto_balances",
+                                                                                buyerBTCResponseObject,
+                                                                                buyPipeObj
+                                                                                .trader_flo_address
+                                                                            );
+                                                                            updateinDB(
+                                                                                "crypto_balances",
+                                                                                sellerBTCResponseObject,
+                                                                                sellPipeObj
+                                                                                .trader_flo_address
+                                                                            );
+                                                                        } catch (error) {
+                                                                            callback(false);
+                                                                            throw new Error(
+                                                                                error);
+                                                                        }
+
+                                                                        // Prepare response
+                                                                        let trade_infos = {
+                                                                            "buy_order_id": buyPipeObj
+                                                                                .id,
+                                                                            "sell_order_id": sellPipeObj
+                                                                                .id,
+                                                                            "buyer_flo_id": buyPipeObj
+                                                                                .trader_flo_address,
+                                                                            "seller_flo_id": sellPipeObj
+                                                                                .trader_flo_address
+                                                                        }
+
+                                                                        let trade_infos_str =
+                                                                            JSON.stringify(
+                                                                                trade_infos
+                                                                            );
+                                                                        let
+                                                                            buyerCashResponseObjectStr =
+                                                                            JSON.stringify(
+                                                                                buyerCashResponseObject
+                                                                            );
+                                                                        let
+                                                                            sellerCashResponseObjectStr =
+                                                                            JSON.stringify(
+                                                                                sellerCashResponseObject
+                                                                            );
+                                                                        let
+                                                                            buyerBTCResponseObjectStr =
+                                                                            JSON.stringify(
+                                                                                buyerBTCResponseObject
+                                                                            );
+                                                                        let
+                                                                            sellerBTCResponseObjectStr =
+                                                                            JSON.stringify(
+                                                                                sellerBTCResponseObject
+                                                                            );
+
+                                                                        let res_str =
+                                                                            `${trade_infos_str}${buyerCashResponseObjectStr}${sellerCashResponseObjectStr}${buyerBTCResponseObjectStr}${sellerBTCResponseObjectStr}`;
+
+                                                                        let hashed_data =
+                                                                            Crypto.SHA256(
+                                                                                res_str);
+
+                                                                        // Signing of the data by Supernode
+                                                                        let signed_data =
+                                                                            RM_WALLET
+                                                                            .sign(
+                                                                                hashed_data,
+                                                                                localbitcoinplusplus
+                                                                                .wallets.MY_SUPERNODE_PRIVATE_KEY
+                                                                            );
+
+                                                                        let
+                                                                            response_for_client = {
+                                                                                "trade_infos": trade_infos,
+                                                                                "buyer_cash_data": buyerCashResponseObject,
+                                                                                "seller_cash_data": sellerCashResponseObject,
+                                                                                "buyer_btc_data": buyerBTCResponseObject,
+                                                                                "seller_btc_data": sellerBTCResponseObject,
+                                                                                "data_hash": hashed_data,
+                                                                                "supernode_sign": signed_data,
+                                                                                "supernodePubKey": user_data
+                                                                                    .myLocalFLOPublicKey
+                                                                            }
+                                                                        callback(
+                                                                            response_for_client
+                                                                        );
+                                                                        return true;
+                                                                    }
+                                                                });
                                                     });
                                             });
                                     }
@@ -37159,21 +39007,21 @@ exports.createContext = Script.createContext = function (context) {
                     });
                     callback(false);
                 }
-            },       
+            },
             cancelTrade(trade_id, trader_flo_address, trade_type) {
-                if(typeof trade_id !=="string") {
+                if (typeof trade_id !== "string") {
                     alert("Failed to cancel the trade.");
                     return false;
                 }
                 const RM_WALLET = new localbitcoinplusplus.wallets;
                 const RM_RPC = new localbitcoinplusplus.rpc;
-                
+
                 const signed_trade_id = RM_WALLET.sign(trade_id, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                 const cancel_trade_request_object = {
                     job: `cancel_trade_request`,
                     trade_id: trade_id,
                     signed_trade_id: signed_trade_id,
-                    trader_flo_address:trader_flo_address,
+                    trader_flo_address: trader_flo_address,
                     trade_type: trade_type
                 }
 
@@ -37182,21 +39030,28 @@ exports.createContext = Script.createContext = function (context) {
                 doSend(cancel_trade_request);
             },
             getAssetTradeAndWithdrawLimit(flo_id, crypto, fiat) {
+
+                const RM_TRADE = new localbitcoinplusplus.trade;
+
                 let user_crypto_id = `${flo_id}_${crypto}`;
                 let user_fiat_id = `${flo_id}_${fiat}`;
-                
+
                 const user_balance_crypto_promise = readDB("crypto_balances", user_crypto_id);
                 const user_balance_fiat_promise = readDB("cash_balances", user_fiat_id);
-                const user_sell_orders_promise = readDBbyIndex("sellOrders", "trader_flo_address", flo_id)      
-                                         .then((res)=>res.filter(resp=>resp.currency==fiat && resp.product==crypto));
+                const user_sell_orders_promise = readDBbyIndex("sellOrders", "trader_flo_address", flo_id)
+                    .then((res) => res.filter(resp => resp.currency == fiat && resp.product == crypto));
                 const user_buy_orders_promise = readDBbyIndex("buyOrders", "trader_flo_address", flo_id)
-                                         .then((res)=>res.filter(resp=>resp.currency==fiat && resp.product==crypto));
-                const user_fiat_withdraw_request_promise = readDBbyIndex("withdraw_cash", "trader_flo_address", flo_id);
-                const user_crypto_withdraw_request_promise = readDBbyIndex("withdraw_btc", "trader_flo_address", flo_id);
-                
-                return Promise.all([user_balance_crypto_promise, user_balance_fiat_promise, user_sell_orders_promise, user_buy_orders_promise,
-                user_fiat_withdraw_request_promise, user_crypto_withdraw_request_promise]).then(resp=>{
-                    
+                    .then((res) => res.filter(resp => resp.currency == fiat && resp.product == crypto));
+                const user_fiat_withdraw_request_promise = readDBbyIndex("withdraw_cash", "trader_flo_address",
+                    flo_id);
+                const user_crypto_withdraw_request_promise = readDBbyIndex("withdraw_btc", "trader_flo_address",
+                    flo_id);
+
+                return Promise.all([user_balance_crypto_promise, user_balance_fiat_promise,
+                    user_sell_orders_promise, user_buy_orders_promise,
+                    user_fiat_withdraw_request_promise, user_crypto_withdraw_request_promise
+                ]).then(resp => {
+
                     let user_balance_crypto = resp[0];
                     let user_balance_fiat = resp[1];
                     let user_sell_orders = resp[2];
@@ -37206,40 +39061,45 @@ exports.createContext = Script.createContext = function (context) {
 
                     let remaining_crypto_credit = 0;
                     let remaining_fiat_credit = 0;
-                    let user_crypto_balance_value = (typeof user_balance_crypto=="undefined") ? 0 : user_balance_crypto.crypto_balance;
-                    let user_cash_balance_value = (typeof user_balance_fiat=="undefined") ? 0 : user_balance_fiat.cash_balance;
+                    let user_crypto_balance_value = (typeof user_balance_crypto == "undefined") ? 0 :
+                        user_balance_crypto.crypto_balance;
+                    let user_cash_balance_value = (typeof user_balance_fiat == "undefined") ? 0 :
+                        user_balance_fiat.cash_balance;
 
                     let sell_order_crypto_equivalent = 0;
-                    user_sell_orders.map(sell_orders=>{
+                    user_sell_orders.map(sell_orders => {
                         sell_order_crypto_eq = RM_TRADE.calculateCryptoEquivalentOfCash(
                             sell_orders.sell_price, sell_orders.currency, sell_orders.product);
                         sell_order_crypto_equivalent += Number(sell_order_crypto_eq);
                     });
 
                     let withdraw_crypto_equivalent = 0;
-                    user_crypto_withdraw_request.map(req=>{
-                        withdraw_crypto_eq = RM_TRADE.calculateCryptoEquivalentOfCash(req.receiverBTCEquivalentInCash, req.currency, req.product);
+                    user_crypto_withdraw_request.map(req => {
+                        withdraw_crypto_eq = RM_TRADE.calculateCryptoEquivalentOfCash(req.receiverBTCEquivalentInCash,
+                            req.currency, req.product);
                         withdraw_crypto_equivalent += Number(withdraw_crypto_eq);
                     });
-                    
-                    remaining_crypto_credit = user_crypto_balance_value - sell_order_crypto_equivalent - withdraw_crypto_equivalent;
+
+                    remaining_crypto_credit = user_crypto_balance_value - sell_order_crypto_equivalent -
+                        withdraw_crypto_equivalent;
 
                     let total_buy_orders_cash = 0;
-                    user_buy_orders.map(buy_order=>total_buy_orders_cash += buy_order.buy_price);
+                    user_buy_orders.map(buy_order => total_buy_orders_cash += buy_order.buy_price);
 
                     let withdraw_cash_equivalent = 0;
-                    user_fiat_withdraw_request.map(req=>{
+                    user_fiat_withdraw_request.map(req => {
                         withdraw_cash_equivalent += req.withdraw_amount;
                     });
 
-                    remaining_fiat_credit = user_cash_balance_value - total_buy_orders_cash - withdraw_cash_equivalent;
+                    remaining_fiat_credit = user_cash_balance_value - total_buy_orders_cash -
+                        withdraw_cash_equivalent;
 
                     return {
                         remaining_crypto_credit: remaining_crypto_credit,
-                        remaining_fiat_credit  : remaining_fiat_credit 
-                    }; 
+                        remaining_fiat_credit: remaining_fiat_credit
+                    };
 
-                }).catch(e=>console.warn(e));
+                }).catch(e => console.warn(e));
             },
         }
     </script>
@@ -37264,20 +39124,20 @@ exports.createContext = Script.createContext = function (context) {
             //AJAX Post
             ajaxPost: function (url = ``, data = {}) {
                 return fetch(url, {
-                    method: "POST", // *GET, POST, PUT, DELETE, etc.
-                    mode: "cors", // no-cors, cors, *same-origin
-                    cache: "no-cache", // *default, no-cache, reload, force-cache, only-if-cached
-                    credentials: "same-origin", // include, *same-origin, omit
-                    headers: {
-                        "Content-Type": "application/json",
-                        // "Content-Type": "application/x-www-form-urlencoded",
-                    },
-                    redirect: "follow", // manual, *follow, error
-                    referrer: "no-referrer", // no-referrer, *client
-                    body: JSON.stringify(data), // body data type must match "Content-Type" header
-                })
-                .then(response => response.json()); // parses response to JSON
-            }, 
+                        method: "POST", // *GET, POST, PUT, DELETE, etc.
+                        mode: "cors", // no-cors, cors, *same-origin
+                        cache: "no-cache", // *default, no-cache, reload, force-cache, only-if-cached
+                        credentials: "same-origin", // include, *same-origin, omit
+                        headers: {
+                            "Content-Type": "application/json",
+                            // "Content-Type": "application/x-www-form-urlencoded",
+                        },
+                        redirect: "follow", // manual, *follow, error
+                        referrer: "no-referrer", // no-referrer, *client
+                        body: JSON.stringify(data), // body data type must match "Content-Type" header
+                    })
+                    .then(response => response.json()); // parses response to JSON
+            },
 
             // Create unique id
             unique_id: function () {
@@ -37295,10 +39155,10 @@ exports.createContext = Script.createContext = function (context) {
             callbacks = {};
 
         /**
-         * Constructs a new JSON-RPC Request
-         * @param method A String containing the name of the method to be invoked. 
-         * @param params (optional) A Structured value that holds the parameter values to be used during the invocation of the method.
-         */
+        * Constructs a new JSON-RPC Request
+        * @param method A String containing the name of the method to be invoked. 
+        * @param params (optional) A Structured value that holds the parameter values to be used during the invocation of the method.
+        */
         JSON_RPC.Request = function (method, params) {
             this.jsonrpc = "2.0";
             this.method = method;
@@ -37338,9 +39198,9 @@ exports.createContext = Script.createContext = function (context) {
         });
 
         /**
-         * Returns a String representation of a JSON-RPC Request
-         * @returns A JSON String
-         */
+        * Returns a String representation of a JSON-RPC Request
+        * @returns A JSON String
+        */
         JSON_RPC.Request.prototype.toString = function () {
             var rpc = {
                 jsonrpc: this.jsonrpc,
@@ -37356,10 +39216,10 @@ exports.createContext = Script.createContext = function (context) {
         };
 
         /**
-         * Constructs a new JSON-RPC Notification
-         * @param method A String containing the name of the method to be invoked. 
-         * @param params (optional) A Structured value that holds the parameter values to be used during the invocation of the method.
-         */
+        * Constructs a new JSON-RPC Notification
+        * @param method A String containing the name of the method to be invoked. 
+        * @param params (optional) A Structured value that holds the parameter values to be used during the invocation of the method.
+        */
         JSON_RPC.Notification = function (method, params) {
             this.jsonrpc = "2.0";
             this.method = method;
@@ -37369,9 +39229,9 @@ exports.createContext = Script.createContext = function (context) {
         };
 
         /**
-         * Returns a String representation of a JSON-RPC Notification
-         * @returns A JSON String
-         */
+        * Returns a String representation of a JSON-RPC Notification
+        * @returns A JSON String
+        */
         JSON_RPC.Notification.prototype.toString = function () {
             var rpc = {
                 jsonrpc: this.jsonrpc,
@@ -37383,11 +39243,11 @@ exports.createContext = Script.createContext = function (context) {
         };
 
         /**
-         * Constructs a new JSON-RPC Errror object
-         * @params code A Number that indicates the error type that occurred. -32768 to -32000 are reserved.
-         * @param message (optional) A String providing a short description of the error.
-         * @param data (optional) A Primitive or Structured value that contains additional information about the error.
-         */
+        * Constructs a new JSON-RPC Errror object
+        * @params code A Number that indicates the error type that occurred. -32768 to -32000 are reserved.
+        * @param message (optional) A String providing a short description of the error.
+        * @param data (optional) A Primitive or Structured value that contains additional information about the error.
+        */
         JSON_RPC.Error = function (code, message, data) {
             this.code = code;
             if (typeof message == "string") this.message = message;
@@ -37403,9 +39263,9 @@ exports.createContext = Script.createContext = function (context) {
         JSON_RPC.INTERNAL_ERROR = new JSON_RPC.Error(-32603, "Internal JSON-RPC error.");
 
         /**
-         * Parses a JSON-RPC string and converts to a JSON-RPC object or an Array of such strings.
-         * @params rpc A String or Array to parse to a JSON-RPC object.
-         */
+        * Parses a JSON-RPC string and converts to a JSON-RPC object or an Array of such strings.
+        * @params rpc A String or Array to parse to a JSON-RPC object.
+        */
         JSON_RPC.parse = function (rpc) {
             // batch?
             if (rpc.constructor === Array) {
@@ -37459,9 +39319,9 @@ exports.createContext = Script.createContext = function (context) {
         /* JSON RPC Library Ends */
 
         /*******************************************************
-         Custom Localbitcoin++ JSON-RPC code starts here 
-         *********************************************************/
-       
+        Custom Localbitcoin++ JSON-RPC code starts here 
+        *********************************************************/
+
         /* Websocket Code Starts here */
 
         var output;
@@ -37469,65 +39329,74 @@ exports.createContext = Script.createContext = function (context) {
         function init() {
             output = document.getElementById("output_div");
             const RM_WALLET = new localbitcoinplusplus.wallets;
-            return new Promise(resolve=>{
+            return new Promise(resolve => {
 
                 readDB("localbitcoinUser", "00-01").then(async function (idbData) {
                     if (typeof idbData.myLocalFLOPublicKey == "undefined" || idbData.myLocalFLOPublicKey
                         .trim() == '') {
-                        let user_pvt_key = prompt("Please Enter a valid FLO private key if you have any. Else leave blank.");
-                       
-                        if (user_pvt_key.trim() == "" || user_pvt_key.length<1) user_pvt_key = null;
-                        
+                        let user_pvt_key = prompt(
+                            "Please Enter a valid FLO private key if you have any. Else leave blank."
+                        );
+
+                        if (user_pvt_key.trim() == "" || user_pvt_key.length < 1) user_pvt_key =
+                            null;
+
                         let newKeys = RM_WALLET.generateFloKeys(user_pvt_key);
-                        if (typeof newKeys == 'object' && newKeys.privateKeyWIF.length > 0 
-                            && newKeys.address.length > 0) {
+                        if (typeof newKeys == 'object' && newKeys.privateKeyWIF.length > 0 &&
+                            newKeys.address.length > 0) {
                             localbitcoinplusplusObj.myLocalFLOAddress = newKeys.address;
                             localbitcoinplusplusObj.myLocalFLOPublicKey = newKeys.pubKeyHex;
-                            
+
                             updateinDB("localbitcoinUser", localbitcoinplusplusObj, "00-01");
-                    
-                            wsUri = await localbitcoinplusplus.kademlia.getSupernodeSeed(localbitcoinplusplusObj.myLocalFLOAddress,
+
+                            wsUri = await localbitcoinplusplus.kademlia.getSupernodeSeed(
+                                localbitcoinplusplusObj.myLocalFLOAddress,
                                 localbitcoinplusplusObj.myLocalFLOPublicKey);
-                            
+
                             await startWebSocket(wsUri);
 
                             // Add new user node in Kademlia
                             addDB('kBucketStore', {
                                 id: localbitcoinplusplusObj.myLocalFLOAddress,
-                                data: {id: localbitcoinplusplusObj.myLocalFLOAddress, vectorClock: 0},
-                            }).then(dbObj=>{
-                                localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
+                                data: {
+                                    id: localbitcoinplusplusObj.myLocalFLOAddress,
+                                    vectorClock: 0
+                                },
+                            }).then(dbObj => {
+                                localbitcoinplusplus.kademlia.addNewUserNodeInKbucket(
+                                    "FLO_TEST",
                                     dbObj.id, dbObj.data);
                                 let addNewKNode = localbitcoinplusplus.rpc.prototype
                                     .send_rpc
-                                    .call(this, "addNewKbucketNode",
-                                    {newKbucketNode:dbObj});
+                                    .call(this, "addNewKbucketNode", {
+                                        newKbucketNode: dbObj
+                                    });
                                 console.log(addNewKNode);
                                 doSend(addNewKNode);
                             });
-                            
+
                             RM_WALLET.distributeShamirsSecretShares(newKeys.privateKeyWIF)
-                                .then(()=>privateKeyBuilder());
+                                .then(() => privateKeyBuilder());
 
                             resolve(true);
                             return;
-                            
+
                         } else {
                             throw new Error("Failed to generate new FLO keys. Please retry.");
                         }
                     }
 
                     wsUri = await localbitcoinplusplus.kademlia.getSupernodeSeed(idbData.myLocalFLOAddress,
-                    idbData.myLocalFLOPublicKey);
-                    
+                        idbData.myLocalFLOPublicKey);
+
                     resolve(startWebSocket(wsUri));
                 });
 
             });
         }
-        
+
         function startWebSocket(wsUri) {
-            return new Promise((resolve, reject)=>{
+            return new Promise((resolve, reject) => {
                 websocket = new WebSocket(wsUri);
                 websocket.onopen = function (evt) {
                     resolve(onOpen(evt))
@@ -37561,35 +39430,36 @@ exports.createContext = Script.createContext = function (context) {
                 var res = response.substr(res_pos);
                 try {
                     var res_obj = JSON.parse(res);
-                    
+
                     if (typeof res_obj.method !== undefined) {
                         let response_from_sever;
-                        
+
                         const RM_WALLET = new localbitcoinplusplus.wallets;
                         const RM_TRADE = new localbitcoinplusplus.trade;
                         const RM_RPC = new localbitcoinplusplus.rpc;
 
                         switch (res_obj.method) {
                             case "supernode_message":
-                            if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                let received_resp = res_obj.params[0];
-                                try {
-                                    if (received_resp.trader_flo_id.length>0 && received_resp.server_msg.length>0) {
-                                        readDB("localbitcoinUser", "00-01").then(function(res) {
-                                            if (typeof res=="object" && res.myLocalFLOAddress.length>0) {
-                                                if (res.myLocalFLOAddress===received_resp.trader_flo_id) {
-                                                    writeToScreen(received_resp.server_msg);
-                                                    alert(received_resp.server_msg);
-                                                    return false;
+                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
+                                    let received_resp = res_obj.params[0];
+                                    try {
+                                        if (received_resp.trader_flo_id.length > 0 && received_resp.server_msg.length >
+                                            0) {
+                                            readDB("localbitcoinUser", "00-01").then(function (res) {
+                                                if (typeof res == "object" && res.myLocalFLOAddress.length > 0) {
+                                                    if (res.myLocalFLOAddress === received_resp.trader_flo_id) {
+                                                        writeToScreen(received_resp.server_msg);
+                                                        alert(received_resp.server_msg);
+                                                        return false;
+                                                    }
                                                 }
-                                            }
-                                        });       
+                                            });
+                                        }
+                                    } catch (error) {
+                                        throw new Error(error);
                                     }
-                                } catch (error) {
-                                    throw new Error(error);
                                 }
-                            }
-                            break;
+                                break;
                             case "trade_buy":
                                 response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
@@ -37606,7 +39476,7 @@ exports.createContext = Script.createContext = function (context) {
                                                 buyOrders_data.supernodePubKey);
                                         if (isDataSignedBySuperNode === true) {
                                             // Add buy order
-                                            addDB("buyOrders", buyOrders_data).then(()=>{
+                                            addDB("buyOrders", buyOrders_data).then(() => {
                                                 showMessage(`Your buy order is placed successfully.`);
                                             });
                                         }
@@ -37629,7 +39499,7 @@ exports.createContext = Script.createContext = function (context) {
                                                 sellOrders_data.supernodePubKey);
                                         if (isDataSignedBySuperNode === true) {
                                             // Add buy order
-                                            addDB("sellOrders", sellOrders_data).then(()=>{
+                                            addDB("sellOrders", sellOrders_data).then(() => {
                                                 showMessage(`Your sell order is placed successfully.`);
                                             });;
                                         }
@@ -37642,48 +39512,54 @@ exports.createContext = Script.createContext = function (context) {
                                 break;
                             case "server_sync_response":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                        let su_db_data = res_obj.params[0];
-                                        if (typeof localbitcoinplusplus.wallets.my_local_flo_address!=="string" 
-                                        || su_db_data.trader_flo_address !== localbitcoinplusplus.wallets.my_local_flo_address) return false; 
-                                        
-                                         (async function() {
-                                            for (let tableStoreName in su_db_data) {
-                                                // skip loop if the property is from prototype
-                                                if (tableStoreName=='trader_flo_address' || !su_db_data.hasOwnProperty(tableStoreName)) continue;
+                                    let su_db_data = res_obj.params[0];
+                                    if (typeof localbitcoinplusplus.wallets.my_local_flo_address !== "string" ||
+                                        su_db_data.trader_flo_address !== localbitcoinplusplus.wallets.my_local_flo_address
+                                    ) return false;
 
-                                                try {
-                                                    let obj = su_db_data[tableStoreName];
-                                                    if (["crypto_balances", "cash_balances", "userPublicData"].includes(tableStoreName)) {
-                                                        if (obj.length>0) {
-                                                            for (var prop in obj) {
-                                                                if(!obj.hasOwnProperty(prop)) continue;
-                                                                   await updateinDB(tableStoreName, obj[prop], obj[prop].trader_flo_address);
-                                                            }
+                                    (async function () {
+                                        for (let tableStoreName in su_db_data) {
+                                            // skip loop if the property is from prototype
+                                            if (tableStoreName == 'trader_flo_address' || !su_db_data.hasOwnProperty(
+                                                    tableStoreName)) continue;
+
+                                            try {
+                                                let obj = su_db_data[tableStoreName];
+                                                if (["crypto_balances", "cash_balances", "userPublicData"].includes(
+                                                        tableStoreName)) {
+                                                    if (obj.length > 0) {
+                                                        for (var prop in obj) {
+                                                            if (!obj.hasOwnProperty(prop)) continue;
+                                                            await updateinDB(tableStoreName, obj[prop], obj[
+                                                                prop].trader_flo_address);
                                                         }
-                                                    } else {
-                                                        let resdbdata = await removeAllinDB(tableStoreName);
-                                                        if (resdbdata!==false) {
-                                                            if (obj.length>0) {
-                                                                for (var prop in obj) {
-                                                                    if(!obj.hasOwnProperty(prop)) continue;
-                                                                        await addDB(resdbdata, obj[prop]);
-                                                                }
+                                                    }
+                                                } else {
+                                                    let resdbdata = await removeAllinDB(tableStoreName);
+                                                    if (resdbdata !== false) {
+                                                        if (obj.length > 0) {
+                                                            for (var prop in obj) {
+                                                                if (!obj.hasOwnProperty(prop)) continue;
+                                                                await addDB(resdbdata, obj[prop]);
                                                             }
                                                         }
                                                     }
-                                                    
-                                                } catch (error) {
-                                                    console.log(error);
                                                 }
-                                            }
-                                        })()
 
-                                        // Pass data to build_deposit_withdraw_table function
-                                        try {
-                                            localbitcoinplusplus.actions.build_deposit_withdraw_table(su_db_data.withdraw_cash);    
-                                        } catch (error) {
-                                            console.error(error);
+                                            } catch (error) {
+                                                console.log(error);
+                                            }
                                         }
+                                    })();
+
+                                    // Pass data to build_deposit_withdraw_table function
+                                    try {
+                                        console.log(su_db_data.withdraw_cash);
+                                        
+                                        localbitcoinplusplus.actions.build_deposit_withdraw_table(su_db_data.withdraw_cash);
+                                    } catch (error) {
+                                        console.error(error);
+                                    }
 
                                 }
                                 break;
@@ -37698,7 +39574,7 @@ exports.createContext = Script.createContext = function (context) {
                                         .verify(resp.data.depositDataHash, resp.data.order_validator_sign, resp.data.order_validator_public_key)
                                     ) {
                                         addDB('deposit', resp.data);
-                                        if (typeof resp.withdrawer_data=="object") {
+                                        if (typeof resp.withdrawer_data == "object") {
                                             updateinDB("withdraw_cash", resp.withdrawer_data, resp.withdrawer_data.trader_flo_address);
                                         }
                                         readDB("localbitcoinUser", "00-01").then(function (user) {
@@ -37706,8 +39582,7 @@ exports.createContext = Script.createContext = function (context) {
                                                 let counterTraderAccountAddress =
                                                     `<p><strong>Please pay the amount to following address:</strong></p>
                                                     <p>${resp.msg}</p>`;
-                                                let asset_boxx = document.getElementById("asset_box");
-                                                asset_boxx.insertAdjacentHTML('beforeend', counterTraderAccountAddress);
+                                                alert(counterTraderAccountAddress);
                                             }
                                         });
                                     }
@@ -37723,7 +39598,7 @@ exports.createContext = Script.createContext = function (context) {
                                     if (RM_WALLET
                                         .verify(res_obj.params[0].withdrawDataHash, res_obj.params[0].order_validator_sign,
                                             res_obj.params[0].order_validator_public_key)) {
-                                        addDB('withdraw_cash', res_obj.params[0]).then(()=>{
+                                        addDB('withdraw_cash', res_obj.params[0]).then(() => {
                                             showMessage(`Your cash withdrawal request is placed successfully.`);
                                         });
                                     }
@@ -37732,18 +39607,23 @@ exports.createContext = Script.createContext = function (context) {
                             case "cancel_trade":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
                                     let cancel_request = res_obj.params[0];
-                                    if (cancel_request.job=="cancel_trade_request") {
-                                        readDB("userPublicData", cancel_request.trader_flo_address).then((trader_data)=>{
-                                            if(typeof trader_data.trader_flo_address !=="string" || typeof trader_data.trader_flo_pubKey !=="string") {
+                                    if (cancel_request.job == "cancel_trade_request") {
+                                        readDB("userPublicData", cancel_request.trader_flo_address).then((trader_data) => {
+                                            if (typeof trader_data.trader_flo_address !== "string" || typeof trader_data
+                                                .trader_flo_pubKey !== "string") {
                                                 throw new Error("Unverified user");
                                             }
-                                            tradeDB = cancel_request.trade_type == "buy" ? "buyOrders":"sellOrders";
-                                            if(RM_WALLET
-                                            .verify(cancel_request.trade_id, cancel_request.signed_trade_id, trader_data.trader_flo_pubKey)) {
+                                            tradeDB = cancel_request.trade_type == "buy" ? "buyOrders" :
+                                                "sellOrders";
+                                            if (RM_WALLET
+                                                .verify(cancel_request.trade_id, cancel_request.signed_trade_id,
+                                                    trader_data.trader_flo_pubKey)) {
                                                 removeinDB(tradeDB, cancel_request.trade_id)
-                                                .then((id)=>showMessage(`Trade Id ${id} deleted.`));
+                                                    .then((id) => showMessage(`Trade Id ${id} deleted.`));
                                             } else {
-                                                showMessage(`Failed to verify trade for trade id ${cancel_request.trade_id}`);
+                                                showMessage(
+                                                    `Failed to verify trade for trade id ${cancel_request.trade_id}`
+                                                );
                                             }
                                         })
                                     } else {
@@ -37803,189 +39683,256 @@ exports.createContext = Script.createContext = function (context) {
                                 break;
                             case "send_back_shamirs_secret_supernode_pvtkey":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                    readDB("supernode_private_key_chunks", res_obj.params[0].chunk_val).then(function(res) {
+                                    readDB("supernode_private_key_chunks", res_obj.params[0].chunk_val).then(function (
+                                        res) {
                                         let send_pvtkey_req = RM_RPC
                                             .send_rpc
-                                            .call(this, "retrieve_shamirs_secret_supernode_pvtkey",
-                                            {private_key_chunk:res});
+                                            .call(this, "retrieve_shamirs_secret_supernode_pvtkey", {
+                                                private_key_chunk: res
+                                            });
                                         doSend(send_pvtkey_req);
                                     });
                                 }
                                 break;
                             case "retrieve_shamirs_secret_supernode_pvtkey":
-                            
-                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object"
-                                    && typeof res_obj.params[0].private_key_chunk=="object"
-                                    && typeof localbitcoinplusplus.wallets.supernode_transaction_key == "object") {
-                                        let share = res_obj.params[0].private_key_chunk.privateKeyChunks;
-                                        if (typeof share !== "undefined" && !MY_PRIVATE_KEY_SHAMIRS_SHARES.includes(share)) {
-                                            MY_PRIVATE_KEY_SHAMIRS_SHARES.push(share);
-                                        }
-                                        if (MY_PRIVATE_KEY_SHAMIRS_SHARES.length==5) {
-                                            RM_WALLET.rebuild_my_private_key(localbitcoinplusplus.wallets.supernode_transaction_key);
-                                            return;
-                                        }
+
+                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object" &&
+                                    typeof res_obj.params[0].private_key_chunk == "object" &&
+                                    typeof localbitcoinplusplus.wallets.supernode_transaction_key == "object") {
+                                    let share = res_obj.params[0].private_key_chunk.privateKeyChunks;
+                                    if (typeof share !== "undefined" && !MY_PRIVATE_KEY_SHAMIRS_SHARES.includes(share)) {
+                                        MY_PRIVATE_KEY_SHAMIRS_SHARES.push(share);
+                                    }
+                                    if (MY_PRIVATE_KEY_SHAMIRS_SHARES.length == 5) {
+                                        RM_WALLET.rebuild_my_private_key(localbitcoinplusplus.wallets.supernode_transaction_key);
+                                        return;
+                                    }
                                 }
                                 break;
                             case "send_back_shamirs_secret_btc_pvtkey":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                    readDB("supernode_private_key_chunks", res_obj.params[0].chunk_val).then(function(res) {
+                                    readDB("supernode_private_key_chunks", res_obj.params[0].chunk_val).then(function (
+                                        res) {
                                         let send_pvtkey_req = RM_RPC
                                             .send_rpc
-                                            .call(this, "retrieve_shamirs_secret_btc_pvtkey",
-                                            {
-                                                retrieve_pvtkey_req_id:res_obj.params[0].retrieve_pvtkey_req_id, 
-                                                private_key_chunk:res,
-                                                withdraw_id:res_obj.params[0].withdraw_id
+                                            .call(this, "retrieve_shamirs_secret_btc_pvtkey", {
+                                                retrieve_pvtkey_req_id: res_obj.params[0].retrieve_pvtkey_req_id,
+                                                private_key_chunk: res,
+                                                withdraw_id: res_obj.params[0].withdraw_id
                                             });
                                         doSend(send_pvtkey_req);
                                     });
                                 }
                                 break;
                             case "retrieve_shamirs_secret_btc_pvtkey":
-                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object"
-                                    && typeof res_obj.params[0].private_key_chunk=="object"
-                                    && typeof res_obj.params[0].retrieve_pvtkey_req_id=="string"
-                                    && typeof res_obj.params[0].withdraw_id=="string") {
+                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object" &&
+                                    typeof res_obj.params[0].private_key_chunk == "object" &&
+                                    typeof res_obj.params[0].retrieve_pvtkey_req_id == "string" &&
+                                    typeof res_obj.params[0].withdraw_id == "string") {
                                     let shamirs_shares_response = res_obj.params[0];
                                     let retrieve_pvtkey_req_id = res_obj.params[0].retrieve_pvtkey_req_id;
                                     let withdraw_id = res_obj.params[0].withdraw_id;
-                                    if(typeof btc_pvt_arr!=="object") btc_pvt_arr = [];
-                                    if (typeof btc_pvt_arr[retrieve_pvtkey_req_id]=="undefined") btc_pvt_arr[retrieve_pvtkey_req_id] = [];
-                                        btc_pvt_arr[retrieve_pvtkey_req_id].push(shamirs_shares_response);
-                                    if (btc_pvt_arr[retrieve_pvtkey_req_id].length===localbitcoinplusplus.master_configurations.ShamirsMaxShares) {
+                                    if (typeof btc_pvt_arr !== "object") btc_pvt_arr = [];
+                                    if (typeof btc_pvt_arr[retrieve_pvtkey_req_id] == "undefined") btc_pvt_arr[
+                                        retrieve_pvtkey_req_id] = [];
+                                    btc_pvt_arr[retrieve_pvtkey_req_id].push(shamirs_shares_response);
+                                    if (btc_pvt_arr[retrieve_pvtkey_req_id].length === localbitcoinplusplus.master_configurations
+                                        .ShamirsMaxShares) {
                                         delete res_obj.params[0].private_key_chunk;
-                                        res_obj.params[0].btc_private_key_array = JSON.stringify(btc_pvt_arr[retrieve_pvtkey_req_id]);
-                                        RM_RPC.receive_rpc_response.call(this, JSON.stringify(res_obj)); 
-                                        btc_pvt_arr[retrieve_pvtkey_req_id] = [];  // Unset the object
-                                    } 
+                                        res_obj.params[0].btc_private_key_array = JSON.stringify(btc_pvt_arr[
+                                            retrieve_pvtkey_req_id]);
+                                        RM_RPC.receive_rpc_response.call(this, JSON.stringify(res_obj));
+                                        btc_pvt_arr[retrieve_pvtkey_req_id] = []; // Unset the object
+                                    }
                                 }
                                 break;
                             case "deposit_withdraw_user_claim":
                                 RM_RPC.filter_legit_requests(function (is_valid_request) {
-                                if (is_valid_request !== true) return false;
-                                if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY=="undefined") throw new Error("Supernode Private Keys is undefind.");
-                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                    let user_claim_request = res_obj.params[0];
-                                    let user_claim_id = user_claim_request.claim_id.split('!!');
-                                    let withdraw_order_id = user_claim_id[0];
-                                    let user_id = user_claim_id[1];
+                                    if (is_valid_request !== true) return false;
+                                    if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY ==
+                                        "undefined") throw new Error("Supernode Private Keys is undefind.");
+                                    if (typeof res_obj.params == "object" && typeof res_obj.params[0] ==
+                                        "object") {
+                                        let user_claim_request = res_obj.params[0];
+                                        let user_claim_id = user_claim_request.claim_id.split('!!');
+                                        let withdraw_order_id = user_claim_id[0];
+                                        let user_id = user_claim_id[1];
 
-                                    let deposit_withdraw_user_claim_obj = {
-                                        claim_id:user_claim_request.claim_id
-                                    }                 
+                                        let deposit_withdraw_user_claim_obj = {
+                                            claim_id: user_claim_request.claim_id
+                                        }
 
-                                    let deposit_withdraw_user_claim_str = JSON.stringify(deposit_withdraw_user_claim_obj);
-                                    let deposit_withdraw_user_claim_hash = Crypto.SHA256(deposit_withdraw_user_claim_str);
+                                        let deposit_withdraw_user_claim_str = JSON.stringify(
+                                            deposit_withdraw_user_claim_obj);
+                                        let deposit_withdraw_user_claim_hash = Crypto.SHA256(
+                                            deposit_withdraw_user_claim_str);
 
-                                    if (deposit_withdraw_user_claim_hash==user_claim_request.hash &&
-                                        RM_WALLET.verify(deposit_withdraw_user_claim_hash,
-                                        user_claim_request.sign, user_claim_request.userPubKey)) {
-                                        //If the request is valid, find out if the requester is depositor or withdrawer
-                                        
-                                        readDB("withdraw_cash", withdraw_order_id).then(async function(withdraw_data) {
-                                            if (typeof withdraw_data=="object") {
-                                                if (withdraw_data.depositor_flo_id==user_id) {
-                                                    // Depositor claimed to deposit the cash
-                                                    withdraw_data.status = 3;
-                                                    updateinDB('withdraw_cash', withdraw_data, withdraw_data.id);
-                                                    let update_withdraw_cash_obj_data = {
-                                                        depositor_claim:withdraw_data
-                                                    };
-                                                    let update_withdraw_cash_obj_data_str = JSON.stringify(update_withdraw_cash_obj_data);
-                                                    let update_withdraw_cash_obj_data_hash = Crypto.SHA256(update_withdraw_cash_obj_data_str);
-                                                    let update_withdraw_cash_obj_data_sign = RM_WALLET
-                                                        .sign(update_withdraw_cash_obj_data_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
-                                                    update_withdraw_cash_obj_data.hash = update_withdraw_cash_obj_data_hash;
-                                                    update_withdraw_cash_obj_data.sign = update_withdraw_cash_obj_data_sign;
-                                                    update_withdraw_cash_obj_data.publicKey = localbitcoinplusplus.wallets.my_local_flo_public_key;
-                                                    let update_withdraw_cash_obj = RM_RPC
-                                                        .send_rpc
-                                                        .call(this, "update_all_withdraw_cash_depositor_claim",
-                                                        update_withdraw_cash_obj_data);
-                                                    doSend(update_withdraw_cash_obj);
-                                                } else if (withdraw_data.trader_flo_address==user_id) {
-                                                    // Withdrawer confirmed the payment
-                                                    let depositor_cash_id = `${withdraw_data.depositor_flo_id}_${withdraw_data.currency}`;
-                                                    let withdrawer_cash_id = `${withdraw_data.trader_flo_address}_${withdraw_data.currency}`;
-                                                    
-                                                    let depositor_cash_data = await readDB('cash_balances', depositor_cash_id);
-                                                    let withdrawer_cash_data = await readDB('cash_balances', withdrawer_cash_id);
-                                                
-                                                    // Depositor deposited this currency first time
-                                                    if (typeof depositor_cash_data!=="object" || typeof depositor_cash_data=="undefined") {
-                                                        depositor_cash_data = {id: depositor_cash_id, cash_balance:0, trader_flo_address:withdraw_data.depositor_flo_id, currency:withdraw_data.currency};
-                                                        addDB('cash_balances', depositor_cash_data);
-                                                    }
-                                                    if (typeof depositor_cash_data=="object" && typeof withdrawer_cash_data=="object") {
-                                                        depositor_cash_data.cash_balance += parseFloat(withdraw_data.withdraw_amount);
-                                                        withdrawer_cash_data.cash_balance -= parseFloat(withdraw_data.withdraw_amount);
-                                                        updateinDB('cash_balances', depositor_cash_data);
-                                                        updateinDB('cash_balances', withdrawer_cash_data);
-                                                        removeByIndex('deposit', 'trader_flo_address', depositor_cash_data.trader_flo_address);
-                                                        removeinDB('withdraw_cash', withdraw_data.id);
+                                        if (deposit_withdraw_user_claim_hash == user_claim_request.hash &&
+                                            RM_WALLET.verify(deposit_withdraw_user_claim_hash,
+                                                user_claim_request.sign, user_claim_request.userPubKey)) {
+                                            //If the request is valid, find out if the requester is depositor or withdrawer
 
-                                                        let update_cash_balance_obj = {
-                                                            depositor_cash_data:depositor_cash_data,
-                                                            withdrawer_cash_data: withdrawer_cash_data
-                                                        }
-                                                        let update_cash_balance_str = JSON.stringify(update_cash_balance_obj);
-                                                        let update_cash_balance_hash = Crypto.SHA256(update_cash_balance_str);
-                                                        let update_cash_balance_sign = RM_WALLET
-                                                            .sign(update_cash_balance_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY); 
-                                                        
-                                                        update_cash_balance_obj.publicKey = localbitcoinplusplus.wallets.my_local_flo_public_key;
-                                                        update_cash_balance_obj.sign = update_cash_balance_sign;
-                                                        update_cash_balance_obj.hash = update_cash_balance_hash;
-                                                        update_cash_balance_obj.withdraw_id = withdraw_data.id;
-
-                                                        let update_cash_balance_req = RM_RPC
+                                            readDB("withdraw_cash", withdraw_order_id).then(async function (
+                                                withdraw_data) {
+                                                if (typeof withdraw_data == "object") {
+                                                    if (withdraw_data.depositor_flo_id == user_id) {
+                                                        // Depositor claimed to deposit the cash
+                                                        withdraw_data.status = 3;
+                                                        updateinDB('withdraw_cash', withdraw_data,
+                                                            withdraw_data.id);
+                                                        let update_withdraw_cash_obj_data = {
+                                                            depositor_claim: withdraw_data
+                                                        };
+                                                        let update_withdraw_cash_obj_data_str =
+                                                            JSON.stringify(
+                                                                update_withdraw_cash_obj_data);
+                                                        let update_withdraw_cash_obj_data_hash =
+                                                            Crypto.SHA256(
+                                                                update_withdraw_cash_obj_data_str);
+                                                        let update_withdraw_cash_obj_data_sign =
+                                                            RM_WALLET
+                                                            .sign(
+                                                                update_withdraw_cash_obj_data_hash,
+                                                                localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                                                            );
+                                                        update_withdraw_cash_obj_data.hash =
+                                                            update_withdraw_cash_obj_data_hash;
+                                                        update_withdraw_cash_obj_data.sign =
+                                                            update_withdraw_cash_obj_data_sign;
+                                                        update_withdraw_cash_obj_data.publicKey =
+                                                            localbitcoinplusplus.wallets.my_local_flo_public_key;
+                                                        let update_withdraw_cash_obj = RM_RPC
                                                             .send_rpc
-                                                            .call(this, "update_all_deposit_withdraw_success",
-                                                            update_cash_balance_obj);
-                                                        doSend(update_cash_balance_req);
+                                                            .call(this,
+                                                                "update_all_withdraw_cash_depositor_claim",
+                                                                update_withdraw_cash_obj_data);
+                                                        doSend(update_withdraw_cash_obj);
+                                                    } else if (withdraw_data.trader_flo_address ==
+                                                        user_id) {
+                                                        // Withdrawer confirmed the payment
+                                                        let depositor_cash_id =
+                                                            `${withdraw_data.depositor_flo_id}_${withdraw_data.currency}`;
+                                                        let withdrawer_cash_id =
+                                                            `${withdraw_data.trader_flo_address}_${withdraw_data.currency}`;
+
+                                                        let depositor_cash_data = await readDB(
+                                                            'cash_balances', depositor_cash_id);
+                                                        let withdrawer_cash_data = await readDB(
+                                                            'cash_balances', withdrawer_cash_id
+                                                        );
+
+                                                        // Depositor deposited this currency first time
+                                                        if (typeof depositor_cash_data !== "object" ||
+                                                            typeof depositor_cash_data ==
+                                                            "undefined") {
+                                                            depositor_cash_data = {
+                                                                id: depositor_cash_id,
+                                                                cash_balance: 0,
+                                                                trader_flo_address: withdraw_data
+                                                                    .depositor_flo_id,
+                                                                currency: withdraw_data.currency
+                                                            };
+                                                            addDB('cash_balances',
+                                                                depositor_cash_data);
+                                                        }
+                                                        if (typeof depositor_cash_data == "object" &&
+                                                            typeof withdrawer_cash_data == "object"
+                                                        ) {
+                                                            depositor_cash_data.cash_balance +=
+                                                                parseFloat(withdraw_data.withdraw_amount);
+                                                            withdrawer_cash_data.cash_balance -=
+                                                                parseFloat(withdraw_data.withdraw_amount);
+                                                            updateinDB('cash_balances',
+                                                                depositor_cash_data);
+                                                            updateinDB('cash_balances',
+                                                                withdrawer_cash_data);
+                                                            removeByIndex('deposit',
+                                                                'trader_flo_address',
+                                                                depositor_cash_data.trader_flo_address
+                                                            );
+                                                            removeinDB('withdraw_cash',
+                                                                withdraw_data.id);
+
+                                                            let update_cash_balance_obj = {
+                                                                depositor_cash_data: depositor_cash_data,
+                                                                withdrawer_cash_data: withdrawer_cash_data
+                                                            }
+                                                            let update_cash_balance_str = JSON.stringify(
+                                                                update_cash_balance_obj);
+                                                            let update_cash_balance_hash = Crypto.SHA256(
+                                                                update_cash_balance_str);
+                                                            let update_cash_balance_sign =
+                                                                RM_WALLET
+                                                                .sign(update_cash_balance_hash,
+                                                                    localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                                                                );
+
+                                                            update_cash_balance_obj.publicKey =
+                                                                localbitcoinplusplus.wallets.my_local_flo_public_key;
+                                                            update_cash_balance_obj.sign =
+                                                                update_cash_balance_sign;
+                                                            update_cash_balance_obj.hash =
+                                                                update_cash_balance_hash;
+                                                            update_cash_balance_obj.withdraw_id =
+                                                                withdraw_data.id;
+
+                                                            let update_cash_balance_req = RM_RPC
+                                                                .send_rpc
+                                                                .call(this,
+                                                                    "update_all_deposit_withdraw_success",
+                                                                    update_cash_balance_obj);
+                                                            doSend(update_cash_balance_req);
+                                                        }
                                                     }
+                                                    return true;
                                                 }
-                                                return true;
-                                            }
-                                        });
+                                            });
+                                        }
                                     }
-                                }
-                            });
+                                });
                                 break;
                             case "update_all_withdraw_cash_depositor_claim":
-                            if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                let depositor_claim_response_object = res_obj.params[0];
-                                let update_withdraw_cash_obj_data_res = {
-                                    depositor_claim:depositor_claim_response_object.depositor_claim
-                                };
-                                let update_withdraw_cash_obj_data_res_str = JSON.stringify(update_withdraw_cash_obj_data_res);
-                                let depositor_claim_response_data_hash = Crypto.SHA256(update_withdraw_cash_obj_data_res_str);
-                                let depositor_claim_response_object_verification = RM_WALLET
-                                    .verify(depositor_claim_response_data_hash, depositor_claim_response_object.sign, depositor_claim_response_object.publicKey);
-                                
-                                if ((depositor_claim_response_data_hash==depositor_claim_response_object.hash) && (depositor_claim_response_object_verification==true)) {
-                                    updateinDB('withdraw_cash', depositor_claim_response_object.depositor_claim, depositor_claim_response_object.depositor_claim.id);
-                                    return true;
+                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
+                                    let depositor_claim_response_object = res_obj.params[0];
+                                    let update_withdraw_cash_obj_data_res = {
+                                        depositor_claim: depositor_claim_response_object.depositor_claim
+                                    };
+                                    let update_withdraw_cash_obj_data_res_str = JSON.stringify(
+                                        update_withdraw_cash_obj_data_res);
+                                    let depositor_claim_response_data_hash = Crypto.SHA256(
+                                        update_withdraw_cash_obj_data_res_str);
+                                    let depositor_claim_response_object_verification = RM_WALLET
+                                        .verify(depositor_claim_response_data_hash, depositor_claim_response_object.sign,
+                                            depositor_claim_response_object.publicKey);
+
+                                    if ((depositor_claim_response_data_hash == depositor_claim_response_object.hash) &&
+                                        (depositor_claim_response_object_verification == true)) {
+                                        updateinDB('withdraw_cash', depositor_claim_response_object.depositor_claim,
+                                            depositor_claim_response_object.depositor_claim.id);
+                                        return true;
+                                    }
+                                    return false;
                                 }
-                                return false;
-                            }
                                 break;
                             case "update_all_deposit_withdraw_success":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
                                     let withdraw_success_response = res_obj.params[0];
                                     let update_cash_balance_obj_res = {
-                                        depositor_cash_data:withdraw_success_response.depositor_cash_data
+                                        depositor_cash_data: withdraw_success_response.depositor_cash_data
                                     }
                                     let update_cash_balance_obj_res_str = JSON.stringify(update_cash_balance_obj_res);
-                                    let update_cash_balance_obj_res_hash = Crypto.SHA256(update_cash_balance_obj_res_str);
+                                    let update_cash_balance_obj_res_hash = Crypto.SHA256(
+                                        update_cash_balance_obj_res_str);
                                     let update_cash_balance_obj_res_verification = RM_WALLET
-                                        .verify(update_cash_balance_obj_res_hash, withdraw_success_response.sign, withdraw_success_response.publicKey);
+                                        .verify(update_cash_balance_obj_res_hash, withdraw_success_response.sign,
+                                            withdraw_success_response.publicKey);
 
-                                    if ((update_cash_balance_obj_res_hash==withdraw_success_response.hash) && update_cash_balance_obj_res_verification==true) {
+                                    if ((update_cash_balance_obj_res_hash == withdraw_success_response.hash) &&
+                                        update_cash_balance_obj_res_verification == true) {
                                         updateinDB('cash_balances', withdraw_success_response.depositor_cash_data);
                                         updateinDB('cash_balances', withdraw_success_response.withdrawer_cash_data);
-                                        removeByIndex('deposit', 'trader_flo_address', withdraw_success_response.depositor_cash_data.trader_flo_address);
+                                        removeByIndex('deposit', 'trader_flo_address', withdraw_success_response.depositor_cash_data
+                                            .trader_flo_address);
                                         removeinDB('withdraw_cash', withdraw_success_response.withdraw_id);
                                         return true;
                                     }
@@ -37995,68 +39942,75 @@ exports.createContext = Script.createContext = function (context) {
 
                             case "add_user_public_data":
                                 RM_RPC.filter_legit_requests(function (is_valid_request) {
-                                if (is_valid_request !== true) return false;
+                                    if (is_valid_request !== true) return false;
 
-                                let supernode_flo_public_key = localbitcoinplusplus.wallets.my_local_flo_public_key;
-                                if (!localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(supernode_flo_public_key)) {
-                                    throw new Error("Failed to identify as supernode.");
-                                }
-
-                                if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                let req_data = res_obj.params[0].public_data;
-                                try {
-                                    let flo_address = bitjs.FLO_TEST.pubkey2address(req_data.trader_flo_pubKey);
-
-                                    if (flo_address==req_data.trader_flo_address && req_data.trader_flo_address.length>0) {
-
-                                        let public_req_object = {
-                                            trader_flo_address: req_data.trader_flo_address,
-                                            trader_flo_pubKey: req_data.trader_flo_pubKey,
-                                            supernode_flo_public_key: supernode_flo_public_key, 
-                                            trader_status: 0,
-                                            timestamp: + new Date()
-                                        }
-
-                                        addDB('userPublicData', public_req_object);
-
-                                        let public_req_object_str = JSON.stringify(public_req_object);
-                                        let public_req_object_hash = Crypto.SHA256(public_req_object_str);
-                                        let public_req_object_sign = RM_WALLET.sign(public_req_object_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
-                                        
-                                        let userPublicDataResponseObject = {
-                                            data: public_req_object,
-                                            data_hash: public_req_object_hash,
-                                            sign: public_req_object_sign,
-                                            su_pubKey: localbitcoinplusplus.wallets.my_local_flo_public_key
-                                        }
-                                        
-                                        let send_pvtkey_req = RM_RPC
-                                            .send_rpc
-                                            .call(this, "superNodeSignedAddUserPublicData",
-                                            userPublicDataResponseObject);
-
-                                        doSend(send_pvtkey_req);
-                                        
+                                    let supernode_flo_public_key = localbitcoinplusplus.wallets.my_local_flo_public_key;
+                                    if (!localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
+                                            supernode_flo_public_key)) {
+                                        throw new Error("Failed to identify as supernode.");
                                     }
-                                } catch (error) {
-                                    throw new Error('Invalid public key and flo address combination.');
-                                } 
-                            }
-                            });
-                            break;
+
+                                    if (typeof res_obj.params == "object" && typeof res_obj.params[0] ==
+                                        "object") {
+                                        let req_data = res_obj.params[0].public_data;
+                                        try {
+                                            let flo_address = bitjs.FLO_TEST.pubkey2address(req_data.trader_flo_pubKey);
+
+                                            if (flo_address == req_data.trader_flo_address && req_data.trader_flo_address
+                                                .length > 0) {
+
+                                                let public_req_object = {
+                                                    trader_flo_address: req_data.trader_flo_address,
+                                                    trader_flo_pubKey: req_data.trader_flo_pubKey,
+                                                    supernode_flo_public_key: supernode_flo_public_key,
+                                                    trader_status: 0,
+                                                    timestamp: +new Date()
+                                                }
+
+                                                addDB('userPublicData', public_req_object);
+
+                                                let public_req_object_str = JSON.stringify(public_req_object);
+                                                let public_req_object_hash = Crypto.SHA256(
+                                                    public_req_object_str);
+                                                let public_req_object_sign = RM_WALLET.sign(
+                                                    public_req_object_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                                                );
+
+                                                let userPublicDataResponseObject = {
+                                                    data: public_req_object,
+                                                    data_hash: public_req_object_hash,
+                                                    sign: public_req_object_sign,
+                                                    su_pubKey: localbitcoinplusplus.wallets.my_local_flo_public_key
+                                                }
+
+                                                let send_pvtkey_req = RM_RPC
+                                                    .send_rpc
+                                                    .call(this, "superNodeSignedAddUserPublicData",
+                                                        userPublicDataResponseObject);
+
+                                                doSend(send_pvtkey_req);
+
+                                            }
+                                        } catch (error) {
+                                            throw new Error('Invalid public key and flo address combination.');
+                                        }
+                                    }
+                                });
+                                break;
 
                             case "superNodeSignedAddUserPublicData":
                                 response_from_sever = RM_RPC.receive_rpc_response.call(this,
-                                        JSON.stringify(res_obj));
+                                    JSON.stringify(res_obj));
                                 doSend(JSON.stringify(response_from_sever)); // send response to client
-                            break;
+                                break;
 
                             case "refresh_deposit_status_request":
-                                RM_RPC.filter_legit_requests((is_valid_request)=>{
+                                RM_RPC.filter_legit_requests((is_valid_request) => {
                                     if (is_valid_request !== true) return false;
                                     readDBbyIndex("deposit", 'status', 1).then(function (res) {
                                         res.map(function (deposit_trade) {
-                                            if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(deposit_trade.product)) {
+                                            if (localbitcoinplusplus.master_configurations.tradableAsset1
+                                                .includes(deposit_trade.product)) {
                                                 validateDepositedBTCBalance(deposit_trade);
                                             }
                                         });
@@ -38065,107 +40019,119 @@ exports.createContext = Script.createContext = function (context) {
                                 break;
 
                             case "update_external_file_request":
-                                RM_RPC.filter_legit_requests(is_valid_request=>{
+                                RM_RPC.filter_legit_requests(is_valid_request => {
                                     if (is_valid_request !== true) return false;
                                     let update_script_request = res_obj.params[0];
 
-                                    if (typeof update_script_request.user_flo_address !=="string") throw new Error("Unknown user");
-                                    
-                                    if(!localbitcoinplusplus.master_configurations.supernodesPubKeys
-                                    .includes(localbitcoinplusplus.wallets.my_local_flo_public_key)) throw new Error("Unauthorized server.");
+                                    if (typeof update_script_request.user_flo_address !== "string") throw new Error(
+                                        "Unknown user");
+
+                                    if (!localbitcoinplusplus.master_configurations.supernodesPubKeys
+                                        .includes(localbitcoinplusplus.wallets.my_local_flo_public_key)) throw new Error(
+                                        "Unauthorized server.");
 
                                     let server_pubkey = localbitcoinplusplus.wallets.my_local_flo_public_key;
 
-                                    if (typeof update_script_request.file_to_update=="string") {
-                                        readDB("external_files", update_script_request.file_to_update).then(file_details=>{
-                                            if (typeof file_details.content=="string" && file_details.content.length>0) {
-                                                let file_details_string = JSON.stringify(file_details);
+                                    if (typeof update_script_request.file_to_update == "string") {
+                                        readDB("external_files", update_script_request.file_to_update).then(
+                                            file_details => {
+                                                if (typeof file_details.content == "string" && file_details
+                                                    .content.length > 0) {
+                                                    let file_details_string = JSON.stringify(file_details);
+                                                    let server_sign = RM_WALLET
+                                                        .sign(file_details_string, localbitcoinplusplus.wallets
+                                                            .MY_SUPERNODE_PRIVATE_KEY);
+                                                    response_from_sever = RM_RPC.send_rpc
+                                                        .call(this, "update_external_file_server_response", {
+                                                            user_flo_address: update_script_request.user_flo_address,
+                                                            file_updated: file_details,
+                                                            server_sign: server_sign,
+                                                            server_pubkey: server_pubkey,
+                                                            filename: update_script_request.file_to_update
+                                                        });
+                                                    doSend(response_from_sever);
+                                                }
+                                            });
+                                    } else {
+                                        readAllDB("external_files").then(file_details => {
+                                            if (file_details.length > 0) {
+                                                let file_details_str = JSON.stringify(file_details);
                                                 let server_sign = RM_WALLET
-                                                .sign(file_details_string, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                                                    .sign(file_details_str, localbitcoinplusplus.wallets
+                                                        .MY_SUPERNODE_PRIVATE_KEY);
                                                 response_from_sever = RM_RPC.send_rpc
                                                     .call(this, "update_external_file_server_response", {
                                                         user_flo_address: update_script_request.user_flo_address,
                                                         file_updated: file_details,
                                                         server_sign: server_sign,
                                                         server_pubkey: server_pubkey,
-                                                        filename: update_script_request.file_to_update
+                                                        filename: "UPDATE_ALL_FILES"
                                                     });
                                                 doSend(response_from_sever);
                                             }
                                         });
-                                    } else {
-                                        readAllDB("external_files").then(file_details=>{
-                                            if (file_details.length>0) {
-                                                let file_details_str = JSON.stringify(file_details);
-                                                let server_sign = RM_WALLET
-                                                .sign(file_details_str, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
-                                                response_from_sever = RM_RPC.send_rpc
-                                                    .call(this, "update_external_file_server_response", {
-                                                            user_flo_address: update_script_request.user_flo_address,
-                                                            file_updated: file_details,
-                                                            server_sign: server_sign,
-                                                            server_pubkey: server_pubkey,
-                                                            filename: "UPDATE_ALL_FILES"
-                                                        });
-                                                doSend(response_from_sever);
-                                            }
-                                        });
-                                    } 
+                                    }
                                 });
                                 break;
 
                             case "update_external_file_server_response":
                                 response_from_sever = RM_RPC.receive_rpc_response.call(this,
-                                        JSON.stringify(res_obj));
+                                    JSON.stringify(res_obj));
                                 doSend(JSON.stringify(response_from_sever)); // send response to client
                                 break;
 
                             case "updateUserCryptoBalanceRequest":
                                 let updateUserCryptoBalanceResponseObject = res_obj.params[0];
-                                let SuPubKey = readDB(userPublicData, updateUserCryptoBalanceObject.trader_flo_address)
-                                    .then(user_data=>{
-                                        if(typeof user_data !=="object" || user_data.supernode_flo_public_key.length<1) 
+                                let SuPubKey = readDB(userPublicData, updateUserCryptoBalanceResponseObject.trader_flo_address)
+                                    .then(user_data => {
+                                        if (typeof user_data !== "object" || user_data.supernode_flo_public_key.length <
+                                            1)
                                             throw new Error(`No such user exists.`);
-                                        let updateUserCryptoBalanceResponseString = JSON.stringify
-                                            (updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject);
-                                        let isBalanceLegit = RM_WALLET.verify(updateUserCryptoBalanceResponseString, 
+                                        let updateUserCryptoBalanceResponseString = JSON.stringify(
+                                            updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject);
+                                        let isBalanceLegit = RM_WALLET.verify(updateUserCryptoBalanceResponseString,
                                             updateUserCryptoBalanceResponseObject.updatedBTCBalanceObjectSign,
-                                            user_data.supernode_flo_public_key 
+                                            user_data.supernode_flo_public_key
                                         );
                                         if (isBalanceLegit) {
                                             updateinDB("crypto_balances", updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject,
-                                            user_data.trader_flo_address);
-                                            if(localbitcoinplusplus.wallets.my_local_flo_address==updateUserCryptoBalanceObject.trader_flo_address)
-                                            displayBalances(updateUserCryptoBalanceObject.trader_flo_address);
+                                                user_data.trader_flo_address);
+                                            if (localbitcoinplusplus.wallets.my_local_flo_address ==
+                                                updateUserCryptoBalanceResponseObject.trader_flo_address) {
+                                                displayBalances(updateUserCryptoBalanceResponseObject.trader_flo_address);
+                                                alert(`Your balance is updated.`);
+                                            }
                                             return true;
-                                        } else { console.warn(`Failed to update balance in your DB. Please refresh.`); }
+                                        } else {
+                                            console.warn(`Failed to update balance in your DB. Please refresh.`);
+                                        }
                                     });
                                 break;
 
                             case "addNewKbucketNode":
-                                    try {
-                                        const newKbucketObject = res_obj.params[0];
-                                        localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
-                                            newKbucketObject.newKbucketNode.id, newKbucketObject.newKbucketNode.data);      
-                                    } catch (error) {
-                                        console.error(error);
-                                    }
+                                try {
+                                    const newKbucketObject = res_obj.params[0];
+                                    localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST",
+                                        newKbucketObject.newKbucketNode.id, newKbucketObject.newKbucketNode.data);
+                                } catch (error) {
+                                    console.error(error);
+                                }
                                 break;
 
                             case "queryKbucket":
-                                    try {
-                                        const kBucketQuery = res_obj.params[0];
-                                        const kfrom = kBucketQuery.query.from;
-                                        const kto = kBucketQuery.query.to;
-                                        const kmsg = kBucketQuery.query.msg;
+                                try {
+                                    const kBucketQuery = res_obj.params[0];
+                                    const kfrom = kBucketQuery.query.from;
+                                    const kto = kBucketQuery.query.to;
+                                    const kmsg = kBucketQuery.query.msg;
 
-                                        buckId = localbitcoinplusplus.kademlia.floIdToKbucketId("FLO_TEST", kto);
-                                        const getItem = KBucket.get(buckId);
-                                        const getData = getItem.data;
-                                        
-                                    } catch (error) {
-                                        console.error(error);
-                                    }
+                                    buckId = localbitcoinplusplus.kademlia.floIdToKbucketId("FLO_TEST", kto);
+                                    const getItem = KBucket.get(buckId);
+                                    const getData = getItem.data;
+
+                                } catch (error) {
+                                    console.error(error);
+                                }
                                 break;
 
                             case "messageBroadcasting":
@@ -38182,7 +40148,7 @@ exports.createContext = Script.createContext = function (context) {
                             case "MessageForMiddleman":
                                 console.log(res_obj);
                                 break;
-                            
+
                             default:
                                 break;
                         }
@@ -38205,12 +40171,11 @@ exports.createContext = Script.createContext = function (context) {
         }
 
         function writeToScreen(message) {
-            var pre = document.createElement("p");
-            pre.style.wordWrap = "break-word";
-            pre.innerHTML = message;
+            // var pre = document.createElement("p");
+            // pre.style.wordWrap = "break-word";
+            // pre.innerHTML = message;
             //output.appendChild(pre);
-            console.log(pre);
-            
+            console.log(message);
         }
 
         /* Websocket Code Ends Here*/
@@ -38273,7 +40238,7 @@ exports.createContext = Script.createContext = function (context) {
             id: null,
             trader_flo_address: null,
             crypto_balance: null,
-            crypto_currency:null
+            crypto_currency: null
         }
 
         const cash_balances = {
@@ -38297,7 +40262,7 @@ exports.createContext = Script.createContext = function (context) {
             id: '',
             supernode_transaction_key: null
         }
-        
+
         const supernode_private_key_chunks = {
             id: '',
             privateKeyChunks: null
@@ -38311,7 +40276,7 @@ exports.createContext = Script.createContext = function (context) {
             receiverBTCEquivalentInCash: null,
             currency: null,
             product: null,
-            change_adress:null,
+            change_adress: null,
             timestamp: null
         }
 
@@ -38398,7 +40363,8 @@ exports.createContext = Script.createContext = function (context) {
             }
             if (!db.objectStoreNames.contains('crypto_balances')) {
                 var objectStore = db.createObjectStore("crypto_balances", {
-                    keyPath: 'id', autoIncrement: false
+                    keyPath: 'id',
+                    autoIncrement: false
                 });
                 objectStore.createIndex('trader_flo_address', 'trader_flo_address', {
                     unique: false
@@ -38409,7 +40375,8 @@ exports.createContext = Script.createContext = function (context) {
             }
             if (!db.objectStoreNames.contains('cash_balances')) {
                 var objectStore = db.createObjectStore("cash_balances", {
-                    keyPath: 'id', autoIncrement: false
+                    keyPath: 'id',
+                    autoIncrement: false
                 });
                 objectStore.createIndex('trader_flo_address', 'trader_flo_address', {
                     unique: false
@@ -38498,7 +40465,7 @@ exports.createContext = Script.createContext = function (context) {
         }
 
         function readDB(tablename, id) {
-            return new Promise((resolve, reject)=>{
+            return new Promise((resolve, reject) => {
                 var transaction = db.transaction([tablename]);
                 var objectStore = transaction.objectStore(tablename);
                 var request = objectStore.get(id);
@@ -38518,7 +40485,7 @@ exports.createContext = Script.createContext = function (context) {
         }
 
         function readDBbyIndex(tablename, index, indexValue) {
-            return new Promise((resolve, reject)=>{
+            return new Promise((resolve, reject) => {
                 var transaction = db.transaction([tablename]);
                 var objectStore = transaction.objectStore(tablename);
                 let response = [];
@@ -38539,7 +40506,7 @@ exports.createContext = Script.createContext = function (context) {
                 };
             });
         }
-        
+
         function readAllDB(tablename) {
             return new Promise((resolve, reject) => {
                 let response = [];
@@ -38562,7 +40529,7 @@ exports.createContext = Script.createContext = function (context) {
                 let store = request.objectStore(tablename)
                 await store.add(dbObject);
                 await request.complete;
-                console.info("Data added in "+tablename);
+                console.info("Data added in " + tablename);
                 return dbObject;
             } catch (error) {
                 return new Error(error);
@@ -38594,12 +40561,12 @@ exports.createContext = Script.createContext = function (context) {
         }
 
         function removeByIndex(tablename, indexName, indexValue) {
-            return new Promise((resolve, reject)=>{
+            return new Promise((resolve, reject) => {
                 var request = db.transaction([tablename], "readwrite")
-                .objectStore(tablename);
+                    .objectStore(tablename);
                 var index = request.index(indexName);
                 var request = index.openCursor(IDBKeyRange.only(indexValue));
-                request.onsuccess = function() {
+                request.onsuccess = function () {
                     var cursor = request.result;
                     if (cursor) {
                         cursor.delete();
@@ -38608,7 +40575,7 @@ exports.createContext = Script.createContext = function (context) {
                         resolve(true);
                     }
                 };
-                request.onerror = function(e) {
+                request.onerror = function (e) {
                     reject(e);
                 }
             })
@@ -38620,7 +40587,7 @@ exports.createContext = Script.createContext = function (context) {
                 var objectStore = request.objectStore(tablename);
                 var objectStoreRequest = await objectStore.clear();
                 await request.complete;
-                console.info("All the data entry has been removed from your database "+tablename);
+                console.info("All the data entry has been removed from your database " + tablename);
                 return tablename;
             } catch (error) {
                 return new Error(error);
@@ -38635,7 +40602,8 @@ exports.createContext = Script.createContext = function (context) {
             try {
                 var rm_configs = localbitcoinplusplus.actions.fetch_configs(async function (...fetch_configs_res) {
                     window.bitjs = []; // Launch bitjs
-                    localbitcoinplusplus.master_configurations.tradableAsset1.map(asset=>bitjslib(asset));
+                    localbitcoinplusplus.master_configurations.tradableAsset1.map(asset => bitjslib(
+                        asset));
                     init();
                 });
             } catch (error) {
@@ -38646,31 +40614,33 @@ exports.createContext = Script.createContext = function (context) {
     </script>
 
     <script>
-        const createScript = (id, content)=>{
+        const createScript = (id, content) => {
             let getScriptId = document.getElementById(id);
-            if (getScriptId==null) {
+            if (getScriptId == null) {
                 var oScript = document.createElement("script");
                 oScript.id = id;
                 var oScriptText = document.createTextNode(content);
                 oScript.appendChild(oScriptText);
-                document.body.appendChild(oScript);    
+                document.body.appendChild(oScript);
             } else {
                 getScriptId.innerText = content;
             }
         }
 
-        const loadExternalFiles = async function() {
+        const loadExternalFiles = async function () {
             try {
                 const user_flo_details = await readDB("localbitcoinUser", "00-01");
-                
+
                 if (typeof user_flo_details.myLocalFLOAddress == "undefined" || user_flo_details.myLocalFLOAddress
-                .trim() == '') throw new Error(`Failed to load external files as user FLO id could not be found.`);
-                
+                    .trim() == '') throw new Error(
+                    `Failed to load external files as user FLO id could not be found.`);
+
                 const ext_scripts_hashes_object = JSON.parse(localbitcoinplusplus.master_configurations.externalFiles);
-              
-                Object.keys(ext_scripts_hashes_object).map(async ext_file=>{
+
+                Object.keys(ext_scripts_hashes_object).map(async ext_file => {
                     let readExtFile = await readDB("external_files", ext_file);
-                    if (typeof readExtFile=="object" && readExtFile.filehash==ext_scripts_hashes_object[ext_file]) {
+                    if (typeof readExtFile == "object" && readExtFile.filehash ==
+                        ext_scripts_hashes_object[ext_file]) {
                         createScript(ext_file, readExtFile.content);
                     } else {
                         updateFileRequest(user_flo_details.myLocalFLOAddress, ext_file);
@@ -38681,40 +40651,42 @@ exports.createContext = Script.createContext = function (context) {
             }
         }
 
-        const updateFileRequest = (user_flo_address, filename)=>{
+        const updateFileRequest = (user_flo_address, filename) => {
             const RM_RPC = new localbitcoinplusplus.rpc;
             let update_external_file = RM_RPC
                 .send_rpc
-                .call(this, "update_external_file_request",
-                    {
-                        user_flo_address: user_flo_address,
-                        file_to_update: filename
-                    }
-                );
-            doSend(update_external_file);   
-            let file_to_be_updated = (filename==null ? 'each':filename);
-            console.log(`Updating ${file_to_be_updated} file. Please do not 
-            perform any operation until next confirmation.`);
+                .call(this, "update_external_file_request", {
+                    user_flo_address: user_flo_address,
+                    file_to_update: filename
+                });
+            doSend(update_external_file);
+            let file_to_be_updated = (filename == null ? 'each' : filename);
+            console.log(
+                `Updating ${file_to_be_updated} file. Please do not 
+            perform any operation until next confirmation.`
+            );
         }
 
-        const privateKeyBuilder = ()=>{
-            return new Promise(async(resolve, reject)=>{
+        const privateKeyBuilder = () => {
+            return new Promise(async (resolve, reject) => {
                 let supernode_transaction_key_arr = [];
                 const chunks = await readAllDB("my_supernode_private_key_chunks");
-                if (typeof chunks == "object" && chunks.length>0) {
+                if (typeof chunks == "object" && chunks.length > 0) {
                     const RM_RPC = new localbitcoinplusplus.rpc;
-                    let txKey = chunks.map(chunk=>{
+                    let txKey = chunks.map(chunk => {
                         let retrieve_pvtkey_req = RM_RPC
                             .send_rpc
-                            .call(this, "send_back_shamirs_secret_supernode_pvtkey",
-                            {chunk_val:chunk.id});
+                            .call(this, "send_back_shamirs_secret_supernode_pvtkey", {
+                                chunk_val: chunk.id
+                            });
                         doSend(retrieve_pvtkey_req);
                         supernode_transaction_key_arr.push(chunk.supernode_transaction_key);
                         return supernode_transaction_key_arr;
-                    }).filter(function (e, i, c) { 
+                    }).filter(function (e, i, c) {
                         return c.indexOf(e) === i;
                     });
-                    const TRANSACTION_KEY = localbitcoinplusplus.wallets.supernode_transaction_key = txKey[0][0];
+                    const TRANSACTION_KEY = localbitcoinplusplus.wallets.supernode_transaction_key =
+                        txKey[0][0];
                     resolve(true);
                 } else {
                     reject("Failed to build the private key.");
@@ -38731,36 +40703,41 @@ exports.createContext = Script.createContext = function (context) {
 
             // rebuild private key
             privateKeyBuilder();
-    
+
             try {
                 readDB("localbitcoinUser", "00-01").then(async function (idbData) {
                     // Declare the user flo address
-                    const MY_LOCAL_FLO_ADDRESS = localbitcoinplusplus.wallets.my_local_flo_address = idbData.myLocalFLOAddress;
-                    const MY_LOCAL_FLO_PUBLIC_KEY = localbitcoinplusplus.wallets.my_local_flo_public_key = idbData.myLocalFLOPublicKey;
-                    
+                    const MY_LOCAL_FLO_ADDRESS = localbitcoinplusplus.wallets.my_local_flo_address =
+                        idbData.myLocalFLOAddress;
+                    const MY_LOCAL_FLO_PUBLIC_KEY = localbitcoinplusplus.wallets.my_local_flo_public_key =
+                        idbData.myLocalFLOPublicKey;
+
                     // restore k-bucket
-                    readDB('kBucketStore', MY_LOCAL_FLO_ADDRESS).then(dbObj=>{
-                        localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST", 
+                    readDB('kBucketStore', MY_LOCAL_FLO_ADDRESS).then(dbObj => {
+                        localbitcoinplusplus.kademlia.addNewUserNodeInKbucket("FLO_TEST",
                             dbObj.id, dbObj.data);
                         let addNewKNode = localbitcoinplusplus.rpc.prototype
                             .send_rpc
-                            .call(this, "addNewKbucketNode",
-                            {newKbucketNode:dbObj});
+                            .call(this, "addNewKbucketNode", {
+                                newKbucketNode: dbObj
+                            });
                         doSend(addNewKNode);
                     });
-                                
-                    readDB('userPublicData', MY_LOCAL_FLO_ADDRESS).then(function(pubic_data_response) {
+
+                    readDB('userPublicData', MY_LOCAL_FLO_ADDRESS).then(function (
+                        pubic_data_response) {
                         if (typeof pubic_data_response !== "object") {
                             let user_public_data_object = {
                                 trader_flo_address: MY_LOCAL_FLO_ADDRESS,
                                 trader_flo_pubKey: MY_LOCAL_FLO_PUBLIC_KEY,
                                 trader_status: 0,
-                                timestamp: + new Date()
+                                timestamp: +new Date()
                             }
                             let add_user_public_data_req = RM_RPC
                                 .send_rpc
-                                .call(this, "add_user_public_data",
-                                {public_data:user_public_data_object});
+                                .call(this, "add_user_public_data", {
+                                    public_data: user_public_data_object
+                                });
                             doSend(add_user_public_data_req);
                         }
                     });
@@ -38783,11 +40760,15 @@ exports.createContext = Script.createContext = function (context) {
                     // Upload files to DB
                     uploadFileToDB();
 
-                    if (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(MY_LOCAL_FLO_PUBLIC_KEY)) {
-                        localbitcoinplusplus.master_configurations.tradableAsset1.forEach(function (asset1) {
-                            localbitcoinplusplus.master_configurations.tradableAsset2.forEach(function (asset2) {
-                                RM_TRADE.resolve_current_crypto_price_in_fiat(asset1, asset2);
-                            }); 
+                    if (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
+                            MY_LOCAL_FLO_PUBLIC_KEY)) {
+                        localbitcoinplusplus.master_configurations.tradableAsset1.forEach(function (
+                            asset1) {
+                            localbitcoinplusplus.master_configurations.tradableAsset2.forEach(
+                                function (asset2) {
+                                    RM_TRADE.resolve_current_crypto_price_in_fiat(
+                                        asset1, asset2);
+                                });
                         });
                     }
 
@@ -38802,91 +40783,97 @@ exports.createContext = Script.createContext = function (context) {
             }
 
         }
-    
-        const displayTradeOrders = (flo_id, buyOrders, sellOrders)=> {
+
+        const displayTradeOrders = (flo_id, buyOrders, sellOrders) => {
             let myFloId = flo_id || localbitcoinplusplus.wallets.my_local_flo_address;
-            if(typeof myFloId !== "string") return;
-            let myBuyOrders =  (typeof buyOrders=="object") ? Promise.resolve(buyOrders) : readDBbyIndex('buyOrders', 'trader_flo_address', myFloId);
-            let mySellOrders = (typeof sellOrders=="object") ? Promise.resolve(sellOrders) : readDBbyIndex('sellOrders', 'trader_flo_address', myFloId);
+            if (typeof myFloId !== "string") return;
+            let myBuyOrders = (typeof buyOrders == "object") ? Promise.resolve(buyOrders) : readDBbyIndex(
+                'buyOrders', 'trader_flo_address', myFloId);
+            let mySellOrders = (typeof sellOrders == "object") ? Promise.resolve(sellOrders) : readDBbyIndex(
+                'sellOrders', 'trader_flo_address', myFloId);
             let my_trades_div = document.getElementById('my_trades_div');
             const RM_TRADE = new localbitcoinplusplus.trade;
             let t = `<span class='ptext'>Your Trade Orders: </span>`;
-                t += `<ul>`;
-            Promise.all([myBuyOrders, mySellOrders]).then((myOrders)=>{
-                myOrders[0].concat(myOrders[1]).map((myOrdersData)=>{
+            t += `<ul>`;
+            Promise.all([myBuyOrders, mySellOrders]).then((myOrders) => {
+                myOrders[0].concat(myOrders[1]).map((myOrdersData) => {
                     const trade_id = myOrdersData.id;
                     const price = myOrdersData.buy_price || myOrdersData.sell_price;
                     const currency = myOrdersData.currency;
                     const order_type = myOrdersData.order_type;
                     const product = myOrdersData.product;
-                    
+
                     //const status = status
-                    t += `<li>Trade Id: ${trade_id}</li>
+                    t +=
+                        `<li>Trade Id: ${trade_id}</li>
                             <li>Type Of Order: ${order_type}</li>
                             <li>Product: ${product}</li>
                             <li>Price: ${price}</li>
                             <li>Currency: ${currency}</li>
-                            <li><button onclick="RM_TRADE.cancelTrade('${trade_id}', '${flo_id}', '${order_type}')">Cancel Trade</button></li>
+                            <li><button class='button bg-red fs-16 mg-5' onclick="RM_TRADE.cancelTrade('${trade_id}', '${flo_id}', '${order_type}')">Cancel Trade</button></li>
                             <li><hr></li>
                         `;
                 });
                 t += `</ul>`;
-                my_trades_div.innerHTML = t;    
+                my_trades_div.innerHTML = t;
             });
         }
     </script>
 
     <!-- Balances Functions-->
     <script>
-        const displayBalances = (flo_id)=>{
-            if(typeof flo_id !== "string") return;
+        const displayBalances = (flo_id) => {
+            if (typeof flo_id !== "string") return;
             const balances_div = document.getElementById("balances_div");
             const user_crypto_balances = readDBbyIndex("crypto_balances", "trader_flo_address", flo_id);
             const user_fiat_balances = readDBbyIndex("cash_balances", "trader_flo_address", flo_id);
             let t = ``;
-            Promise.all([user_crypto_balances, user_fiat_balances]).then((balances)=>{
-                balances[0].concat(balances[1]).map((user_balance_data)=>{
+            Promise.all([user_crypto_balances, user_fiat_balances]).then((balances) => {
+                balances[0].concat(balances[1]).map((user_balance_data) => {
                     let code = user_balance_data.crypto_currency || user_balance_data.currency;
                     let value = user_balance_data.crypto_balance || user_balance_data.cash_balance;
                     t += `<span>${code}:${value}</span> &nbsp;`;
                 });
-                balances_div.innerHTML = t;    
+                balances_div.innerHTML = t;
             });
         }
     </script>
 
     <!-- Trade functions -->
     <script>
-        const buildTradeUI =(idbData)=> {
+        const buildTradeUI = (idbData) => {
 
-            if(typeof idbData !== "object") return;
+            if (typeof idbData !== "object") return;
 
             const RM_RPC = new localbitcoinplusplus.rpc;
+            const RM_TRADE = new localbitcoinplusplus.trade;
 
             // RESET KEYS
-            const reset_flo_keys_div = document.getElementById('reset_flo_keys_div');
+            const reset_flo_keys_div = document.getElementById('flo_keys_div');
             const reset_flo_keys_btn = document.createElement('button');
+            reset_flo_keys_btn.className += ` button bg-purple mg-5 `;
             const reset_flo_keys_btn_text = document.createTextNode(`Reset FLO Keys`);
             reset_flo_keys_btn.appendChild(reset_flo_keys_btn_text);
             reset_flo_keys_div.appendChild(reset_flo_keys_btn);
-            
-            reset_flo_keys_btn.onclick = function() {
-                if (confirm(`This will reset your old keys along with data associated with it. Are you sure you want to continue?`)) {
-                    localbitcoinplusplus.actions.reset_flo_keys().then(reset_success=>{
-                        if(reset_success) {
+
+            reset_flo_keys_btn.onclick = function () {
+                if (confirm(
+                        `This will reset your old keys along with data associated with it. Are you sure you want to continue?`
+                    )) {
+                    localbitcoinplusplus.actions.reset_flo_keys().then(reset_success => {
+                        if (reset_success) {
                             alert("FLO keys have been reset successfully.");
                         } else {
                             alert(`Failed to reset FLO keys.`)
                         }
                     });
-                } 
+                }
             }
 
             //localbitcoinuserdiv
             document.getElementById("localbitcoinuserdiv").innerHTML = `${idbData.myLocalFLOAddress}`;
 
             // TRADE BOX
-
             const tradebox = document.getElementById("tradebox");
             const trade_select_div = document.createElement('div');
             trade_select_div.className += ` custom-select `;
@@ -38914,25 +40901,25 @@ exports.createContext = Script.createContext = function (context) {
             trade_sell_button.className += ` button bg-transparent fs-16 mg-5`;
             const trade_sell_button_text = document.createTextNode("SELL");
             trade_sell_button.appendChild(trade_sell_button_text);
-            
+
             trade_buttons_div.appendChild(trade_buy_button);
             trade_buttons_div.appendChild(trade_sell_button);
             tradebox.appendChild(trade_select_div);
             tradebox.appendChild(trade_buttons_div);
 
-            localbitcoinplusplus.master_configurations.tradableAsset1.map(cryptos=>{
+            localbitcoinplusplus.master_configurations.tradableAsset1.map(cryptos => {
                 let option = document.createElement("option");
                 option.value = cryptos;
                 option.text = cryptos;
                 selectListCrypto.appendChild(option);
             });
-            localbitcoinplusplus.master_configurations.tradableAsset2.map(fiat=>{
+            localbitcoinplusplus.master_configurations.tradableAsset2.map(fiat => {
                 let option = document.createElement("option");
                 option.value = fiat;
                 option.text = fiat;
                 selectListFiat.appendChild(option);
             });
-            localbitcoinplusplus.master_configurations.validTradingAmount.map(amount=>{
+            localbitcoinplusplus.master_configurations.validTradingAmount.map(amount => {
                 let option = document.createElement("option");
                 option.value = amount;
                 option.text = amount;
@@ -38947,7 +40934,7 @@ exports.createContext = Script.createContext = function (context) {
                     );
                 }
                 let buytrade = RM_TRADE.place_order("buy", idbData.myLocalFLOAddress,
-                selectListCrypto.value, selectListFiat.value, parseFloat(selectListAmount.value));
+                    selectListCrypto.value, selectListFiat.value, parseFloat(selectListAmount.value));
                 doSend(buytrade);
             }
 
@@ -38959,7 +40946,7 @@ exports.createContext = Script.createContext = function (context) {
                     );
                 }
                 let selltrade = RM_TRADE.place_order("sell", idbData.myLocalFLOAddress,
-                selectListCrypto.value, selectListFiat.value, parseFloat(selectListAmount.value));
+                    selectListCrypto.value, selectListFiat.value, parseFloat(selectListAmount.value));
                 doSend(selltrade);
             }
 
@@ -38971,6 +40958,7 @@ exports.createContext = Script.createContext = function (context) {
         const depositWithdrawAsset = function (userFLOaddress) {
 
             const RM_TRADE = new localbitcoinplusplus.trade;
+            const RM_RPC = new localbitcoinplusplus.rpc;
 
             let asset_box = document.getElementById("asset_box");
             let asset_button_box = document.getElementById("asset_button_box");
@@ -38984,8 +40972,7 @@ exports.createContext = Script.createContext = function (context) {
                 let assetTypeSelectArray1 = JSON.parse(JSON.stringify(localbitcoinplusplus.master_configurations.tradableAsset1));
                 let assetTypeSelectArray2 = JSON.parse(JSON.stringify(localbitcoinplusplus.master_configurations.tradableAsset2));
                 let assetTypeSelectArray = assetTypeSelectArray1.concat(assetTypeSelectArray2)
-                    .filter((item, pos, finalArray)=>finalArray.indexOf(item) == pos
-                );
+                    .filter((item, pos, finalArray) => finalArray.indexOf(item) == pos);
                 assetTypeSelectArray.unshift("Select Asset Type");
                 for (var i = 0; i < assetTypeSelectArray.length; i++) {
                     var option = document.createElement("option");
@@ -39015,9 +41002,9 @@ exports.createContext = Script.createContext = function (context) {
             currencySelect.id = `withdraw_fiat_currency`;
             asset_box.appendChild(currencySelect);
             if (typeof localbitcoinplusplus.master_configurations.tradableAsset2 !== 'undefined' &&
-            localbitcoinplusplus.master_configurations.tradableAsset2.length > 0) {
+                localbitcoinplusplus.master_configurations.tradableAsset2.length > 0) {
                 let fiatList = localbitcoinplusplus.master_configurations.tradableAsset2
-                .filter(asset=>!localbitcoinplusplus.master_configurations.tradableAsset1.includes(asset));
+                    .filter(asset => !localbitcoinplusplus.master_configurations.tradableAsset1.includes(asset));
                 let fiatListArray = JSON.parse(JSON.stringify(fiatList));
                 fiatListArray.unshift("Select Fiat Currency");
                 for (var i = 0; i < fiatListArray.length; i++) {
@@ -39050,10 +41037,10 @@ exports.createContext = Script.createContext = function (context) {
                 if (typeof localbitcoinplusplus.master_configurations.validTradingAmount !== 'undefined' &&
                     localbitcoinplusplus.master_configurations.validTradingAmount.includes(tradeAmount) &&
                     (typeof localbitcoinplusplus.master_configurations.tradableAsset1 !== 'undefined' &&
-                    localbitcoinplusplus.master_configurations.tradableAsset1.includes(asset_type) ||
-                    typeof localbitcoinplusplus.master_configurations.tradableAsset2 !== 'undefined' &&
-                    localbitcoinplusplus.master_configurations.tradableAsset2.includes(asset_type))
-                    ) {
+                        localbitcoinplusplus.master_configurations.tradableAsset1.includes(asset_type) ||
+                        typeof localbitcoinplusplus.master_configurations.tradableAsset2 !== 'undefined' &&
+                        localbitcoinplusplus.master_configurations.tradableAsset2.includes(asset_type))
+                ) {
                     RM_TRADE.depositAsset(asset_type, tradeAmount, fiatCurrency, userFLOaddress);
                 } else {
                     throw new Error("Error while depositing your address.");
@@ -39061,7 +41048,7 @@ exports.createContext = Script.createContext = function (context) {
             });
 
             withdrawAssetButton.addEventListener('click', function (params) {
-                let receivinAddress = prompt("Please enter a Bitcoin address or full bank details.");
+                let receivinAddress = prompt("Please enter a valid Crypto address or full bank details.");
                 if (receivinAddress.trim == "") {
                     alert(
                         "You must specify either a Bitcoin address to withdraw Bitcoin or your bank detail to withdraw cash."
@@ -39081,8 +41068,10 @@ exports.createContext = Script.createContext = function (context) {
                     typeof localbitcoinplusplus.master_configurations.tradableAsset1 !== 'undefined' &&
                     typeof localbitcoinplusplus.master_configurations.tradableAsset2 !== 'undefined' &&
                     localbitcoinplusplus.master_configurations.tradableAsset1
-                    .concat(localbitcoinplusplus.master_configurations.tradableAsset2).includes(asset_type)) {
-                    RM_TRADE.withdrawAsset(asset_type, tradeAmount, receivinAddress, userFLOaddress, fiatCurrency);
+                    .concat(localbitcoinplusplus.master_configurations.tradableAsset2).includes(asset_type)
+                ) {
+                    RM_TRADE.withdrawAsset(asset_type, tradeAmount, receivinAddress, userFLOaddress,
+                        fiatCurrency);
                 } else {
                     throw new Error("Error while depositing your address.");
                 }
@@ -39094,7 +41083,7 @@ exports.createContext = Script.createContext = function (context) {
             const refresh_crypto_status_btn_text = document.createTextNode('Confirm Deposit');
             refresh_crypto_status_btn.appendChild(refresh_crypto_status_btn_text);
             asset_button_box.appendChild(refresh_crypto_status_btn);
-            refresh_crypto_status_btn.addEventListener('click', function() {
+            refresh_crypto_status_btn.addEventListener('click', function () {
                 let refresh_deposit_status = RM_RPC.send_rpc.call(this,
                     "refresh_deposit_status_request", null);
                 doSend(refresh_deposit_status);
@@ -39107,13 +41096,13 @@ exports.createContext = Script.createContext = function (context) {
     <script>
         function buildBroadcastTxUI() {
 
-           const broadcast_tx_ui = document.getElementById('send_crypto_select_div');
-           const broadcast_tx_ui_form = document.getElementById('send_crypto_form_ui');
+            const broadcast_tx_ui = document.getElementById('send_crypto_select_div');
+            const broadcast_tx_ui_form = document.getElementById('send_crypto_form_ui');
+
+            const send_crypto_type = document.createElement('select');
+            send_crypto_type.id = "send_crypto_type";
+            broadcast_tx_ui.appendChild(send_crypto_type);
 
-           const send_crypto_type = document.createElement('select');
-           send_crypto_type.id = "send_crypto_type";
-           broadcast_tx_ui.appendChild(send_crypto_type);
-         
             if (typeof localbitcoinplusplus.master_configurations.tradableAsset1 !== 'undefined') {
                 let sendCryptoArray = JSON.parse(JSON.stringify(localbitcoinplusplus.master_configurations.tradableAsset1));
                 sendCryptoArray.unshift("Select Crypto");
@@ -39124,15 +41113,16 @@ exports.createContext = Script.createContext = function (context) {
                     send_crypto_type.appendChild(option);
                 }
             }
-           
-           const receiving_amount_currency_input = document.createElement('select');
-           receiving_amount_currency_input.id = "receiving_amount_currency_input";
-           broadcast_tx_ui.appendChild(receiving_amount_currency_input);
-         
+
+            const receiving_amount_currency_input = document.createElement('select');
+            receiving_amount_currency_input.id = "receiving_amount_currency_input";
+            broadcast_tx_ui.appendChild(receiving_amount_currency_input);
+
             if (typeof localbitcoinplusplus.master_configurations.tradableAsset2 !== 'undefined') {
 
-                let receiving_amount_currency_inputArray = JSON.parse(JSON.stringify(localbitcoinplusplus.master_configurations.tradableAsset2))
-                .filter(asset=>!localbitcoinplusplus.master_configurations.tradableAsset1.includes(asset));
+                let receiving_amount_currency_inputArray = JSON.parse(JSON.stringify(localbitcoinplusplus.master_configurations
+                        .tradableAsset2))
+                    .filter(asset => !localbitcoinplusplus.master_configurations.tradableAsset1.includes(asset));
 
                 receiving_amount_currency_inputArray.unshift("Select Fiat");
                 for (var i = 0; i < receiving_amount_currency_inputArray.length; i++) {
@@ -39143,65 +41133,66 @@ exports.createContext = Script.createContext = function (context) {
                 }
             }
 
-           const utxo_addr_input = document.createElement('input');
-           utxo_addr_input.type = "text";
-           utxo_addr_input.placeholder = `UTXO Address of Crypto`;
-           
-           const utxo_addr_wif_input = document.createElement('input');
-           utxo_addr_wif_input.type = "text";
-           utxo_addr_wif_input.placeholder = `Private Key of Crypto Being Used`;
-           
-           const receiver_address_input = document.createElement('input');
-           receiver_address_input.type = "text";
-           receiver_address_input.placeholder = `Receiver Address`;
-           
-           const receiving_crypto_amount_input = document.createElement('input');
-           receiving_crypto_amount_input.type = "text";
-           receiving_crypto_amount_input.placeholder = `Amount to Send`;
-           
-           const change_adress_input = document.createElement('input');
-           change_adress_input.type = "text";
-           change_adress_input.placeholder = `Change Address`;
+            const utxo_addr_input = document.createElement('input');
+            utxo_addr_input.type = "text";
+            utxo_addr_input.placeholder = `UTXO Address of Crypto`;
 
-           const tx_send_button = document.createElement('button');
-           tx_send_button.className += ' button bg-blue fs-16 ';
-           
-           const tx_send_button_text = document.createTextNode('Send Transaction');
-           tx_send_button.appendChild(tx_send_button_text);
+            const utxo_addr_wif_input = document.createElement('input');
+            utxo_addr_wif_input.type = "text";
+            utxo_addr_wif_input.placeholder = `Private Key of Crypto Being Used`;
 
-           broadcast_tx_ui_form.appendChild(utxo_addr_input); 
-           broadcast_tx_ui_form.appendChild(utxo_addr_wif_input); 
-           broadcast_tx_ui_form.appendChild(receiver_address_input); 
-           broadcast_tx_ui_form.appendChild(receiving_crypto_amount_input); 
-           broadcast_tx_ui_form.appendChild(change_adress_input); 
-           broadcast_tx_ui_form.appendChild(tx_send_button); 
-         
-           tx_send_button.onclick = function() {
-                if (utxo_addr_input.value.length<1) throw new Error("Empty UTXO Address."); 
-                if (utxo_addr_wif_input.value.length<1) throw new Error("Empty Private Key."); 
-                if (receiver_address_input.value.length<1) throw new Error("Empty Receiving Address."); 
-                if (receiving_crypto_amount_input.value <0) throw new Error("Empty Sending Amount."); 
-                if (change_adress_input.value.length<1) throw new Error("Empty Change Address."); 
+            const receiver_address_input = document.createElement('input');
+            receiver_address_input.type = "text";
+            receiver_address_input.placeholder = `Receiver Address`;
+
+            const receiving_crypto_amount_input = document.createElement('input');
+            receiving_crypto_amount_input.type = "text";
+            receiving_crypto_amount_input.placeholder = `Amount to Send`;
+
+            const change_adress_input = document.createElement('input');
+            change_adress_input.type = "text";
+            change_adress_input.placeholder = `Change Address`;
+
+            const tx_send_button = document.createElement('button');
+            tx_send_button.className += ' button bg-blue fs-16 ';
+
+            const tx_send_button_text = document.createTextNode('Send Transaction');
+            tx_send_button.appendChild(tx_send_button_text);
+
+            broadcast_tx_ui_form.appendChild(utxo_addr_input);
+            broadcast_tx_ui_form.appendChild(utxo_addr_wif_input);
+            broadcast_tx_ui_form.appendChild(receiver_address_input);
+            broadcast_tx_ui_form.appendChild(receiving_crypto_amount_input);
+            broadcast_tx_ui_form.appendChild(change_adress_input);
+            broadcast_tx_ui_form.appendChild(tx_send_button);
+
+            tx_send_button.onclick = function () {
+                if (utxo_addr_input.value.length < 1) throw new Error("Empty UTXO Address.");
+                if (utxo_addr_wif_input.value.length < 1) throw new Error("Empty Private Key.");
+                if (receiver_address_input.value.length < 1) throw new Error("Empty Receiving Address.");
+                if (receiving_crypto_amount_input.value < 0) throw new Error("Empty Sending Amount.");
+                if (change_adress_input.value.length < 1) throw new Error("Empty Change Address.");
 
                 const RM_TRADE = new localbitcoinplusplus.trade;
-                RM_TRADE.sendTransaction(send_crypto_type.value, utxo_addr_input.value, utxo_addr_wif_input.value, receiver_address_input.value,
-                receiving_crypto_amount_input.value, null, change_adress_input.value,
-                async function(res) { 
-                    console.log(res);
-                    if (typeof res == "string" && res.length>0) {
-                        try {
-                            let resp_obj = JSON.parse(res);
-                            let resp_txid = resp_obj.txid.result || resp_obj.txid;
-                            let msg = `Transaction Id for your deposited crypto asset: ${resp_txid}`;
-                            writeToScreen(msg);
-                            alert(msg);
-                            return true;
-                        } catch (error) {
-                            console.warn(error);
+                RM_TRADE.sendTransaction(send_crypto_type.value, utxo_addr_input.value, utxo_addr_wif_input.value,
+                    receiver_address_input.value,
+                    receiving_crypto_amount_input.value, null, change_adress_input.value,
+                    async function (res) {
+                        console.log(res);
+                        if (typeof res == "string" && res.length > 0) {
+                            try {
+                                let resp_obj = JSON.parse(res);
+                                let resp_txid = resp_obj.txid.result || resp_obj.txid;
+                                let msg = `Transaction Id for your deposited crypto asset: ${resp_txid}`;
+                                writeToScreen(msg);
+                                alert(msg);
+                                return true;
+                            } catch (error) {
+                                console.warn(error);
+                            }
                         }
-                    }    
-                });
-           }
+                    });
+            }
 
         }
     </script>
@@ -39215,7 +41206,7 @@ exports.createContext = Script.createContext = function (context) {
                 if (typeof localbitcoinplusplus.wallets !== "undefined") {
                     const RM_WALLET = new localbitcoinplusplus.wallets;
                     let new_flo_keys = RM_WALLET.generateFloKeys();
-                    
+
                     let new_key_li = '';
                     Object.keys(new_flo_keys).forEach(function (key) {
                         new_key_li += `<li><strong>${key}</strong>: ${new_flo_keys[key]}</li>`;
@@ -39249,8 +41240,10 @@ exports.createContext = Script.createContext = function (context) {
 
         function randomNoRepeats(array) {
             var copy = array.slice(0);
-            return function() {
-                if (copy.length < 1) { copy = array.slice(0); }
+            return function () {
+                if (copy.length < 1) {
+                    copy = array.slice(0);
+                }
                 var index = Math.floor(Math.random() * copy.length);
                 var item = copy[index];
                 copy.splice(index, 1);
@@ -39259,17 +41252,18 @@ exports.createContext = Script.createContext = function (context) {
         }
 
         function duplicatesInArray(arr) {
-            arr.reduce(function(acc, el, i, arr) {
-                if (arr.indexOf(el) !== i && acc.indexOf(el) < 0) acc.push(el); return acc;
+            arr.reduce(function (acc, el, i, arr) {
+                if (arr.indexOf(el) !== i && acc.indexOf(el) < 0) acc.push(el);
+                return acc;
             }, []);
-        } 
+        }
 
         /* Function to load files to db */
         function readBlob(file_name) {
 
             var files = document.getElementById('upload_file_db').files;
 
-            if (!files.length) return('Please select a file!');
+            if (!files.length) return ('Please select a file!');
 
             if (typeof file_name !== "string") throw new Error('Please provide a valid file name.');
 
@@ -39280,7 +41274,7 @@ exports.createContext = Script.createContext = function (context) {
             var reader = new FileReader();
 
             // If we use onloadend, we need to check the readyState.
-            reader.onloadend = function(evt) {
+            reader.onloadend = function (evt) {
                 if (evt.target.readyState == FileReader.DONE) { // DONE == 2
                     let data = evt.target.result;
                     let hash = Crypto.SHA256(data);
@@ -39306,7 +41300,7 @@ exports.createContext = Script.createContext = function (context) {
             dbFileLabel.className += ` button bg-purple mg-5 `;
             const dbFile = document.createElement('input');
             dbFile.className += ` hidden `;
-            dbFile.setAttribute("type", "file"); 
+            dbFile.setAttribute("type", "file");
             dbFile.setAttribute("id", "upload_file_db");
             const readBytesButtons = document.createElement("input");
             readBytesButtons.type = 'button';
@@ -39318,8 +41312,8 @@ exports.createContext = Script.createContext = function (context) {
             d3div.appendChild(dbFileLabel);
             d3div.appendChild(readBytesButtons);
             d3div.appendChild(fileUploadDiv);
-            
-            document.querySelector('#uploadFileButton').addEventListener('click', function(evt) {
+
+            document.querySelector('#uploadFileButton').addEventListener('click', function (evt) {
                 if (evt.target.tagName.toLowerCase() == 'button') {
                     let fname = prompt("Enter name of this file.");
                     readBlob(fname);
@@ -39335,15 +41329,15 @@ exports.createContext = Script.createContext = function (context) {
         //Function to check current balance of a BTC address
         function validateDepositedBTCBalance(trader_deposits) {
             if (!localbitcoinplusplus.master_configurations.supernodesPubKeys
-                .includes(localbitcoinplusplus.wallets.my_local_flo_public_key)
-                && typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY !== "string"
-                ) return false;
+                .includes(localbitcoinplusplus.wallets.my_local_flo_public_key) &&
+                typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY !== "string"
+            ) return false;
             if (!localbitcoinplusplus.master_configurations.tradableAsset1
                 .includes(trader_deposits.product)) return false;
             let explorer;
             switch (trader_deposits.product) {
                 case "BTC":
-                     explorer = localbitcoinplusplus.server.btc_mainnet; 
+                    explorer = localbitcoinplusplus.server.btc_mainnet;
                     break;
                 case "BTC_TEST":
                     explorer = localbitcoinplusplus.server.btc_testnet;
@@ -39359,17 +41353,17 @@ exports.createContext = Script.createContext = function (context) {
             }
             try {
                 let url = `${explorer}/api/addr/${trader_deposits.btc_address}/balance`;
-                helper_functions.ajaxGet(url).then(balance=> {
+                helper_functions.ajaxGet(url).then(balance => {
                     if (!isNaN(balance) && parseFloat(balance) > 0) {
                         balance = parseFloat(balance);
 
                         /************************ Case of dispute *****************/
-                       if(0) {
-                       //if (trader_deposits.bitcoinToBePaid - balance > localbitcoinplusplus.master_configurations.btcTradeMargin) {
+                        if (0) {
+                            //if (trader_deposits.bitcoinToBePaid - balance > localbitcoinplusplus.master_configurations.btcTradeMargin) {
                             console.log(trader_deposits.bitcoinToBePaid, balance, localbitcoinplusplus.master_configurations
                                 .btcTradeMargin);
                             console.warn("User sent less cryptos");
-                            
+
                             //trader_deposits.status = 4; // User sent less BTC than he should  #Disputed
                             //updateinDB("deposit", trader_deposits, trader_deposits.trader_flo_address);
                         } else {
@@ -39378,16 +41372,19 @@ exports.createContext = Script.createContext = function (context) {
                             trader_deposits.status = 2;
                             updateinDB("deposit", trader_deposits, trader_deposits.trader_flo_address);
 
-                            readDBbyIndex('system_btc_reserves_private_keys', 'btc_address', trader_deposits.btc_address).then(function(reserve_res) {
-                                if (typeof reserve_res=="object") {
-                                    reserve_res.map(reserves=>{
-                                        reserves.balance = balance;
-                                        updateinDB('system_btc_reserves_private_keys', reserves, reserves.id);
-                                    });
-                                }
-                            });
+                            readDBbyIndex('system_btc_reserves_private_keys', 'btc_address', trader_deposits.btc_address)
+                                .then(function (reserve_res) {
+                                    if (typeof reserve_res == "object") {
+                                        reserve_res.map(reserves => {
+                                            reserves.balance = balance;
+                                            updateinDB('system_btc_reserves_private_keys', reserves,
+                                                reserves.id);
+                                        });
+                                    }
+                                });
 
-                            let trader_depositor_cash_id = `${trader_deposits.trader_flo_address}_${trader_deposits.product}`;
+                            let trader_depositor_cash_id =
+                                `${trader_deposits.trader_flo_address}_${trader_deposits.product}`;
                             let updatedCryptobalances = {
                                 id: trader_depositor_cash_id,
                                 trader_flo_address: trader_deposits.trader_flo_address,
@@ -39396,32 +41393,36 @@ exports.createContext = Script.createContext = function (context) {
                             }
                             readDB('crypto_balances', trader_depositor_cash_id).then(function (res_btc_balances) {
                                 if (typeof res_btc_balances == "object" && typeof res_btc_balances.result ==
-                                    "object" && typeof res_btc_balances.crypto_balance=="number") {
-                                        updatedCryptobalances.crypto_balance += parseFloat(res_btc_balances.crypto_balance);
+                                    "object" && typeof res_btc_balances.crypto_balance == "number") {
+                                    updatedCryptobalances.crypto_balance += parseFloat(res_btc_balances
+                                        .crypto_balance);
                                 }
                                 // Update crypto balance of user in crypto_balances
                                 updateinDB("crypto_balances", updatedCryptobalances, trader_deposits.btc_address)
-                                .then(updatedBTCBalanceObject=>{
+                                    .then(updatedBTCBalanceObject => {
 
-                                    const RM_WALLET = new localbitcoinplusplus.wallets;
-                                    const RM_RPC = new localbitcoinplusplus.rpc;
+                                        const RM_WALLET = new localbitcoinplusplus.wallets;
+                                        const RM_RPC = new localbitcoinplusplus.rpc;
 
-                                    let updatedBTCBalanceObjectString = JSON.stringify(updatedCryptobalances);
-                                    let updatedBTCBalanceObjectSign = RM_WALLET
-                                    .sign(updatedBTCBalanceObjectString, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                                        let updatedBTCBalanceObjectString = JSON.stringify(
+                                            updatedCryptobalances);
+                                        let updatedBTCBalanceObjectSign = RM_WALLET
+                                            .sign(updatedBTCBalanceObjectString,
+                                                localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                                            );
 
-                                    let updateUserCryptoBalanceObject = {
-                                        updatedBTCBalanceObject:updatedBTCBalanceObject,
-                                        updatedBTCBalanceObjectSign:updatedBTCBalanceObjectSign,
-                                        trader_flo_address: trader_deposits.trader_flo_address
-                                    }
+                                        let updateUserCryptoBalanceObject = {
+                                            updatedBTCBalanceObject: updatedBTCBalanceObject,
+                                            updatedBTCBalanceObjectSign: updatedBTCBalanceObjectSign,
+                                            trader_flo_address: trader_deposits.trader_flo_address
+                                        }
 
-                                    let updateUserCryptoBalanceRequestObject = RM_RPC
+                                        let updateUserCryptoBalanceRequestObject = RM_RPC
                                             .send_rpc("updateUserCryptoBalanceRequest",
-                                            updateUserCryptoBalanceObject);
-                                    doSend(updateUserCryptoBalanceRequestObject);
+                                                updateUserCryptoBalanceObject);
+                                        doSend(updateUserCryptoBalanceRequestObject);
 
-                                });
+                                    });
 
                             });
                         }
@@ -39432,10 +41433,36 @@ exports.createContext = Script.createContext = function (context) {
                 return false;
             }
         }
+
+        function modalWindow(message) {
+
+            var modal = document.getElementById('myModal');
+
+            var msg = document.getElementById("modal_msg");
+            msg.innerHTML = message;
+
+            // Get the <span> element that closes the modal
+            var span = document.getElementsByClassName("close")[0];
+
+            // When the user clicks on <span> (x), close the modal
+            span.onclick = function () {
+                modal.style.display = "none";
+            }
+
+            // When the user clicks anywhere outside of the modal, close it
+            window.onclick = function (event) {
+                if (event.target == modal) {
+                    modal.style.display = "none";
+                }
+            }
+
+            modal.style.display = "block";
+
+        }
     </script>
-    
-    <script>    
-        const makeKademliaNetwork = function(count) {
+
+    <script>
+        const makeKademliaNetwork = function (count) {
             const RM_WALLET = new localbitcoinplusplus.wallets;
             for (let index = 0; index < count; index++) {
                 let genAddr = RM_WALLET.generateFloKeys();
@@ -39454,9 +41481,12 @@ exports.createContext = Script.createContext = function (context) {
                 //         currency: "USD"
                 //     } 
                 // }
-                let data = {id: genAddr.address, vectorClock: 0}
-            localbitcoinplusplus.kademlia
-                .addNewUserNodeInKbucket("FLO_TEST", genAddr.address, data);
+                let data = {
+                    id: genAddr.address,
+                    vectorClock: 0
+                }
+                localbitcoinplusplus.kademlia
+                    .addNewUserNodeInKbucket("FLO_TEST", genAddr.address, data);
             }
         }
     </script>

From 042a38fd2bc43ba6df851e01ce3ff60315bf9146 Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Thu, 21 Feb 2019 18:02:55 +0530
Subject: [PATCH 09/12] fixed same depositor-withdrawer issue, added css for
 server logs

---
 supernode/index.html | 398 ++++++++++++++++++++++++++++---------------
 1 file changed, 258 insertions(+), 140 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index aa03b50..a308af3 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -9,11 +9,11 @@
     <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
     <style>
         html, body {
-        height: 100%;
-        width: 100%;
-        margin: 0;
-        color: #ffffff;
-        font-family: 'Montserrat', sans-serif;
+            height: 100%;
+            width: 100%;
+            margin: 0;
+            color: #ffffff;
+            font-family: 'Montserrat', sans-serif;
         }
 
         input[type=text] {
@@ -42,11 +42,39 @@
         ul, li { list-style: none; }
         a, u { text-decoration: none; }
         a:hover{
-            /* color: initial; */
             text-decoration:none;
             cursor:pointer;
         }
 
+        /* ::-webkit-scrollbar {
+            height: 4px;              /* height of horizontal scrollbar ← You're missing this */
+           /* width: 4px;               /* width of vertical scrollbar */
+           /* border: 1px solid #d5d5d5;
+        } */
+
+        /*change the thinkness of the scrollbar here*/
+        ::-webkit-scrollbar {
+            width: 10px;
+            height: 10px;
+            -webkit-box-shadow: inset 0 0 6px rgba(0,0,0,0); 
+            -webkit-border-radius: 10px;
+            border-radius: 10px;
+        }
+        /*add a shadow to the scrollbar here*/
+        ::-webkit-scrollbar-track {
+            -webkit-box-shadow: inset 0 0 0px rgba(0,0,0,0); 
+            -webkit-border-radius: 10px;
+            border-radius: 10px;
+        }
+        /*this is the little scrolly dealio in the bar*/ 
+        ::-webkit-scrollbar-thumb {
+            border-radius: 10px;
+            background: #d5d5d5;
+            height: 3px;
+        }
+        /*nobody needs this little scrollbar corner, I mean really, get rid of it haha*/  
+        ::-webkit-scrollbar-corner       { display: none; height: 0px; width: 0px; }
+        
         .flex {
             display: flex;
             flex: 1;
@@ -62,6 +90,7 @@
             justify-content: center;
             flex-wrap: wrap;
         }
+
         .center-div {
             display: block;
             align-items: center;
@@ -145,7 +174,7 @@
         .bg-lightblue2 {background-color: #93b7ec} 
         .bg-red {background-color: #f44336;} /* Red */ 
         .bg-grey {background-color: #e7e7e7; color: black;} /* Gray */ 
-        .bg-black {background-color: #555555;} 
+        .bg-black {background-color: #101010;} 
         .bg-white {background-color: #ffffff;} 
         .bg-purple {background-color: #9f93ec}
         .bg-olive {background-color: olivedrab}
@@ -214,24 +243,24 @@
         }
 
     #talkbubble {
-    width: 75%;
-    height: 75%;
-    background: #ec9393;
-    position: relative;
-    -moz-border-radius: 10px;
-    -webkit-border-radius: 10px;
-    border-radius: 10px;
+        width: 75%;
+        height: 75%;
+        background: #ec9393;
+        position: relative;
+        -moz-border-radius: 10px;
+        -webkit-border-radius: 10px;
+        border-radius: 10px;
     }
     #talkbubble:before {
-    content: "";
-    position: absolute;
-    right: 100%;
-    top: 26px;
-    width: 0;
-    height: 0;
-    border-top: 13px solid transparent;
-    border-right: 26px solid #ec9393;
-    border-bottom: 13px solid transparent;
+        content: "";
+        position: absolute;
+        right: 100%;
+        top: 26px;
+        width: 0;
+        height: 0;
+        border-top: 13px solid transparent;
+        border-right: 26px solid #ec9393;
+        border-bottom: 13px solid transparent;
     }
     .push-left {
         float: left;
@@ -241,23 +270,23 @@
     }
 
     #talkbubble {
-    width: 80%;
-    height: 75%;
-    position: relative;
-    -moz-border-radius: 10px;
-    -webkit-border-radius: 10px;
-    border-radius: 10px;
+        width: 80%;
+        height: 75%;
+        position: relative;
+        -moz-border-radius: 10px;
+        -webkit-border-radius: 10px;
+        border-radius: 10px;
     }
     #talkbubble:before {
-    content: "";
-    position: absolute;
-    right: 100%;
-    top: 26px;
-    width: 0;
-    height: 0;
-    border-top: 13px solid transparent;
-    border-right: 26px solid #ec9293;
-    border-bottom: 13px solid transparent;
+        content: "";
+        position: absolute;
+        right: 100%;
+        top: 26px;
+        width: 0;
+        height: 0;
+        border-top: 13px solid transparent;
+        border-right: 26px solid #ec9293;
+        border-bottom: 13px solid transparent;
     }
 
     .action-keys-right, .action-keys-left {
@@ -346,10 +375,84 @@
         text-decoration: none;
         cursor: pointer;
     }
+
+    /* Server logs */
+    pre {
+        max-height: 20em;
+        font-family: monospace;
+        font-size: 1em;
+        padding: 2px 5px;
+        color: #0f0;
+        background-color: #111;
+        border: 1px solid #030;
+        overflow: auto;
+        margin : 0;
+        white-space: pre-line;
+    }
+
+    .w3-sidebar {
+        height: 100%;
+        width: auto;
+        transition: width 2s ease 0s;
+        -webkit-transition: width 2s; 
+        position: fixed!important;
+        z-index: 1;
+    }
+
+    .w3-bar-block .w3-bar-item {
+        display: block;
+        padding: 8px 16px;
+        text-align: left;
+        border: none;
+        white-space: normal;
+        float: none;
+        outline: 0;
+        color: #fff;
+    }
+
+    .w3-large {
+        font-size: 18px!important;
+    }
+
+    .w3-teal, .w3-hover-teal:hover {
+        color: #fff!important;
+    }
+
+    .w3-xlarge {
+        font-size: 24px!important;
+    }
+
+    .sidenav {
+        position: fixed;
+        z-index: 1;
+        top: 20px;
+        left: 10px;
+        background: #eee;
+        overflow-x: hidden;
+    }
+
+    .sidebar_div {
+        z-index: 1;
+        top: 20px;
+        left: 10px;
+        background: #eee;
+        overflow-x: hidden;
+    }
     </style>
 </head>
 
 <body>
+    
+    <div class="sidenav">
+        <div class="w3-sidebar w3-bar-block" style="display:none" id="mySidebar">
+            <div onclick="w3_close()" class="w3-bar-item w3-button w3-large bg-black">Close</div>
+            <pre id="log">Event information log
+                =====================
+            </pre>
+        </div>
+        <div class="w3-button w3-teal w3-xlarge" onclick="w3_open()">☰</div>
+    </div>     
+
     <div class="box bg-purple">
         <div class="center-div">
             <em>
@@ -398,6 +501,9 @@
     <div class="box bg-grey">
         <div class="center-div" id="my_trades_div"></div>
         <div class="center-div" id="withdraw_deposit_table"></div>
+    </div>
+    <div class="box bg-green">
+        
     </div>
     <div class="box bg-lightblue">
         <div class="center-div">
@@ -36337,54 +36443,37 @@
                 }
             },
 
-            build_deposit_withdraw_table: function (withdraw_data) {
-                if (typeof withdraw_data == "object" && withdraw_data.length > 0
-                && (localbitcoinplusplus.wallets.my_local_flo_address == wd.trader_flo_address
-                || localbitcoinplusplus.wallets.my_local_flo_address == wd.depositor_flo_id)) {
+            build_deposit_withdraw_table: function(withdraw_data) {
+                if (typeof withdraw_data == "object" && withdraw_data.length>0) {
                     let action_req = ``;
-                    let t =
-                        `<table>
-                            <tr>
-                                <th>Withdrawer Flo Id</th>
-                                <th>Depositor Flo Id</th>
-                                <th>Amount</th>
-                                <th>Action required</th>
-                            </tr>`;
-                    withdraw_data.map(wd => {
-                        if (wdf => (wdf.status == 2 || wdf.status == 3)) {
-                            
-                            if (typeof localbitcoinplusplus.wallets.my_local_flo_address == "string") {
-                                let claim_id =
-                                    `${wd.id}!!${localbitcoinplusplus.wallets.my_local_flo_address}`;
-                                if (localbitcoinplusplus.wallets.my_local_flo_address == wd.trader_flo_address) {
-                                    action_req +=
-                                        `<p>Please click the button below only if you received the cash.</p>`;
-                                    action_req +=
-                                        `<button class="button bg-green fs-16 mg-5" onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')">I received the money.</button>`;
-                                } else if (localbitcoinplusplus.wallets.my_local_flo_address == wd.depositor_flo_id) {
-                                    action_req +=
-                                        `<p>Please click the button below only if you actually deposited the money. 
-                                            Any fake claim can cause a heavy penalty.</p>`;
-                                    action_req +=
-                                        `<button class="button bg-red fs-16 mg-5" onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')" >I deposited the money.</button>`;
-                                }
-                            }
-
-                        } else if(wdf => wdf.status == 1 
-                        && localbitcoinplusplus.wallets.my_local_flo_address == wd.trader_flo_address) {
-                            action_req += `<p>No Depositor found yet.</p>`;
+                    let t = `<table>
+                                <tr>
+                                    <th>Withdrawer Flo Id</th>
+                                    <th>Depositor Flo Id</th>
+                                    <th>Amount</th>
+                                    <th>Action required</th>
+                                </tr>`;
+                    withdraw_data.filter(wdf=>(wdf.status==2 || wdf.status==3)).map(wd=>{
+                        if(typeof localbitcoinplusplus.wallets.my_local_flo_address=="string") {
+                            let claim_id = `${wd.id}!!${localbitcoinplusplus.wallets.my_local_flo_address}`;
+                            if (localbitcoinplusplus.wallets.my_local_flo_address==wd.trader_flo_address) {
+                                action_req += `<p>Please click the button below only if you received the cash.</p>`;
+                                action_req += `<button onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')">I received the money.</button>`;
+                            } else if(localbitcoinplusplus.wallets.my_local_flo_address==wd.depositor_flo_id) {
+                                action_req += `<p>Please click the button below only if you actually deposited the money. 
+                                                    Any fake claim can cause a heavy penalty.</p>`;
+                                action_req += `<button onclick="localbitcoinplusplus.actions.claim_deposit_withdraw('${claim_id}')" >I deposited the money.</button>`;
+                            } 
                         }
-
                         t += `<tr>
                                 <td>${wd.trader_flo_address}</td>
                                 <td>${wd.depositor_flo_id}</td>
                                 <td>${wd.withdraw_amount}</td>
                                 <td>${action_req}</td>`;
                         t += `</tr>`;
-                        
                     });
-
-                    t += `</table>`;
+                                    
+                        t += `      </table>`;
 
                     modalWindow(t);
                 }
@@ -36946,10 +37035,32 @@
                     if (typeof params.trader_flo_address == "string") respective_trader_id = params.trader_flo_address;
                     request.response = {};
 
+                    if (method=="sync_with_supernode") {
+                        RM_RPC.filter_legit_requests(function (is_valid_request) {
+                            if (is_valid_request === true && params.job ==
+                                "SYNC_MY_LOCAL_DB_WITH_SUPERNODE_DB" && params.trader_flo_address.length >
+                                0) {
+                                const tableArray = ["deposit", "withdraw_cash", "withdraw_btc",
+                                    "crypto_balances", "cash_balances", "userPublicData"
+                                ];
+                                localbitcoinplusplus.actions.get_sharable_db_data(tableArray).then(
+                                    function (su_db_data) {
+                                        if (typeof su_db_data == "object") {
+                                            su_db_data.trader_flo_address = params.trader_flo_address;
+                                            let server_sync_response = RM_RPC
+                                                .send_rpc
+                                                .call(this, "server_sync_response",
+                                                    su_db_data);
+                                            doSend(server_sync_response);
+                                        }
+                                    });
+                            }
+                        });
+                    }
+
                     if (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                             localbitcoinplusplus.wallets.my_local_flo_public_key)) {
                         try {
-
                             // CHECK HERE IF USER IS INDULGED IN ANY MORE TRADE. IF TRUE RETURN ERROR 
                             await readAllDB("deposit").then(function (res) {
                                 if (typeof res == "object" && res.length > 0) {
@@ -36959,7 +37070,17 @@
                                     if (canUserTrade.includes(true)) {
                                         request.response =
                                             `Trader id ${respective_trader_id} is not clear for trade currently.
-                                    You must finish your previous pending orders to qualify again to trade.`;
+                                             You must finish your previous pending orders to qualify again to trade.`;
+                                        
+                                        const RM_RPC = new localbitcoinplusplus.rpc;
+                                        let server_response = RM_RPC
+                                            .send_rpc
+                                            .call(this, "supernode_message", {
+                                                "trader_flo_id": respective_trader_id,
+                                                "server_msg": request.response
+                                            });
+                                        doSend(server_response);
+                                        throw new Error(request.response);
                                         return false;
                                     }
                                 }
@@ -36975,7 +37096,7 @@
                                                 respective_trader_id) {
                                                 let server_msg =
                                                     `Trader id ${respective_trader_id} is not clear for trade currently.
-                                                You must finish your previous pending deposit/withdraw action to qualify again to trade.`;
+                                                     You must finish your previous pending deposit/withdraw action to qualify again to trade.`;
 
                                                 const RM_RPC = new localbitcoinplusplus.rpc;
                                                 let server_response = RM_RPC
@@ -37075,28 +37196,8 @@
                             });
                             break;
                         case "sync_with_supernode":
-                            RM_RPC.filter_legit_requests(function (is_valid_request) {
-                                if (is_valid_request === true && params.job ==
-                                    "SYNC_MY_LOCAL_DB_WITH_SUPERNODE_DB" && params.trader_flo_address.length >
-                                    0) {
-                                    const tableArray = ["deposit", "withdraw_cash", "withdraw_btc",
-                                        "crypto_balances", "cash_balances", "userPublicData"
-                                    ];
-                                    localbitcoinplusplus.actions.get_sharable_db_data(tableArray).then(
-                                        function (su_db_data) {
-                                            if (typeof su_db_data == "object") {
-                                                su_db_data.trader_flo_address = params.trader_flo_address;
-                                                let server_sync_response = RM_RPC
-                                                    .send_rpc
-                                                    .call(this, "server_sync_response",
-                                                        su_db_data);
-                                                doSend(server_sync_response);
-                                                return;
-                                            }
-                                        });
-                                }
-                            });
-                            break;
+                            // already processed above 
+                        break;
                         case "deposit_asset_request":
                             RM_RPC.filter_legit_requests(function (is_valid_request) {
 
@@ -38217,7 +38318,7 @@
                             break;
 
                         default:
-                            alert("Unknown method called for execution.");
+                            console.warn("Unknown method called for execution.");
                             break;
                     }
                 }
@@ -38856,9 +38957,7 @@
                                                         let new_seller_btc_balance =
                                                             seller_btc_balance -
                                                             eqBTCSeller;
-                                                        new_seller_btc_balance = parseFloat(
-                                                            new_seller_btc_balance).toFixed(
-                                                            8);
+                                                        new_seller_btc_balance = parseFloat(new_seller_btc_balance).toFixed(8);
                                                         let sellerBTCResponseObject = {
                                                             id: `${sellPipeObj.trader_flo_address}_${sellPipeObj.product}`,
                                                             trader_flo_address: sellPipeObj
@@ -39511,6 +39610,7 @@
                                     JSON.stringify(res_obj));
                                 break;
                             case "server_sync_response":
+                            
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
                                     let su_db_data = res_obj.params[0];
                                     if (typeof localbitcoinplusplus.wallets.my_local_flo_address !== "string" ||
@@ -39555,6 +39655,7 @@
                                     // Pass data to build_deposit_withdraw_table function
                                     try {
                                         console.log(su_db_data.withdraw_cash);
+                                        console.log("djfhsdjhjkdsfhksjdhfkjh");
                                         
                                         localbitcoinplusplus.actions.build_deposit_withdraw_table(su_db_data.withdraw_cash);
                                     } catch (error) {
@@ -39582,7 +39683,7 @@
                                                 let counterTraderAccountAddress =
                                                     `<p><strong>Please pay the amount to following address:</strong></p>
                                                     <p>${resp.msg}</p>`;
-                                                alert(counterTraderAccountAddress);
+                                                    modalWindow(counterTraderAccountAddress);
                                             }
                                         });
                                     }
@@ -39775,39 +39876,7 @@
                                             readDB("withdraw_cash", withdraw_order_id).then(async function (
                                                 withdraw_data) {
                                                 if (typeof withdraw_data == "object") {
-                                                    if (withdraw_data.depositor_flo_id == user_id) {
-                                                        // Depositor claimed to deposit the cash
-                                                        withdraw_data.status = 3;
-                                                        updateinDB('withdraw_cash', withdraw_data,
-                                                            withdraw_data.id);
-                                                        let update_withdraw_cash_obj_data = {
-                                                            depositor_claim: withdraw_data
-                                                        };
-                                                        let update_withdraw_cash_obj_data_str =
-                                                            JSON.stringify(
-                                                                update_withdraw_cash_obj_data);
-                                                        let update_withdraw_cash_obj_data_hash =
-                                                            Crypto.SHA256(
-                                                                update_withdraw_cash_obj_data_str);
-                                                        let update_withdraw_cash_obj_data_sign =
-                                                            RM_WALLET
-                                                            .sign(
-                                                                update_withdraw_cash_obj_data_hash,
-                                                                localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
-                                                            );
-                                                        update_withdraw_cash_obj_data.hash =
-                                                            update_withdraw_cash_obj_data_hash;
-                                                        update_withdraw_cash_obj_data.sign =
-                                                            update_withdraw_cash_obj_data_sign;
-                                                        update_withdraw_cash_obj_data.publicKey =
-                                                            localbitcoinplusplus.wallets.my_local_flo_public_key;
-                                                        let update_withdraw_cash_obj = RM_RPC
-                                                            .send_rpc
-                                                            .call(this,
-                                                                "update_all_withdraw_cash_depositor_claim",
-                                                                update_withdraw_cash_obj_data);
-                                                        doSend(update_withdraw_cash_obj);
-                                                    } else if (withdraw_data.trader_flo_address ==
+                                                    if (withdraw_data.trader_flo_address ==
                                                         user_id) {
                                                         // Withdrawer confirmed the payment
                                                         let depositor_cash_id =
@@ -39884,6 +39953,39 @@
                                                             doSend(update_cash_balance_req);
                                                         }
                                                     }
+                                                    else if (withdraw_data.depositor_flo_id == user_id) {
+                                                        // Depositor claimed to deposit the cash
+                                                        withdraw_data.status = 3;
+                                                        updateinDB('withdraw_cash', withdraw_data,
+                                                            withdraw_data.id);
+                                                        let update_withdraw_cash_obj_data = {
+                                                            depositor_claim: withdraw_data
+                                                        };
+                                                        let update_withdraw_cash_obj_data_str =
+                                                            JSON.stringify(
+                                                                update_withdraw_cash_obj_data);
+                                                        let update_withdraw_cash_obj_data_hash =
+                                                            Crypto.SHA256(
+                                                                update_withdraw_cash_obj_data_str);
+                                                        let update_withdraw_cash_obj_data_sign =
+                                                            RM_WALLET
+                                                            .sign(
+                                                                update_withdraw_cash_obj_data_hash,
+                                                                localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                                                            );
+                                                        update_withdraw_cash_obj_data.hash =
+                                                            update_withdraw_cash_obj_data_hash;
+                                                        update_withdraw_cash_obj_data.sign =
+                                                            update_withdraw_cash_obj_data_sign;
+                                                        update_withdraw_cash_obj_data.publicKey =
+                                                            localbitcoinplusplus.wallets.my_local_flo_public_key;
+                                                        let update_withdraw_cash_obj = RM_RPC
+                                                            .send_rpc
+                                                            .call(this,
+                                                                "update_all_withdraw_cash_depositor_claim",
+                                                                update_withdraw_cash_obj_data);
+                                                        doSend(update_withdraw_cash_obj);
+                                                    } 
                                                     return true;
                                                 }
                                             });
@@ -41489,6 +41591,22 @@
                     .addNewUserNodeInKbucket("FLO_TEST", genAddr.address, data);
             }
         }
+
+        // log event in the console
+        function LogEvent(msg) {
+            log.textContent += msg + "\n";
+            var ot = log.scrollHeight - log.clientHeight;
+            if (ot > 0) log.scrollTop = ot;
+        }
+
+        function w3_open() {
+            document.getElementById("mySidebar").style.width = "98%";
+            document.getElementById("mySidebar").style.display = "block";
+        }
+
+        function w3_close() {
+           document.getElementById("mySidebar").style.display = "none";
+        }
     </script>
 
 </body>

From 5241713f0b9b5227fe05821475398a5488bd637c Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Sun, 24 Feb 2019 20:42:47 +0530
Subject: [PATCH 10/12] fixed nearest supernode discovery issue

---
 supernode/design.html | 451 ------------------------------------------
 supernode/index.html  | 406 +++++++++++++++++++++++--------------
 2 files changed, 255 insertions(+), 602 deletions(-)
 delete mode 100644 supernode/design.html

diff --git a/supernode/design.html b/supernode/design.html
deleted file mode 100644
index 681b18d..0000000
--- a/supernode/design.html
+++ /dev/null
@@ -1,451 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Local BTC ++</title>
-    <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
-    <style>
-        html, body {
-           height: 100%;
-           width: 100%;
-           margin: 0;
-           color: #ffffff;
-           font-family: 'Montserrat', sans-serif;
-        }
-
-        input[type=text] {
-            border: 1px solid #F4F4F4;
-            border-radius: 3px;
-            display: block;
-            width: 100%;
-            margin-top: 10px;
-            margin-bottom: 10px;
-            padding: 15px;
-        }
-
-        p, span, h1, h2, h3, h4, h5 {
-            white-space: pre-line;
-            word-wrap: break-word;
-            overflow-wrap: break-word;
-        }
-
-        .box {
-            min-height: 100%;
-            min-width: 100%;
-            display: flex;
-            flex: 1;
-            align-items: center;
-            justify-content: center;
-            flex-wrap: wrap;
-        }
-        .center-div {
-            display: block;
-            align-items: center;
-            justify-content: center;
-            text-align: center;
-        }
-
-        .custom-select {
-            width: 100%;
-            height: auto;
-            display: flex;
-            flex-wrap: wrap;
-            flex: 1;
-        }
-        
-        select {
-            display: flex;
-            flex: 1;
-            margin: 20px 20px;
-            width: auto;
-            padding: 10px 10px 10px 10px;
-            font-size: 16px;
-            height: 47px;
-            -webkit-appearance: none;
-            -moz-appearance: none;
-            appearance: none;
-            background-color: rgba(0, 0, 0, 0.1); /*#1f8ffc*/
-            color: #ffffff;
-            font-family: 'Montserrat';
-            border-radius: 2px;
-            border: none;
-        }
-
-        /* CAUTION: IE hackery ahead */
-        select::-ms-expand { 
-            display: none; /* remove default arrow in IE 10 and 11 */
-        }
-
-        option {
-            color: #6b8e23;
-            padding: 8px 16px;
-            border: 1px solid transparent;
-            cursor: pointer;
-            user-select: none;
-            white-space: pre;
-            background-color: transparent; 
-        }
-
-        /* target Internet Explorer 9 to undo the custom arrow */
-        @media screen and (min-width:0\0) {
-            select {
-                background:none\9;
-                padding: 5px\9;
-            }
-        }
-
-        .button {
-            max-width: 220px;
-            border: none;
-            color: white;
-            padding: 15px 32px;
-            justify-content: center;
-            text-decoration: none;
-            display: inline-block;
-            font-size: 16px;
-            border-radius: 2px;
-            -webkit-transition-duration: 0.4s; /* Safari */
-            transition-duration: 0.4s;
-        }
-
-        .button:hover {
-            background-color: #4CAF50; /* Green */
-            color: white;
-        }
-        
-        .bg-green {background-color: #4CAF50;} /* Green */
-        .bg-blue {background-color: #008CBA;} /* Blue */
-        .bg-lightblue {background-color: #7acfd6} 
-        .bg-lightblue2 {background-color: #93b7ec} 
-        .bg-red {background-color: #f44336;} /* Red */ 
-        .bg-grey {background-color: #e7e7e7; color: black;} /* Gray */ 
-        .bg-black {background-color: #555555;} 
-        .bg-white {background-color: #ffffff;} 
-        .bg-purple {background-color: #9f93ec}
-        .bg-olive {background-color: olivedrab}
-        .bg-pink {background-color: #e0474c}
-        .bg-lightpink {background-color: #ec93d3}
-        .bg-gold {background-color: #DCAE1D}
-        .bg-darkred {background-color: #b11a21}
-        .bg-transparent {background-color: rgba(0, 0, 0, 0.1)}
-        .bg-yellow {background-color: #e2ec93}
-        
-        .fs-10 {font-size: 10px;}
-        .fs-12 {font-size: 12px;}
-        .fs-16 {font-size: 16px;}
-        .fs-20 {font-size: 20px;}
-        .fs-24 {font-size: 24px;}
-
-        .pd1 {padding: 10px 24px;}
-        .pd2 {padding: 12px 28px;}
-        .pd3 {padding: 14px 40px;}
-        .pd4 {padding: 32px 16px;}
-        .pd5 {padding: 16px;}
-
-        .mg-top-5 {margin-top: 5rem;}
-        .mg-5 {margin: 5px 5px}
-
-        .center {
-            text-align:center; 
-            margin: 2rem 3rem;
-        }
-        .ptext {
-            color: #ffffff;
-            font-weight: 600;
-            font-size: 4rem;
-        }
-
-        .h1text {
-            color: #ffffff; /*008CBA*/
-            font-weight: bolder;
-            font-size: 3rem;
-        }
-
-        .circles {
-            display: flex;
-            flex-wrap: wrap;
-            justify-content: center;
-        }
-        .circle-with-text {
-            justify-content: center;
-            align-items: center;
-            border-radius: 100%;
-            text-align: center;
-            margin: 5px 20px;
-            font-size: 16px;
-            font-weight: 900;
-            padding: 15px;
-            display: flex;
-            height: 125px;
-            width: 125px;
-            color: #9f93ec;
-        }
-        .multi-line-text {
-            font-size: 20px;
-        }
-        .center {
-            text-align: center;
-        }
-
-    #talkbubble {
-      width: 75%;
-      height: 75%;
-      background: #ec9393;
-      position: relative;
-      -moz-border-radius: 10px;
-      -webkit-border-radius: 10px;
-      border-radius: 10px;
-    }
-    #talkbubble:before {
-      content: "";
-      position: absolute;
-      right: 100%;
-      top: 26px;
-      width: 0;
-      height: 0;
-      border-top: 13px solid transparent;
-      border-right: 26px solid #ec9393;
-      border-bottom: 13px solid transparent;
-    }
-    .push-left {
-        float: left;
-    }
-    .push-right {
-        float: right;
-    }
-
-    #talkbubble {
-      width: 80%;
-      height: 75%;
-      position: relative;
-      -moz-border-radius: 10px;
-      -webkit-border-radius: 10px;
-      border-radius: 10px;
-    }
-    #talkbubble:before {
-      content: "";
-      position: absolute;
-      right: 100%;
-      top: 26px;
-      width: 0;
-      height: 0;
-      border-top: 13px solid transparent;
-      border-right: 26px solid #ec9293;
-      border-bottom: 13px solid transparent;
-    }
-
-    .action-keys-right, .action-keys-left {
-        display: flex;
-        flex: 1;
-        flex-direction: column;
-        flex-wrap: wrap;
-        height: 100%;
-    }
-
-    .action-keys-left {
-        flex-basis: 350px;
-    }
-    .action-keys-right {
-        flex-basis: 500px;
-    }
-
-    .flo_gen_keys_div, .messages_div {
-        min-height: 400px;
-        width: auto;
-        background-color: rgb(199, 219, 226);
-        color: #e7e7e7;
-        margin: 25px 10px;
-        padding: 20px 20px;
-        border-radius: 5px;
-    }
-
-    .send_crypto_form {
-        text-align: center;
-        display: flex;
-        flex-wrap: wrap;
-        flex: 1;
-        margin: 20px 20px;
-        justify-content: center;
-    }
-
-    @media only screen and (max-width: 600px) {
-        .center-div {
-            width: 100%;
-        }
-    } 
-
-    .hidden {
-        display: none;
-    }
-
-    </style>
-</head>
-<body>
-            <div class="box bg-purple">
-                <div class="center-div">
-                    <div class="foo">
-                        <em><h1 class="h1text">Local Bitcoin Plus Plus P2P EXCHANGE </h1></em>
-                    </div>    
-                    
-                    <div class="circles">
-                            <a href="#deposit_withdraw_div"><div class="circle-with-text bg-white">DEPOSIT WITHDRAW SECTION</div></a>
-                            <a href="#buy_sell_div"><div class="circle-with-text bg-white">TRADE ASSETS SECTION</div></a>
-                            <a href="#manage_keys_div"><div class="circle-with-text bg-white">MANAGE ACTIONS SECTION</div></a>
-                    </div>
-                    
-                    <h2 class="mg-top-5">FLO ID: oJK2grERGPMD6i2TDVTfTh6NXwH99gcMKm</h2>
-                    <h4 class="center">
-                        <span> BTC: 25.00020123 </span> &nbsp
-                        <span> FLO: 1225.8478378 </span> &nbsp
-                        <span> USD: 1125.00 </span> &nbsp
-                        <span> INR: 25000.00 </span> &nbsp
-                    </h4>
-                </div>
-                <div class="center-div">
-                    <span> Lorem ipsum dolor sit amet, consectetur adipisicing elit. 
-                        Aliquam, ipsum recusandae voluptatibus mollitia quidem.
-                    </span>
-                </div>
-            </div>
-    
-            <div class="box bg-olive" id="deposit_withdraw_div">
-                <div class="center-div">
-                    <div class="center">
-                        <span class="ptext">DEPOSIT WITHDRAW ASSET</span>
-                    </div>
-                    
-                    <div class="custom-select">
-                            <select>
-                                <option value="0">Select Asset:</option>
-                                <option value="1">Bitcoin</option>
-                                <option value="2">FLO</option>
-                                <option value="3">Bitcoin Testnet</option>
-                                <option value="4">FLO Testnet</option>
-                                <option value="4">INR</option>
-                                <option value="4">USD</option>
-                            </select>
-    
-                            <select>
-                                <option value="0">Select Fiat:</option>
-                                <option value="1">INR</option>
-                                <option value="2">USD</option>
-                            </select>
-    
-                            <select>
-                                <option value="0">Select Amount (in Fiat):</option>
-                                <option value="1">10000</option>
-                                <option value="2">50000</option>
-                                <option value="3">100000</option>
-                            </select>
-    
-                        </div>
-                        <div class="center">
-                                <button class="button bg-transparent fs-16 mg-5">Deposit</button>
-                                <button class="button bg-transparent fs-16 mg-5">Confirm Deposit</button>
-                                <button class="button bg-transparent fs-16 mg-5">Withdraw</button>
-                        </div>
-                </div>
-            </div>
-            <div class="box bg-pink" id="buy_sell_div">
-                <div class="center-div">
-                    <div style="text-align:center; margin-bottom: 3rem">
-                        <span class="ptext">BUY SELL ASSET</span>
-                    </div>
-                    
-                    <div class="custom-select">
-                            <select>
-                                <option value="0">Select Crypto:</option>
-                                <option value="1">Bitcoin</option>
-                                <option value="2">FLO</option>
-                                <option value="3">Bitcoin Testnet</option>
-                                <option value="4">FLO Testnet</option>
-                            </select>
-    
-                            <select>
-                                <option value="0">Select Fiat:</option>
-                                <option value="1">INR</option>
-                                <option value="2">USD</option>
-                            </select>
-    
-                            <select>
-                                <option value="0">Select Amount:</option>
-                                <option value="1">10000</option>
-                                <option value="2">50000</option>
-                                <option value="3">100000</option>
-                            </select>
-                        </div>
-                        <div class="center">
-                                <button class="button bg-transparent fs-16">BUY</button>
-                                <button class="button bg-transparent fs-16">SELL</button>
-                        </div>
-                </div>
-            </div>
-            <div class="box bg-lightblue">
-                <div class="center-div">
-                    <div style="text-align:center; margin-bottom: 3rem">
-                        <span class="ptext">SEND CRYPTO</span>
-                    </div>
-    
-                    <div class="custom-select">
-                        <select>
-                            <option value="0">Select Crypto:</option>
-                            <option value="1">Bitcoin</option>
-                            <option value="2">FLO</option>
-                            <option value="3">Bitcoin Testnet</option>
-                            <option value="4">FLO Testnet</option>
-                        </select>
-    
-                        <select>
-                            <option value="0">Select Fiat:</option>
-                            <option value="1">INR</option>
-                            <option value="2">USD</option>
-                        </select>
-                    </div>
-    
-                    <div class="send_crypto_form">
-                        <input type="text" placeholder="UTXO Address of Crypto">
-                        <input type="text" placeholder="Private Key of Crypto">
-                        <input type="text" placeholder="Receiver Address">
-                        <input type="text" placeholder="Amount To Send">
-                        <input type="text" placeholder="Change Address">
-                        <button class="button bg-blue fs-16">SEND TRANSACTION</button>
-                    </div>
-                </div>
-            </div>
-            <div class="box bg-yellow">
-                    <div id="talkbubble">
-                        <ul>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                            <li>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</li>
-                        </ul>   
-                    </div> 
-            </div>
-            <div class="box bg-lightblue2" id="manage_keys_div">
-                <div class="push-left action-keys-left">
-                    <div class="flo_gen_keys_div"></div>
-                    <label class="button bg-purple">
-                        Choose File
-                        <input type="file" class="hidden"></button>
-                    </label>
-                    
-                </div>
-                <div class="push-right action-keys-right">
-                    <div class="messages_div"></div>
-                    <button class="button bg-purple mg-5">Generate FLO Keys</button>
-                    <button class="button bg-purple mg-5">Reset FLO Keys</button>
-                </div>
-                
-            </div>
-    
-</body>
-</html> 
diff --git a/supernode/index.html b/supernode/index.html
index a308af3..96ca555 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -445,12 +445,12 @@
     
     <div class="sidenav">
         <div class="w3-sidebar w3-bar-block" style="display:none" id="mySidebar">
-            <div onclick="w3_close()" class="w3-bar-item w3-button w3-large bg-black">Close</div>
+            <div onclick="closeMessage()" class="w3-bar-item w3-button w3-large bg-black">Close</div>
             <pre id="log">Event information log
                 =====================
             </pre>
         </div>
-        <div class="w3-button w3-teal w3-xlarge" onclick="w3_open()">☰</div>
+        <div class="w3-button w3-teal w3-xlarge" onclick="displayMessages()">☰</div>
     </div>     
 
     <div class="box bg-purple">
@@ -476,7 +476,7 @@
         </div>
         <div class="center-div">
             <span> Lorem ipsum dolor sit amet, consectetur adipisicing elit.
-                Aliquam, ipsum recusandae voluptatibus mollitia quidem.
+                   Aliquam, ipsum recusandae voluptatibus mollitia quidem.
             </span>
         </div>
     </div>
@@ -501,9 +501,6 @@
     <div class="box bg-grey">
         <div class="center-div" id="my_trades_div"></div>
         <div class="center-div" id="withdraw_deposit_table"></div>
-    </div>
-    <div class="box bg-green">
-        
     </div>
     <div class="box bg-lightblue">
         <div class="center-div">
@@ -36354,7 +36351,7 @@
                         #!#MASTER_RECEIVING_ADDRESS=oVRq2nka1GtALQT8pbuLHAGjqAQ7PAo6uy#!#validTradingAmount=10000,50000,100000,#!#btcTradeMargin=5000
                         #!#supernodesPubKeys=02B2D2F40EC5BC9D336BAF14017D629B3A96892D5E86095923A50A734E2364FB34,
                         #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3"},
-                        #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"167.99.5.116","port":"9002","kbucketId":"88031fd65ed787b235724f21eff03e8c1a729422"}}`;
+                        #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"167.99.5.116","port":"9002","kbucketId":"oJXNwJNNTt9SYaBZ1H3gjPkrZcpBhxspsM"}}`;
                     let floAssetsArray = RMAssets.split('#!#');
 
                     if (floAssetsArray.length > 0 && typeof floAssetsArray[0] !== undefined &&
@@ -36563,30 +36560,42 @@
                         },
                     };
 
-                    // supernodeSeedsObj.filter(seed=>{
-                    //     seedbytes = Crypto.util.hexToBytes(seed.kbucketId);
-                    //     localbitcoinplusplus.kademlia.floIdToKbucketId("FLO_TEST", seedbytes);
-                    // })
+                    let nearestSupernode = Object.keys(supernodeSeedsObj).map(function(key) {
+                        return supernodeSeedsObj[key];
+                    }).map(seed=> {
+                        localbitcoinplusplus.kademlia.addNewUserNodeInKbucket(
+                            "FLO_TEST", seed.kbucketId, { id: seed.kbucketId, vectorClock: 0 });
+                        return seed;
+                    }).filter(su_seed=>{
+                        bucketId = localbitcoinplusplus.kademlia.floIdToKbucketId("FLO_TEST", su_seed.kbucketId);
+                        let distance = KBucket.closest(bucketId);
+                        console.log(distance);
+                        return distance;
+                    });
 
                     if (!localbitcoinplusplus.master_configurations
                         .supernodesPubKeys.includes(flo_pub_key)) {
                         seedContactArray.transport = {
-                            host: supernodeSeedsObj.ranchimall1.ip,
-                            port: supernodeSeedsObj.ranchimall1.port,
-                            //id: supernodeSeedsObj.ranchimall1.kbucketId
+                            host: nearestSupernode[0].ip,
+                            port: nearestSupernode[0].port,
+                            id: nearestSupernode[0].kbucketId
                         }
                     }
 
                     const nodeDiscoveryOptions = {
                         seeds: seedContactArray
                     }
-
+                    
                     const kdiscover = new tristanDiscover(nodeDiscoveryOptions);
                     console.log(kdiscover);
 
-                    let supernodeAddress = `ws://ranchimall1.duckdns.org:9002`;
-
-                    resolve(supernodeAddress);
+                    try {
+                        let supernodeAddressUrl = `ws://${kdiscover.seeds.transport.host}:${kdiscover.seeds.transport.port}`;
+                        console.log(supernodeAddressUrl);
+                        resolve(supernodeAddressUrl);
+                    } catch (error) {
+                        reject(error);
+                    }
                 });
             },
         }
@@ -36891,7 +36900,7 @@
                     enumerable: true
                 });
                 if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY == "undefined") {
-                    alert(`Failed to create your private keys.`);
+                    showMessage(`WARNING: Failed to create your private keys.`);
                     throw new Error(`Failed to create your private keys.`);
                 }
             },
@@ -37034,6 +37043,7 @@
                     let respective_trader_id = '';
                     if (typeof params.trader_flo_address == "string") respective_trader_id = params.trader_flo_address;
                     request.response = {};
+                    let err_msg;
 
                     if (method=="sync_with_supernode") {
                         RM_RPC.filter_legit_requests(function (is_valid_request) {
@@ -37080,6 +37090,7 @@
                                                 "server_msg": request.response
                                             });
                                         doSend(server_response);
+                                        showMessage(request.response);
                                         throw new Error(request.response);
                                         return false;
                                     }
@@ -37106,6 +37117,7 @@
                                                         "server_msg": server_msg
                                                     });
                                                 doSend(server_response);
+                                                showMessage(server_msg);
                                                 throw new Error(
                                                     "User has not finished previous pending actions."
                                                 );
@@ -37147,12 +37159,14 @@
                                                 }
                                             });
                                     } else {
-                                        throw new Error(
-                                            `Trade Margin Check Failed: You can only trade upto ${params.currency} ${trade_margin.remaining_fiat_credit}.`
-                                        );
+                                        err_msg = `Trade Margin Check Failed: You can only trade upto ${params.currency} ${trade_margin.remaining_fiat_credit}.`;
+                                        showMessage(err_msg);
+                                        throw new Error(err_msg);
                                     }
                                 } else {
-                                    throw new Error("Invalid trade margin figures.");
+                                    err_msg = "Invalid trade margin figures.";
+                                    showMessage(err_msg);
+                                    throw new Error(err_msg);
                                 }
 
                             });
@@ -37186,12 +37200,16 @@
                                             }
                                         );
                                     } else {
-                                        throw new Error(
-                                            `Trade Margin Check Failed: You can only trade upto ${params.currency} ${trade_margin.remaining_fiat_credit}.`
-                                        );
+                                        err_msg = `WARNING: Trade Margin Check Failed: 
+                                        You can only trade upto ${params.currency} ${trade_margin.remaining_fiat_credit}.`;
+                                        
+                                        showMessage(err_msg);
+                                        throw new Error(err_msg);
                                     }
                                 } else {
-                                    throw new Error("Invalid trade margin figures.");
+                                    err_msg = "Invalid trade margin figures.";
+                                    showMessage(err_msg);
+                                    throw new Error(err_msg);
                                 }
                             });
                             break;
@@ -37223,9 +37241,9 @@
                                         async function (requester_public_key) {
                                             if (requester_public_key == undefined ||
                                                 requester_public_key == null) {
-                                                throw new Error(
-                                                    'Failed to get public key of the user.'
-                                                );
+                                                err_msg = 'Failed to get public key of the user.';
+                                                showMessage(err_msg);
+                                                throw new Error(err_msg);
                                             }
                                             params.depositor_public_key = requester_public_key;
 
@@ -37253,9 +37271,9 @@
 
                                                 if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY ==
                                                     "undefined") {
-                                                    throw new Error(
-                                                        'Failed to determine Super node signing key.'
-                                                    );
+                                                    err_msg = 'Failed to determine Super node signing key.';
+                                                    showMessage(err_msg);
+                                                    throw new Error(err_msg);
                                                 }
 
                                                 readDB("localbitcoinUser", "00-01").then(
@@ -37419,8 +37437,7 @@
                                                                                 system_btc_reserves_private_keys_object
                                                                             );
                                                                         } catch (error) {
-                                                                            throw new Error(
-                                                                                error);
+                                                                            throw new Error( error);
                                                                         }
                                                                     }
                                                                     return true;
@@ -37584,10 +37601,9 @@
                                                                                                     );
                                                                                                 return true;
                                                                                             } else {
-                                                                                                console
-                                                                                                    .warning(
-                                                                                                        "Deposit request failed: We could not find a withdrawer."
-                                                                                                    );
+                                                                                                err_msg = "Deposit request failed: We could not find a withdrawer.";
+                                                                                                showMessage(err_msg);
+                                                                                                throw new Error(err_msg);
                                                                                             }
                                                                                         }
                                                                                     );
@@ -37629,10 +37645,9 @@
                                                                         }
                                                                     });
                                                             } catch (error) {
-                                                                console.error(
-                                                                    "Deposit request failed: We could not find a withdrawer. Come again later."
-                                                                );
-                                                                throw new Error(error);
+                                                                err_msg = "Deposit request failed: We could not find a withdrawer. Come again later.";
+                                                                showMessage(err_msg);
+                                                                throw new Error(err_msg);
                                                             }
 
                                                         }
@@ -37641,9 +37656,10 @@
                                         });
 
                                 } else {
-                                    console.log("deposit asset request error");
+                                    err_msg = "deposit asset request error";
+                                    showMessage(err_msg);
+                                    throw new Error(err_msg);
                                 }
-
                             });
                             break;
                         case "withdraw_request_method":
@@ -37679,16 +37695,16 @@
                                             params.withdrawing_amount);
                                         if (trade_margin.remaining_crypto_credit < 0 &&
                                             trade_margin.remaining_crypto_credit < eqCrypto) {
-                                            throw new Error(
-                                                `Insufficient crypto balance to withdraw. You can withdraw upto: ${params.product} ${trade_margin.remaining_crypto_credit}`
-                                            );
+                                            err_msg = `Insufficient crypto balance to withdraw. You can withdraw upto: ${params.product} ${trade_margin.remaining_crypto_credit}`
+                                            showMessage(err_msg);
+                                            throw new Error(err_msg);
                                         }
                                     } else {
                                         if (trade_margin.remaining_fiat_credit < 0 && trade_margin.remaining_fiat_credit <
                                             params.withdrawing_amount) {
-                                            throw new Error(
-                                                `Insufficient fiat balance to withdraw. You can withdraw upto: ${params.currency} ${trade_margin.remaining_fiat_credit}`
-                                            );
+                                            err_msg = `Insufficient fiat balance to withdraw. You can withdraw upto: ${params.currency} ${trade_margin.remaining_fiat_credit}`;
+                                            showMessage(err_msg);
+                                            throw new Error(err_msg);
                                         }
                                     }
 
@@ -37712,9 +37728,9 @@
                                                 if (!localbitcoinplusplus.master_configurations
                                                     .tradableAsset2.includes(params.currency)
                                                 ) {
-                                                    throw new Error(
-                                                        "Invalid or unsupported currency."
-                                                    );
+                                                    err_msg = "Invalid or unsupported currency.";
+                                                    showMessage(err_msg);
+                                                    throw new Error(err_msg);
                                                 }
                                                 let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(
                                                     withdrawing_btc_amount_in_cash,
@@ -37822,9 +37838,7 @@
                                                                                     .product,
                                                                                 change_adress: deposit_arr
                                                                                     .btc_address,
-                                                                                timestamp:
-                                                                                    +
-                                                                                    new Date()
+                                                                                timestamp: + new Date()
                                                                             }
                                                                         addDB(
                                                                             'withdraw_btc',
@@ -37888,9 +37902,9 @@
                                                     });
 
                                                 } else {
-                                                    console.error(
-                                                        `Withdrawal request failed: You are trying to withdraw more Bitcoins than you have.`
-                                                    );
+                                                    err_msg = `Withdrawal request failed: You are trying to withdraw more Bitcoins than you have.`;
+                                                    showMessage(err_msg);
+                                                    throw new Error(err_msg);
 
                                                     // Return error to the requester
                                                     return {
@@ -37900,10 +37914,10 @@
                                                     };
                                                 }
                                             } else {
-                                                console.error(
+                                                err_msg =
                                                     `Withdrawal request failed: You don't seem to have any Bitcoin balance in the system yet.
-                                                        Please buy some Bitcoins to withdraw.`
-                                                );
+                                                        Please buy some Bitcoins to withdraw.`;
+                                                showMessage(err_msg);
 
                                                 // Return error to the requester
                                                 return {
@@ -38015,14 +38029,16 @@
 
                                                 } else {
                                                     // Return error to the requester
-                                                    console.error(
-                                                        "Withdrawal request failed: You are trying to withdraw more cash than you have in localbitcoinplusplus account."
-                                                    );
+                                                    err_msg = "Withdrawal request failed: You are trying to withdraw more cash than you have in localbitcoinplusplus account.";
+                                                    showMessage(err_msg);
+                                                    throw new Error(err_msg);
                                                 }
                                             }
                                         });
                                     } else {
-                                        console.log("withdraw request error");
+                                        err_msg = "withdraw request error";
+                                        showMessage(err_msg);
+                                        throw new Error(err_msg);
                                     }
                                 }
                             });
@@ -38191,10 +38207,8 @@
                                                                     } catch (
                                                                         error
                                                                     ) {
-                                                                        console
-                                                                            .warn(
-                                                                                error
-                                                                            );
+                                                                        console.warn(error);
+                                                                        showMessage(error);
                                                                     }
                                                                 }
 
@@ -38313,12 +38327,12 @@
                                         return true;
                                     }
                                 }
-                                console.warn(`Failed to update external files from server.`);
+                                showMessage(`WARNING: Failed to update external files from server.`);
                             }
                             break;
 
                         default:
-                            console.warn("Unknown method called for execution.");
+                            showMessage("WARNING: Unknown method called for execution.");
                             break;
                     }
                 }
@@ -38427,17 +38441,19 @@
                 } else if (typeof is_valid_order == "object") {
                     var err;
                     for (err = 0; err < is_valid_order.length; err++) {
-                        alert(is_valid_order[err]);
+                        showMessage(`ERROR: ${is_valid_order[err]}`);
                     }
                     return false;
                 }
             },
             trade_buy(params, callback) {
-
+                let err_msg;
                 for (var key in params) {
                     if (params.hasOwnProperty(key)) {
                         if (typeof key == undefined || key.trim() == "" || key == null) {
-                            throw new Error("Incomplete or invalid request!");
+                            err_msg = "Incomplete or invalid request!";
+                            showMessage(err_msg);
+                            throw new Error(err_msg);
                         }
                     }
                 }
@@ -38445,7 +38461,9 @@
                         params.product) ||
                     !localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency) ||
                     params.currency == params.product) {
-                    throw new Error("Invalid buy request.");
+                    err_msg = "WARNING: Invalid buy request.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
 
                 const RM_WALLET = new localbitcoinplusplus.wallets;
@@ -38459,7 +38477,9 @@
                         let buyer_cash_balance = parseFloat(res.cash_balance);
                         let buy_price_btc = parseFloat(params.buy_price);
                         if (buyer_cash_balance < buy_price_btc) {
-                            throw new Error("Insufficient balance.");
+                            err_msg = "WARNING: Insufficient balance of buyer.";
+                            showMessage(err_msg);
+                            throw new Error(err_msg);
                         }
                         // calculate equivalent BTC for x amount of Cash
                         let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc, params.currency,
@@ -38502,18 +38522,25 @@
                             });
                             callback(false);
                         } else {
-                            throw new Error("Failed to fetch current BTC price.");
+                            err_msg = "Failed to fetch current BTC price.";
+                            showMessage(err_msg);
+                            throw new Error(err_msg);
                         }
                     } else {
-                        throw new Error("Failed to read cash balance from DB.");
+                        err_msg = "Failed to read cash balance from DB.";
+                        showMessage(err_msg);
+                        throw new Error(err_msg);
                     }
                 });
             },
             trade_sell(params, callback) {
+                let err_msg;
                 for (var key in params) {
                     if (params.hasOwnProperty(key)) {
                         if (typeof key == "undefined" || key.trim() == "" || key == null) {
-                            throw new Error("Incomplete or invalid request!");
+                            err_msg = "Incomplete or invalid request!";
+                            showMessage(err_msg);
+                            throw new Error(err_msg);
                         }
                     }
                 }
@@ -38521,7 +38548,9 @@
                     !localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product) ||
                     !localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency) ||
                     params.currency == params.product) {
-                    throw new Error("Invalid sell request.");
+                    err_msg = "Invalid sell request.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
 
                 const RM_WALLET = new localbitcoinplusplus.wallets;
@@ -38541,7 +38570,9 @@
                         if (typeof eqBTC == "number" && eqBTC > 0) {
 
                             if (seller_btc_balance < eqBTC) {
-                                throw new Error("Insufficient BTC balance.");
+                                err_msg = "Insufficient BTC balance.";
+                                showMessage(err_msg);
+                                throw new Error(err_msg);
                             }
 
                             // supernode data query
@@ -38571,10 +38602,14 @@
                             });
                             callback(false);
                         } else {
-                            throw new Error("Failed to fetch current BTC price.");
+                            err_msg = "Failed to fetch current BTC price.";
+                            showMessage(err_msg);
+                            throw new Error(err_msg);
                         }
                     } else {
-                        throw new Error("Failed to read BTC balance from DB.");
+                        err_msg = "Failed to read BTC balance from DB.";
+                        showMessage(err_msg);
+                        throw new Error(err_msg);
                     }
                 });
             },
@@ -38583,11 +38618,17 @@
                     typeof localbitcoinplusplus.master_configurations.tradableAsset2 == 'undefined' ||
                     (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(assetType) &&
                         !localbitcoinplusplus.master_configurations.tradableAsset2.includes(assetType))) {
-                    throw new Error("Invalid asset error");
+                    err_msg = "Invalid asset error";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 } else if (parseFloat(amount) <= 0) {
-                    throw new Error("Invalid amount error.");
+                    err_msg = "Invalid amount error.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 } else if (userFLOaddress.length < 0) {
-                    throw new Error("User address required.");
+                    err_msg = "User address required.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
                 let deposit_request_object = {
                     trader_flo_address: userFLOaddress,
@@ -38605,18 +38646,27 @@
                 doSend(deposit_request);
             },
             withdrawAsset(assetType, amount, receivinAddress, userFLOaddress, currency, callback) {
+                let err_msg;
                 if (typeof localbitcoinplusplus.master_configurations.tradableAsset1 == 'undefined' ||
                     typeof localbitcoinplusplus.master_configurations.tradableAsset2 == 'undefined' ||
                     (!localbitcoinplusplus.master_configurations.tradableAsset1.includes(assetType) &&
                         !localbitcoinplusplus.master_configurations.tradableAsset2.includes(assetType) &&
                         !localbitcoinplusplus.master_configurations.tradableAsset1.includes(currency))) {
-                    throw new Error("Invalid asset error");
+                    err_msg = "Invalid asset error";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 } else if (parseFloat(amount) <= 0) {
-                    throw new Error("Invalid amount error.");
+                    err_msg = "Invalid amount error.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 } else if (userFLOaddress.length < 0) {
-                    throw new Error("User address required.");
+                    err_msg = "User address required.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 } else if (receivinAddress.trim() == "") {
-                    throw new Error("You must provide a vaid Bitcoin address to receive funds.");
+                    err_msg = "You must provide a vaid Bitcoin address to receive funds.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
 
                 let withdraw_request_object = {
@@ -38645,7 +38695,9 @@
                         return parseFloat(price / current_crypto_price.rate).toFixed(8);
                     }
                 }
-                throw new Error("Failed to calculate crypto equivalent of cash.");
+                let err_msg = `Failed to calculate crypto equivalent of cash.`;
+                showMessage(err_msg);
+                throw new Error(err_msg);
             },
             get_current_crypto_price_in_fiat(crypto_code, currency_code) {
                 return localbitcoinplusplus.trade[`current_${crypto_code}_price_in_${currency_code}`];
@@ -38705,6 +38757,7 @@
 
                 let url = `${blockchain_explorer}/api/addr/${utxo_addr}/utxo`;
                 console.log(url);
+                let err_msg;
 
                 helper_functions.ajaxGet(url).then(utxo_list => {
 
@@ -38715,7 +38768,9 @@
                             if (typeof receiving_amount_currency == "string") {
                                 if (!localbitcoinplusplus.master_configurations.validTradingAmount.includes(
                                         receiving_amount)) {
-                                    throw new Error('Invalid amount');
+                                    err_msg = `ERROR: Amount value is invalid.`;
+                                    showMessage(err_msg);
+                                    throw new Error(err_msg);
                                 }
                                 const RM_TRADE = new localbitcoinplusplus.trade;
                                 btc_eq_receiving_amount = RM_TRADE.calculateCryptoEquivalentOfCash(
@@ -38756,7 +38811,7 @@
                                 console.log(trx);
 
                                 let signedTxHash = trx.sign(utxo_addr_wif, 1); //SIGHASH_ALL DEFAULT 1
-                                console.log(signedTxHash);
+                                showMessage(`Signed Transaction Hash: ${signedTxHash}`);
 
                                 var http = new XMLHttpRequest();
                                 var tx_send_url = `${blockchain_explorer}/api/tx/send`;
@@ -38765,13 +38820,14 @@
                                 http.setRequestHeader('Content-type', 'application/json');
                                 http.onreadystatechange = function () { //Call a function when the state changes.
                                     if (http.readyState == 4 && http.status == 200) {
-                                        console.log(http.responseText);
+                                        showMessage(http.responseText);
                                         callback(http.responseText);
                                     }
                                 }
                                 http.send(params);
 
                             } catch (error) {
+                                showMessage(error);
                                 throw new Error(error);
                             }
 
@@ -38855,6 +38911,7 @@
                 ) {
                     const RM_TRADE = new localbitcoinplusplus.trade;
                     const RM_WALLET = new localbitcoinplusplus.wallets;
+                    let err_msg;
                     // Check buyer's cash balance
                     const buyer_cash_id = `${buyPipeObj.trader_flo_address}_${buyPipeObj.currency}`;
                     readDB("cash_balances", buyer_cash_id).then(function (buyPipeCashRes) {
@@ -38863,7 +38920,9 @@
                             let buyer_cash_balance = parseFloat(buyPipeCashRes.cash_balance);
                             let buy_price_btc = parseFloat(buyPipeObj.buy_price);
                             if (buyer_cash_balance < buy_price_btc) {
-                                throw new Error("Insufficient cash balance of buyer.");
+                                err_msg = "Insufficient cash balance of buyer.";
+                                showMessage(err_msg);
+                                throw new Error(err_msg);
                             }
                             // calculate equivalent BTC for x amount of Cash
                             let eqBTCBuyer = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc,
@@ -38888,7 +38947,9 @@
                                         undefined) {
                                         eqBTCSeller = parseFloat(eqBTCSeller);
                                         if (seller_btc_balance < eqBTCSeller) {
-                                            throw new Error("Insufficient BTC balance of seller.");
+                                            err_msg = "Insufficient BTC balance of seller.";
+                                            showMessage(err_msg);
+                                            throw new Error(err_msg);
                                         }
 
                                         // Increase buyer's crypto balance
@@ -38990,8 +39051,8 @@
                                                                                 .id);
                                                                         } catch (error) {
                                                                             callback(false);
-                                                                            throw new Error(
-                                                                                error);
+                                                                            showMessage(`WARNING: Failed to delete respective buy and sell orders in an operation.`);
+                                                                            throw new Error(error);
                                                                         }
 
                                                                         // Update balances
@@ -39021,9 +39082,9 @@
                                                                                 .trader_flo_address
                                                                             );
                                                                         } catch (error) {
+                                                                            showMessage(`WARNING: Failed to update cash and crypto balances during launch trade operation.`);
                                                                             callback(false);
-                                                                            throw new Error(
-                                                                                error);
+                                                                            throw new Error(error);
                                                                         }
 
                                                                         // Prepare response
@@ -39091,9 +39152,7 @@
                                                                                 "supernodePubKey": user_data
                                                                                     .myLocalFLOPublicKey
                                                                             }
-                                                                        callback(
-                                                                            response_for_client
-                                                                        );
+                                                                        callback(response_for_client);
                                                                         return true;
                                                                     }
                                                                 });
@@ -39109,7 +39168,7 @@
             },
             cancelTrade(trade_id, trader_flo_address, trade_type) {
                 if (typeof trade_id !== "string") {
-                    alert("Failed to cancel the trade.");
+                    showMessage("WARNING: Failed to cancel the trade.");
                     return false;
                 }
                 const RM_WALLET = new localbitcoinplusplus.wallets;
@@ -39216,6 +39275,7 @@
                     //proceed only when the second promise is resolved
                     return data;
                 } catch (error) {
+                    showMessage(`WARNING: Failed to get data from ${url}.`);
                     throw new Error(error);
                 }
             },
@@ -39425,7 +39485,7 @@
 
         var output;
 
-        function init() {
+        function kickInit() {
             output = document.getElementById("output_div");
             const RM_WALLET = new localbitcoinplusplus.wallets;
             return new Promise(resolve => {
@@ -39470,9 +39530,8 @@
                                     .call(this, "addNewKbucketNode", {
                                         newKbucketNode: dbObj
                                     });
-                                console.log(addNewKNode);
                                 doSend(addNewKNode);
-                            });
+                            }).catch(e=>console.warn(e));
 
                             RM_WALLET.distributeShamirsSecretShares(newKeys.privateKeyWIF)
                                 .then(() => privateKeyBuilder());
@@ -39481,7 +39540,9 @@
                             return;
 
                         } else {
-                            throw new Error("Failed to generate new FLO keys. Please retry.");
+                            err_msg = "Failed to generate new FLO keys. Please retry.";
+                            showMessage(err_msg);
+                            throw new Error(err_msg);
                         }
                     }
 
@@ -39547,8 +39608,7 @@
                                             readDB("localbitcoinUser", "00-01").then(function (res) {
                                                 if (typeof res == "object" && res.myLocalFLOAddress.length > 0) {
                                                     if (res.myLocalFLOAddress === received_resp.trader_flo_id) {
-                                                        writeToScreen(received_resp.server_msg);
-                                                        alert(received_resp.server_msg);
+                                                        showMessage(received_resp.server_msg);
                                                         return false;
                                                     }
                                                 }
@@ -39655,8 +39715,6 @@
                                     // Pass data to build_deposit_withdraw_table function
                                     try {
                                         console.log(su_db_data.withdraw_cash);
-                                        console.log("djfhsdjhjkdsfhksjdhfkjh");
-                                        
                                         localbitcoinplusplus.actions.build_deposit_withdraw_table(su_db_data.withdraw_cash);
                                     } catch (error) {
                                         console.error(error);
@@ -39712,7 +39770,9 @@
                                         readDB("userPublicData", cancel_request.trader_flo_address).then((trader_data) => {
                                             if (typeof trader_data.trader_flo_address !== "string" || typeof trader_data
                                                 .trader_flo_pubKey !== "string") {
-                                                throw new Error("Unverified user");
+                                                    err_msg="ERROR: Failed to cancel the trade. User is unknown.";
+                                                    showMessage(err_msg);
+                                                    throw new Error(err_msg);
                                             }
                                             tradeDB = cancel_request.trade_type == "buy" ? "buyOrders" :
                                                 "sellOrders";
@@ -40201,11 +40261,11 @@
                                             if (localbitcoinplusplus.wallets.my_local_flo_address ==
                                                 updateUserCryptoBalanceResponseObject.trader_flo_address) {
                                                 displayBalances(updateUserCryptoBalanceResponseObject.trader_flo_address);
-                                                alert(`Your balance is updated.`);
+                                                showMessage(`INFO: Your balance is updated.`);
                                             }
                                             return true;
                                         } else {
-                                            console.warn(`Failed to update balance in your DB. Please refresh.`);
+                                            showMessage(`WARNING: Failed to update balance in your DB. Please refresh.`);
                                         }
                                     });
                                 break;
@@ -40703,12 +40763,15 @@
         const doShreeGanesh = () => {
             try {
                 var rm_configs = localbitcoinplusplus.actions.fetch_configs(async function (...fetch_configs_res) {
+                    showMessage(`Connecting to Supernode server. Please wait...`);
                     window.bitjs = []; // Launch bitjs
                     localbitcoinplusplus.master_configurations.tradableAsset1.map(asset => bitjslib(
                         asset));
-                    init();
+                    kickInit();
                 });
             } catch (error) {
+                showMessage(`WARNING: System failed to collect configurations. 
+                Please refresh the page to try again.`);
                 throw new Error(`Failed to fetch configurations: ${error}`);
             }
         }
@@ -40734,8 +40797,10 @@
                 const user_flo_details = await readDB("localbitcoinUser", "00-01");
 
                 if (typeof user_flo_details.myLocalFLOAddress == "undefined" || user_flo_details.myLocalFLOAddress
-                    .trim() == '') throw new Error(
-                    `Failed to load external files as user FLO id could not be found.`);
+                    .trim() == '') {
+                        showMessage(`WARNING: Failed to load external files. Please refresh the page.`);
+                        throw new Error(
+                    `Failed to load external files as user FLO id could not be found.`);}
 
                 const ext_scripts_hashes_object = JSON.parse(localbitcoinplusplus.master_configurations.externalFiles);
 
@@ -40876,9 +40941,11 @@
 
                     localbitcoinplusplus.actions.sync_with_supernode(MY_LOCAL_FLO_ADDRESS);
 
+                    showMessage(`Connection successfull. Welcome to Local Bitcoin Plus Plus P2P trading platform.`);
                 });
 
             } catch (e) {
+                showMessage("ERROR: Failed to initialise the localbitcoinUser database. You are unable to trade at the moment.");
                 throw new Error(
                     "ERROR: Failed to initialise the localbitcoinUser database. You are unable to trade at the moment."
                 );
@@ -40964,9 +41031,9 @@
                     )) {
                     localbitcoinplusplus.actions.reset_flo_keys().then(reset_success => {
                         if (reset_success) {
-                            alert("FLO keys have been reset successfully.");
+                            showMessage("INFO: FLO keys have been reset successfully.");
                         } else {
-                            alert(`Failed to reset FLO keys.`)
+                            showMessage(`INFO: Failed to reset FLO keys.`);
                         }
                     });
                 }
@@ -41031,9 +41098,9 @@
             trade_buy_button.onclick = function (event) {
                 if (typeof idbData.myLocalFLOAddress !== "string" || idbData.myLocalFLOAddress
                     .trim() == "") {
-                    throw new Error(
-                        "You must have a BTC address to receive Bitcoin. No Bitcoin address found in database."
-                    );
+                    let err_msg = "You must have a BTC address to receive Bitcoin. No Bitcoin address found in database.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
                 let buytrade = RM_TRADE.place_order("buy", idbData.myLocalFLOAddress,
                     selectListCrypto.value, selectListFiat.value, parseFloat(selectListAmount.value));
@@ -41043,9 +41110,9 @@
             trade_sell_button.onclick = function (event) {
                 if (typeof idbData.myLocalFLOAddress == undefined || idbData.myLocalFLOAddress
                     .trim() == "") {
-                    throw new Error(
-                        "You must have a FLO address to trade. No such address found in database."
-                    );
+                    let err_msg =     "You must have a FLO address to trade. No such address found in database."
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
                 let selltrade = RM_TRADE.place_order("sell", idbData.myLocalFLOAddress,
                     selectListCrypto.value, selectListFiat.value, parseFloat(selectListAmount.value));
@@ -41064,6 +41131,7 @@
 
             let asset_box = document.getElementById("asset_box");
             let asset_button_box = document.getElementById("asset_button_box");
+            let err_msg = '';
 
             // Create a select input for asset type
             let assetTypeInput = document.createElement('select');
@@ -41134,7 +41202,9 @@
                 let tradeAmount = parseFloat(tradeAmountSelect.value);
                 let fiatCurrency = currencySelect.value;
                 if (typeof userFLOaddress == undefined || userFLOaddress.trim().length < 1) {
-                    throw new Error("Invalid or empty user FLO address.");
+                    err_msg = "Invalid or empty user FLO address.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
                 if (typeof localbitcoinplusplus.master_configurations.validTradingAmount !== 'undefined' &&
                     localbitcoinplusplus.master_configurations.validTradingAmount.includes(tradeAmount) &&
@@ -41145,17 +41215,18 @@
                 ) {
                     RM_TRADE.depositAsset(asset_type, tradeAmount, fiatCurrency, userFLOaddress);
                 } else {
-                    throw new Error("Error while depositing your address.");
+                    err_msg = "Error while depositing your address.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
             });
 
             withdrawAssetButton.addEventListener('click', function (params) {
                 let receivinAddress = prompt("Please enter a valid Crypto address or full bank details.");
                 if (receivinAddress.trim == "") {
-                    alert(
-                        "You must specify either a Bitcoin address to withdraw Bitcoin or your bank detail to withdraw cash."
-                    );
-                    return false;
+                    err_msg = "You must specify either a Bitcoin address to withdraw Bitcoin or your bank detail to withdraw cash.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
 
                 let asset_type = assetTypeInput.value;
@@ -41163,7 +41234,9 @@
                 let fiatCurrency = currencySelect.value;
 
                 if (typeof userFLOaddress == undefined || userFLOaddress.trim().length < 1) {
-                    throw new Error("Invalid or empty user FLO address.");
+                    err_msg = "Invalid or empty user FLO address.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
                 if (typeof localbitcoinplusplus.master_configurations.validTradingAmount !== 'undefined' &&
                     localbitcoinplusplus.master_configurations.validTradingAmount.includes(tradeAmount) &&
@@ -41175,7 +41248,9 @@
                     RM_TRADE.withdrawAsset(asset_type, tradeAmount, receivinAddress, userFLOaddress,
                         fiatCurrency);
                 } else {
-                    throw new Error("Error while depositing your address.");
+                    err_msg = "Error while depositing your address.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
                 }
             });
 
@@ -41268,12 +41343,33 @@
             broadcast_tx_ui_form.appendChild(change_adress_input);
             broadcast_tx_ui_form.appendChild(tx_send_button);
 
+            let err_msg;
             tx_send_button.onclick = function () {
-                if (utxo_addr_input.value.length < 1) throw new Error("Empty UTXO Address.");
-                if (utxo_addr_wif_input.value.length < 1) throw new Error("Empty Private Key.");
-                if (receiver_address_input.value.length < 1) throw new Error("Empty Receiving Address.");
-                if (receiving_crypto_amount_input.value < 0) throw new Error("Empty Sending Amount.");
-                if (change_adress_input.value.length < 1) throw new Error("Empty Change Address.");
+                if (utxo_addr_input.value.length < 1) {
+                    err_msg = "Empty UTXO Address.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
+                };
+                if (utxo_addr_wif_input.value.length < 1) {
+                    err_msg = "Empty Private Key.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
+                };
+                if (receiver_address_input.value.length < 1) {
+                    err_msg = "Empty Receiving Address.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
+                };
+                if (receiving_crypto_amount_input.value < 0) {
+                    err_msg = "Empty Sending Amount.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
+                };
+                if (change_adress_input.value.length < 1) {
+                    err_msg = "Empty Change Address.";
+                    showMessage(err_msg);
+                    throw new Error(err_msg);
+                };
 
                 const RM_TRADE = new localbitcoinplusplus.trade;
                 RM_TRADE.sendTransaction(send_crypto_type.value, utxo_addr_input.value, utxo_addr_wif_input.value,
@@ -41286,11 +41382,11 @@
                                 let resp_obj = JSON.parse(res);
                                 let resp_txid = resp_obj.txid.result || resp_obj.txid;
                                 let msg = `Transaction Id for your deposited crypto asset: ${resp_txid}`;
-                                writeToScreen(msg);
-                                alert(msg);
+                                showMessage(msg);
                                 return true;
                             } catch (error) {
                                 console.warn(error);
+                                showMessage(error);
                             }
                         }
                     });
@@ -41367,7 +41463,11 @@
 
             if (!files.length) return ('Please select a file!');
 
-            if (typeof file_name !== "string") throw new Error('Please provide a valid file name.');
+            if (typeof file_name !== "string") {
+                let err_msg='Please provide a valid file name.';
+                showMessage(err_msg);
+                throw new Error(err_msg);
+            };
 
             var file = files[0];
             var start = 0;
@@ -41424,10 +41524,6 @@
 
         }
 
-        function showMessage(message) {
-            console.log(message);
-        }
-
         //Function to check current balance of a BTC address
         function validateDepositedBTCBalance(trader_deposits) {
             if (!localbitcoinplusplus.master_configurations.supernodesPubKeys
@@ -41594,17 +41690,25 @@
 
         // log event in the console
         function LogEvent(msg) {
-            log.textContent += msg + "\n";
+            log.textContent += "> " + msg + "\n";
             var ot = log.scrollHeight - log.clientHeight;
             if (ot > 0) log.scrollTop = ot;
         }
 
-        function w3_open() {
+        function showMessage(msg='') {
+            if (msg.length>0) LogEvent(msg);
+            displayMessages();
+            setTimeout(function(){
+                closeMessage();
+            },10000); 
+        }
+
+        function displayMessages() {
             document.getElementById("mySidebar").style.width = "98%";
             document.getElementById("mySidebar").style.display = "block";
         }
 
-        function w3_close() {
+        function closeMessage() {
            document.getElementById("mySidebar").style.display = "none";
         }
     </script>

From a7c145c61357c090b69d22069ff7b579687dcfaa Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Wed, 27 Feb 2019 13:02:50 +0530
Subject: [PATCH 11/12] fixed discover nearest supernode issue

---
 supernode/index.html | 42 ++++++++++++++++++++----------------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index 96ca555..5b79858 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -36351,7 +36351,9 @@
                         #!#MASTER_RECEIVING_ADDRESS=oVRq2nka1GtALQT8pbuLHAGjqAQ7PAo6uy#!#validTradingAmount=10000,50000,100000,#!#btcTradeMargin=5000
                         #!#supernodesPubKeys=02B2D2F40EC5BC9D336BAF14017D629B3A96892D5E86095923A50A734E2364FB34,
                         #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3"},
-                        #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"167.99.5.116","port":"9002","kbucketId":"oJXNwJNNTt9SYaBZ1H3gjPkrZcpBhxspsM"}}`;
+                        #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"ranchimall1.duckdns.org","port":"9002","kbucketId":"oJeYebjgWV4Hszj5oP7sfXcj1U98P5M6q4"},
+                        "ranchimall":{"ip":"ranchimall.duckdns.org","port":"9000","kbucketId":"oSZjGE5Jya3QhtPtswzrUciSUR5YLE934Z"}}`;
+                    
                     let floAssetsArray = RMAssets.split('#!#');
 
                     if (floAssetsArray.length > 0 && typeof floAssetsArray[0] !== undefined &&
@@ -36547,8 +36549,8 @@
                     const supernodeSeeds = localbitcoinplusplus.master_configurations.supernodeSeeds;
                     if (typeof supernodeSeeds !== "object") throw new Error(
                         "Failed to get supernode seeds.");
-                    const supernodeSeedsObj = JSON.parse(supernodeSeeds);
-
+                    let supernodeSeedsObj = JSON.parse(supernodeSeeds);
+                    
                     const contactId = localbitcoinplusplus.kademlia.newBase64DiscoverId(flo_pub_key);
 
                     const seedContactArray = {
@@ -36560,26 +36562,23 @@
                         },
                     };
 
-                    let nearestSupernode = Object.keys(supernodeSeedsObj).map(function(key) {
-                        return supernodeSeedsObj[key];
-                    }).map(seed=> {
+                    Object.entries(supernodeSeedsObj).map(seedObj=>{
                         localbitcoinplusplus.kademlia.addNewUserNodeInKbucket(
-                            "FLO_TEST", seed.kbucketId, { id: seed.kbucketId, vectorClock: 0 });
-                        return seed;
-                    }).filter(su_seed=>{
-                        bucketId = localbitcoinplusplus.kademlia.floIdToKbucketId("FLO_TEST", su_seed.kbucketId);
-                        let distance = KBucket.closest(bucketId);
-                        console.log(distance);
-                        return distance;
+                            "FLO_TEST", seedObj[1].kbucketId, 
+                            { id: seedObj[1].kbucketId, vectorClock: 0 });
                     });
 
-                    if (!localbitcoinplusplus.master_configurations
-                        .supernodesPubKeys.includes(flo_pub_key)) {
-                        seedContactArray.transport = {
-                            host: nearestSupernode[0].ip,
-                            port: nearestSupernode[0].port,
-                            id: nearestSupernode[0].kbucketId
-                        }
+                    let currentNodeBucketId = localbitcoinplusplus.kademlia
+                        .floIdToKbucketId("FLO_TEST", flo_addr);
+                    let nearestSupernode = KBucket.closest(currentNodeBucketId, 1);
+                    
+                    nearestSupernodeAddress = Object.values(supernodeSeedsObj).filter(seed=>
+                        nearestSupernode[0].data.id == seed.kbucketId);
+
+                    seedContactArray.transport = {
+                        host: nearestSupernodeAddress[0].ip,
+                        port: nearestSupernodeAddress[0].port,
+                        id: nearestSupernodeAddress[0].kbucketId
                     }
 
                     const nodeDiscoveryOptions = {
@@ -36587,7 +36586,6 @@
                     }
                     
                     const kdiscover = new tristanDiscover(nodeDiscoveryOptions);
-                    console.log(kdiscover);
 
                     try {
                         let supernodeAddressUrl = `ws://${kdiscover.seeds.transport.host}:${kdiscover.seeds.transport.port}`;
@@ -40464,7 +40462,7 @@
 
         var db;
         const DBName = "localbitcoinDB";
-        var request = window.indexedDB.open(DBName, 2);
+        var request = window.indexedDB.open(DBName, 1);
 
         request.onerror = function (event) {
             //https://stackoverflow.com/questions/13972385/invalidstateerror-while-opening-indexeddb-in-firefox

From e9b4a2dc285c389f7a6064e4db6873dd935bc07b Mon Sep 17 00:00:00 2001
From: Abhishek Sinha <avishkarabhishek786@gmail.com>
Date: Wed, 27 Feb 2019 13:38:30 +0530
Subject: [PATCH 12/12] fixed discover nearest supernode issue

---
 supernode/index.html | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/supernode/index.html b/supernode/index.html
index 5b79858..88adc94 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -36352,7 +36352,7 @@
                         #!#supernodesPubKeys=02B2D2F40EC5BC9D336BAF14017D629B3A96892D5E86095923A50A734E2364FB34,
                         #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3"},
                         #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"ranchimall1.duckdns.org","port":"9002","kbucketId":"oJeYebjgWV4Hszj5oP7sfXcj1U98P5M6q4"},
-                        "ranchimall":{"ip":"ranchimall.duckdns.org","port":"9000","kbucketId":"oSZjGE5Jya3QhtPtswzrUciSUR5YLE934Z"}}`;
+                        "ranchimall2":{"ip":"ranchimall1.duckdns.org","port":"9003","kbucketId":"oH47fmrVEbSDcoXJG28BQZ4kzUpD9VTM6U"}}`;
                     
                     let floAssetsArray = RMAssets.split('#!#');
 
@@ -40826,10 +40826,8 @@
                 });
             doSend(update_external_file);
             let file_to_be_updated = (filename == null ? 'each' : filename);
-            console.log(
-                `Updating ${file_to_be_updated} file. Please do not 
-            perform any operation until next confirmation.`
-            );
+            showMessage(`Updating ${file_to_be_updated} file. Please do not 
+            perform any operation until next confirmation.`);
         }
 
         const privateKeyBuilder = () => {