@leofcoin/peernet 1.2.17 → 1.2.19

package/exports/browser/{identity-CqSnKXWH.js → identity-CVOmmghe.js}

@@ -1,144 +1,341 @@
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-const base$1 = (ALPHABET) => {
-    if (ALPHABET.length >= 255) {
-        throw new TypeError('Alphabet too long');
-    }
-    const BASE_MAP = new Uint8Array(256);
-    for (let j = 0; j < BASE_MAP.length; j++) {
-        BASE_MAP[j] = 255;
-    }
-    for (let i = 0; i < ALPHABET.length; i++) {
-        const x = ALPHABET.charAt(i);
-        const xc = x.charCodeAt(0);
-        if (BASE_MAP[xc] !== 255) {
-            throw new TypeError(x + ' is ambiguous');
-        }
-        BASE_MAP[xc] = i;
-    }
-    const BASE = ALPHABET.length;
-    const LEADER = ALPHABET.charAt(0);
-    const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-    const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-    const encode = (source) => {
-        if (source instanceof Uint8Array) ;
-        else if (ArrayBuffer.isView(source)) {
-            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-        }
-        else if (Array.isArray(source)) {
-            source = Uint8Array.from(source);
-        }
-        if (!(source instanceof Uint8Array)) {
-            throw new TypeError('Expected Uint8Array');
-        }
-        if (source.length === 0) {
-            return '';
-        }
-        // Skip & count leading zeroes.
-        let zeroes = 0;
-        let length = 0;
-        let pbegin = 0;
-        const pend = source.length;
-        while (pbegin !== pend && source[pbegin] === 0) {
-            pbegin++;
-            zeroes++;
-        }
-        // Allocate enough space in big-endian base58 representation.
-        const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-        const b58 = new Uint8Array(size);
-        // Process the bytes.
-        while (pbegin !== pend) {
-            let carry = source[pbegin];
-            // Apply "b58 = b58 * 256 + ch".
-            let i = 0;
-            for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-                carry += (256 * b58[it1]) >>> 0;
-                b58[it1] = (carry % BASE) >>> 0;
-                carry = (carry / BASE) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error('Non-zero carry');
-            }
-            length = i;
-            pbegin++;
-        }
-        // Skip leading zeroes in base58 result.
-        let it2 = size - length;
-        while (it2 !== size && b58[it2] === 0) {
-            it2++;
-        }
-        // Translate the result into a string.
-        let str = LEADER.repeat(zeroes);
-        for (; it2 < size; ++it2) {
-            str += ALPHABET.charAt(b58[it2]);
-        }
-        return str;
-    };
-    const decodeUnsafe = (source) => {
-        if (typeof source !== 'string') {
-            throw new TypeError('Expected String');
-        }
-        if (source.length === 0) {
-            return new Uint8Array();
-        }
-        let psz = 0;
-        // Skip and count leading '1's.
-        let zeroes = 0;
-        let length = 0;
-        while (source[psz] === LEADER) {
-            zeroes++;
-            psz++;
-        }
-        // Allocate enough space in big-endian base256 representation.
-        const size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-        let b256 = new Uint8Array(size);
-        // Process the characters.
-        while (source[psz]) {
-            // Decode character
-            let carry = BASE_MAP[source.charCodeAt(psz)];
-            // Invalid character
-            if (carry === 255) {
-                return;
-            }
-            let i = 0;
-            for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-                carry += (BASE * b256[it3]) >>> 0;
-                b256[it3] = (carry % 256) >>> 0;
-                carry = (carry / 256) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error('Non-zero carry');
-            }
-            length = i;
-            psz++;
-        }
-        // Skip leading zeroes in b256.
-        let it4 = size - length;
-        while (it4 !== size && b256[it4] === 0) {
-            it4++;
-        }
-        let vch = new Uint8Array(zeroes + (size - it4));
-        let j = zeroes;
-        while (it4 !== size) {
-            vch[j++] = b256[it4++];
-        }
-        return vch;
-    };
-    const decode = (string) => {
-        const buffer = decodeUnsafe(string);
-        if (buffer) {
-            return buffer;
-        }
-        throw new Error('Non-base' + BASE + ' character');
-    };
-    return {
-        encode,
-        decodeUnsafe,
-        decode
-    };
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Copyright (c) 2026 Vandeuren Glenn
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+const base$1 = (ALPHABET, options = {}) => {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError("Alphabet too long");
+    }
+    const BASE_MAP = new Uint8Array(256);
+    for (let j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (let i = 0; i < ALPHABET.length; i++) {
+        const x = ALPHABET.charAt(i);
+        const xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + " is ambiguous");
+        }
+        BASE_MAP[xc] = i;
+    }
+    const BASE = ALPHABET.length;
+    const LEADER = ALPHABET.charAt(0);
+    const LEADER_CODE = ALPHABET.charCodeAt(0);
+    const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    // Optimization: If BASE is a power of 2, we can use bitwise operations
+    // This is much faster than the generic algorithm (approx 10x-20x)
+    const isPowerOfTwo = (BASE & (BASE - 1)) === 0;
+    if (isPowerOfTwo) {
+        const k = Math.log2(BASE);
+        const mask = (1 << k) - 1;
+        if (options.rfc4648) {
+            // RFC 4648 Mode
+            const encode = (source) => {
+                if (source instanceof Uint8Array) ;
+                else if (ArrayBuffer.isView(source)) {
+                    source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+                }
+                else if (Array.isArray(source)) {
+                    source = Uint8Array.from(source);
+                }
+                if (!(source instanceof Uint8Array)) {
+                    throw new TypeError("Expected Uint8Array");
+                }
+                if (source.length === 0) {
+                    return "";
+                }
+                let str = "";
+                let currentValue = 0;
+                let currentBits = 0;
+                for (let i = 0; i < source.length; i++) {
+                    currentValue = (currentValue << 8) | source[i];
+                    currentBits += 8;
+                    while (currentBits >= k) {
+                        currentBits -= k;
+                        str += ALPHABET.charAt((currentValue >>> currentBits) & mask);
+                    }
+                }
+                // Leftover bits (padding logic for the last character)
+                if (currentBits > 0) {
+                    str += ALPHABET.charAt((currentValue << (k - currentBits)) & mask);
+                }
+                // Add padding chars '=' if required
+                while ((str.length * k) % 8 !== 0) {
+                    str += "=";
+                }
+                return str;
+            };
+            const decodeUnsafe = (source) => {
+                if (typeof source !== "string") {
+                    throw new TypeError("Expected String");
+                }
+                if (source.length === 0) {
+                    return new Uint8Array();
+                }
+                // Strip padding
+                let end = source.length;
+                while (end > 0 && source[end - 1] === "=") {
+                    end--;
+                }
+                source = source.substring(0, end);
+                let currentValue = 0;
+                let currentBits = 0;
+                // Estimate size: source.length * k / 8
+                const buffer = new Uint8Array((source.length * k) >>> 3);
+                let ptr = 0;
+                for (let i = 0; i < source.length; i++) {
+                    const char = source.charCodeAt(i);
+                    const val = BASE_MAP[char];
+                    if (val === 255)
+                        return undefined;
+                    currentValue = (currentValue << k) | val;
+                    currentBits += k;
+                    if (currentBits >= 8) {
+                        currentBits -= 8;
+                        buffer[ptr++] = (currentValue >>> currentBits) & 0xff;
+                    }
+                }
+                return buffer;
+            };
+            const decode = (string) => {
+                const buffer = decodeUnsafe(string);
+                if (buffer)
+                    return buffer;
+                throw new Error("Non-base" + BASE + " character");
+            };
+            return { encode, decodeUnsafe, decode };
+        }
+        // Standard Mode (Bitwise)
+        const encode = (source) => {
+            if (source instanceof Uint8Array) ;
+            else if (ArrayBuffer.isView(source)) {
+                source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+            }
+            else if (Array.isArray(source)) {
+                source = Uint8Array.from(source);
+            }
+            if (!(source instanceof Uint8Array)) {
+                throw new TypeError("Expected Uint8Array");
+            }
+            if (source.length === 0) {
+                return "";
+            }
+            let zeroes = 0;
+            let pbegin = 0;
+            const pend = source.length;
+            while (pbegin !== pend && source[pbegin] === 0) {
+                pbegin++;
+                zeroes++;
+            }
+            let str = LEADER.repeat(zeroes);
+            if (pbegin === pend)
+                return str;
+            // Bitwise conversion
+            let currentValue = 0;
+            let currentBits = 0;
+            const totalBits = (pend - pbegin) * 8;
+            let remainder = totalBits % k;
+            // Handling the initial alignment to the most significant bits
+            // If total bits isn't divisible by k, the first digit uses 'remainder' bits
+            if (remainder === 0)
+                remainder = k; // effectively divisible, treating first k bits normally
+            let seenNonZero = false;
+            let firstChunk = true;
+            for (let i = pbegin; i < pend; i++) {
+                currentValue = (currentValue << 8) | source[i];
+                currentBits += 8;
+                while (currentBits >= k || (firstChunk && currentBits >= remainder)) {
+                    let bitsToExtract = k;
+                    if (firstChunk) {
+                        if (totalBits % k !== 0) {
+                            bitsToExtract = totalBits % k;
+                        }
+                        firstChunk = false;
+                    }
+                    const shift = currentBits - bitsToExtract;
+                    const digit = (currentValue >>> shift) & ((1 << bitsToExtract) - 1);
+                    currentBits -= bitsToExtract;
+                    if (seenNonZero || digit !== 0) {
+                        str += ALPHABET.charAt(digit);
+                        seenNonZero = true;
+                    }
+                }
+            }
+            return str;
+        };
+        const decodeUnsafe = (source) => {
+            if (typeof source !== "string") {
+                throw new TypeError("Expected String");
+            }
+            if (source.length === 0) {
+                return new Uint8Array();
+            }
+            let psz = 0;
+            let zeroes = 0;
+            while (source.charCodeAt(psz) === LEADER_CODE) {
+                zeroes++;
+                psz++;
+            }
+            // Accumulate bits
+            // We must handle alignment.
+            const length = source.length - psz;
+            const totalBits = length * k;
+            let currentBits = (8 - (totalBits % 8)) % 8; // align to byte boundary
+            const result = new Uint8Array((totalBits + 7) >>> 3); // (totalBits + 7) / 8
+            let rIdx = 0;
+            let currentValue = 0;
+            for (let i = psz; i < source.length; i++) {
+                const char = source.charCodeAt(i);
+                const val = BASE_MAP[char];
+                if (val === 255)
+                    return;
+                currentValue = (currentValue << k) | val;
+                currentBits += k;
+                if (currentBits >= 8) {
+                    const shift = currentBits - 8;
+                    result[rIdx++] = (currentValue >>> shift) & 0xff;
+                    currentBits -= 8;
+                    // Keep only the remaining bits to avoid overflow
+                    currentValue &= (1 << currentBits) - 1;
+                }
+            }
+            // Skip leading zeroes in result buffer
+            let skip = 0;
+            while (skip < rIdx && result[skip] === 0) {
+                skip++;
+            }
+            // Combine with zeroes
+            const final = new Uint8Array(zeroes + (rIdx - skip));
+            // zeroes are 0, so just copy result
+            final.set(result.subarray(skip, rIdx), zeroes);
+            return final;
+        };
+        const decode = (string) => {
+            const buffer = decodeUnsafe(string);
+            if (buffer)
+                return buffer;
+            throw new Error("Non-base" + BASE + " character");
+        };
+        return { encode, decodeUnsafe, decode };
+    }
+    const encode = (source) => {
+        if (source instanceof Uint8Array) ;
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+            throw new TypeError("Expected Uint8Array");
+        }
+        if (source.length === 0) {
+            return "";
+        }
+        // Skip & count leading zeroes.
+        let zeroes = 0;
+        let length = 0;
+        let pbegin = 0;
+        const pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        const b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            let carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            let i = 0;
+            for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+                carry += (b58[it1] << 8) >>> 0;
+                b58[it1] = (carry % BASE) >>> 0;
+                carry = (carry / BASE) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error("Non-zero carry");
+            }
+            length = i;
+            pbegin++;
+        }
+        // Skip leading zeroes in base58 result.
+        let it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
+        // Translate the result into a string.
+        let str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    };
+    const decodeUnsafe = (source) => {
+        if (typeof source !== "string") {
+            throw new TypeError("Expected String");
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        let psz = 0;
+        // Skip and count leading '1's.
+        let zeroes = 0;
+        let length = 0;
+        while (source.charCodeAt(psz) === LEADER_CODE) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        const size = ((source.length - psz) * FACTOR + 1) >>> 0; // log(58) / log(256), rounded up.
+        let b256 = new Uint8Array(size);
+        // Process the characters.
+        for (; psz < source.length; psz++) {
+            // Decode character
+            let carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255) {
+                return;
+            }
+            let i = 0;
+            for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+                carry += (BASE * b256[it3]) >>> 0;
+                b256[it3] = (carry & 0xff) >>> 0;
+                carry = (carry >> 8) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error("Non-zero carry");
+            }
+            length = i;
+        }
+        // Skip leading zeroes in b256.
+        let it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        let vch = new Uint8Array(zeroes + (size - it4));
+        let j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
+    };
+    const decode = (string) => {
+        const buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error("Non-base" + BASE + " character");
+    };
+    return {
+        encode,
+        decodeUnsafe,
+        decode,
+    };
 };
 
 const ALPHABET$1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
@@ -1627,7 +1824,7 @@ function requireBn () {
 	if (hasRequiredBn) return bn$1.exports;
 	hasRequiredBn = 1;
 	(function (module) {
-		(function (module, exports$1) {
+		(function (module, exports) {
 
 		  // Utils
 		  function assert (val, msg) {
@@ -1670,7 +1867,7 @@ function requireBn () {
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -3755,6 +3952,11 @@ function requireBn () {
 		      this.words[this.length - 1] &= mask;
 		    }
 
+		    if (this.length === 0) {
+		      this.words[0] = 0;
+		      this.length = 1;
+		    }
+
 		    return this.strip();
 		  };
 
@@ -5102,9 +5304,9 @@ var hasRequiredUtils$4;
 function requireUtils$4 () {
 	if (hasRequiredUtils$4) return utils$3;
 	hasRequiredUtils$4 = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var utils = exports$1;
+		var utils = exports;
 
 		function toArray(msg, enc) {
 		  if (Array.isArray(msg))
@@ -5169,9 +5371,9 @@ var hasRequiredUtils$3;
 function requireUtils$3 () {
 	if (hasRequiredUtils$3) return utils$4;
 	hasRequiredUtils$3 = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var utils = exports$1;
+		var utils = exports;
 		var BN = requireBn();
 		var minAssert = requireMinimalisticAssert();
 		var minUtils = requireUtils$4();
@@ -7376,9 +7578,9 @@ var hasRequiredCurve;
 function requireCurve () {
 	if (hasRequiredCurve) return curve;
 	hasRequiredCurve = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var curve = exports$1;
+		var curve = exports;
 
 		curve.base = requireBase();
 		curve.short = requireShort();
@@ -8682,8 +8884,8 @@ var hasRequiredHash;
 function requireHash () {
 	if (hasRequiredHash) return hash;
 	hasRequiredHash = 1;
-	(function (exports$1) {
-		var hash = exports$1;
+	(function (exports) {
+		var hash = exports;
 
 		hash.utils = requireUtils$2();
 		hash.common = requireCommon$1();
@@ -9496,9 +9698,9 @@ var hasRequiredCurves;
 function requireCurves () {
 	if (hasRequiredCurves) return curves;
 	hasRequiredCurves = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var curves = exports$1;
+		var curves = exports;
 
 		var hash = requireHash();
 		var curve = requireCurve();
@@ -10737,9 +10939,9 @@ var hasRequiredElliptic$2;
 function requireElliptic$2 () {
 	if (hasRequiredElliptic$2) return elliptic$2;
 	hasRequiredElliptic$2 = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var elliptic = exports$1;
+		var elliptic = exports;
 
 		elliptic.version = require$$0.version;
 		elliptic.utils = requireUtils$3();
@@ -11528,2056 +11730,2055 @@ class HdNode {
 }
 
 // see https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt
-
 var wordlist = [
-  'abandon',
-  'ability',
-  'able',
-  'about',
-  'above',
-  'absent',
-  'absorb',
-  'abstract',
-  'absurd',
-  'abuse',
-  'access',
-  'accident',
-  'account',
-  'accuse',
-  'achieve',
-  'acid',
-  'acoustic',
-  'acquire',
-  'across',
-  'act',
-  'action',
-  'actor',
-  'actress',
-  'actual',
-  'adapt',
-  'add',
-  'addict',
-  'address',
-  'adjust',
-  'admit',
-  'adult',
-  'advance',
-  'advice',
-  'aerobic',
-  'affair',
-  'afford',
-  'afraid',
-  'again',
-  'age',
-  'agent',
-  'agree',
-  'ahead',
-  'aim',
-  'air',
-  'airport',
-  'aisle',
-  'alarm',
-  'album',
-  'alcohol',
-  'alert',
-  'alien',
-  'all',
-  'alley',
-  'allow',
-  'almost',
-  'alone',
-  'alpha',
-  'already',
-  'also',
-  'alter',
-  'always',
-  'amateur',
-  'amazing',
-  'among',
-  'amount',
-  'amused',
-  'analyst',
-  'anchor',
-  'ancient',
-  'anger',
-  'angle',
-  'angry',
-  'animal',
-  'ankle',
-  'announce',
-  'annual',
-  'another',
-  'answer',
-  'antenna',
-  'antique',
-  'anxiety',
-  'any',
-  'apart',
-  'apology',
-  'appear',
-  'apple',
-  'approve',
-  'april',
-  'arch',
-  'arctic',
-  'area',
-  'arena',
-  'argue',
-  'arm',
-  'armed',
-  'armor',
-  'army',
-  'around',
-  'arrange',
-  'arrest',
-  'arrive',
-  'arrow',
-  'art',
-  'artefact',
-  'artist',
-  'artwork',
-  'ask',
-  'aspect',
-  'assault',
-  'asset',
-  'assist',
-  'assume',
-  'asthma',
-  'athlete',
-  'atom',
-  'attack',
-  'attend',
-  'attitude',
-  'attract',
-  'auction',
-  'audit',
-  'august',
-  'aunt',
-  'author',
-  'auto',
-  'autumn',
-  'average',
-  'avocado',
-  'avoid',
-  'awake',
-  'aware',
-  'away',
-  'awesome',
-  'awful',
-  'awkward',
-  'axis',
-  'baby',
-  'bachelor',
-  'bacon',
-  'badge',
-  'bag',
-  'balance',
-  'balcony',
-  'ball',
-  'bamboo',
-  'banana',
-  'banner',
-  'bar',
-  'barely',
-  'bargain',
-  'barrel',
-  'base',
-  'basic',
-  'basket',
-  'battle',
-  'beach',
-  'bean',
-  'beauty',
-  'because',
-  'become',
-  'beef',
-  'before',
-  'begin',
-  'behave',
-  'behind',
-  'believe',
-  'below',
-  'belt',
-  'bench',
-  'benefit',
-  'best',
-  'betray',
-  'better',
-  'between',
-  'beyond',
-  'bicycle',
-  'bid',
-  'bike',
-  'bind',
-  'biology',
-  'bird',
-  'birth',
-  'bitter',
-  'black',
-  'blade',
-  'blame',
-  'blanket',
-  'blast',
-  'bleak',
-  'bless',
-  'blind',
-  'blood',
-  'blossom',
-  'blouse',
-  'blue',
-  'blur',
-  'blush',
-  'board',
-  'boat',
-  'body',
-  'boil',
-  'bomb',
-  'bone',
-  'bonus',
-  'book',
-  'boost',
-  'border',
-  'boring',
-  'borrow',
-  'boss',
-  'bottom',
-  'bounce',
-  'box',
-  'boy',
-  'bracket',
-  'brain',
-  'brand',
-  'brass',
-  'brave',
-  'bread',
-  'breeze',
-  'brick',
-  'bridge',
-  'brief',
-  'bright',
-  'bring',
-  'brisk',
-  'broccoli',
-  'broken',
-  'bronze',
-  'broom',
-  'brother',
-  'brown',
-  'brush',
-  'bubble',
-  'buddy',
-  'budget',
-  'buffalo',
-  'build',
-  'bulb',
-  'bulk',
-  'bullet',
-  'bundle',
-  'bunker',
-  'burden',
-  'burger',
-  'burst',
-  'bus',
-  'business',
-  'busy',
-  'butter',
-  'buyer',
-  'buzz',
-  'cabbage',
-  'cabin',
-  'cable',
-  'cactus',
-  'cage',
-  'cake',
-  'call',
-  'calm',
-  'camera',
-  'camp',
-  'can',
-  'canal',
-  'cancel',
-  'candy',
-  'cannon',
-  'canoe',
-  'canvas',
-  'canyon',
-  'capable',
-  'capital',
-  'captain',
-  'car',
-  'carbon',
-  'card',
-  'cargo',
-  'carpet',
-  'carry',
-  'cart',
-  'case',
-  'cash',
-  'casino',
-  'castle',
-  'casual',
-  'cat',
-  'catalog',
-  'catch',
-  'category',
-  'cattle',
-  'caught',
-  'cause',
-  'caution',
-  'cave',
-  'ceiling',
-  'celery',
-  'cement',
-  'census',
-  'century',
-  'cereal',
-  'certain',
-  'chair',
-  'chalk',
-  'champion',
-  'change',
-  'chaos',
-  'chapter',
-  'charge',
-  'chase',
-  'chat',
-  'cheap',
-  'check',
-  'cheese',
-  'chef',
-  'cherry',
-  'chest',
-  'chicken',
-  'chief',
-  'child',
-  'chimney',
-  'choice',
-  'choose',
-  'chronic',
-  'chuckle',
-  'chunk',
-  'churn',
-  'cigar',
-  'cinnamon',
-  'circle',
-  'citizen',
-  'city',
-  'civil',
-  'claim',
-  'clap',
-  'clarify',
-  'claw',
-  'clay',
-  'clean',
-  'clerk',
-  'clever',
-  'click',
-  'client',
-  'cliff',
-  'climb',
-  'clinic',
-  'clip',
-  'clock',
-  'clog',
-  'close',
-  'cloth',
-  'cloud',
-  'clown',
-  'club',
-  'clump',
-  'cluster',
-  'clutch',
-  'coach',
-  'coast',
-  'coconut',
-  'code',
-  'coffee',
-  'coil',
-  'coin',
-  'collect',
-  'color',
-  'column',
-  'combine',
-  'come',
-  'comfort',
-  'comic',
-  'common',
-  'company',
-  'concert',
-  'conduct',
-  'confirm',
-  'congress',
-  'connect',
-  'consider',
-  'control',
-  'convince',
-  'cook',
-  'cool',
-  'copper',
-  'copy',
-  'coral',
-  'core',
-  'corn',
-  'correct',
-  'cost',
-  'cotton',
-  'couch',
-  'country',
-  'couple',
-  'course',
-  'cousin',
-  'cover',
-  'coyote',
-  'crack',
-  'cradle',
-  'craft',
-  'cram',
-  'crane',
-  'crash',
-  'crater',
-  'crawl',
-  'crazy',
-  'cream',
-  'credit',
-  'creek',
-  'crew',
-  'cricket',
-  'crime',
-  'crisp',
-  'critic',
-  'crop',
-  'cross',
-  'crouch',
-  'crowd',
-  'crucial',
-  'cruel',
-  'cruise',
-  'crumble',
-  'crunch',
-  'crush',
-  'cry',
-  'crystal',
-  'cube',
-  'culture',
-  'cup',
-  'cupboard',
-  'curious',
-  'current',
-  'curtain',
-  'curve',
-  'cushion',
-  'custom',
-  'cute',
-  'cycle',
-  'dad',
-  'damage',
-  'damp',
-  'dance',
-  'danger',
-  'daring',
-  'dash',
-  'daughter',
-  'dawn',
-  'day',
-  'deal',
-  'debate',
-  'debris',
-  'decade',
-  'december',
-  'decide',
-  'decline',
-  'decorate',
-  'decrease',
-  'deer',
-  'defense',
-  'define',
-  'defy',
-  'degree',
-  'delay',
-  'deliver',
-  'demand',
-  'demise',
-  'denial',
-  'dentist',
-  'deny',
-  'depart',
-  'depend',
-  'deposit',
-  'depth',
-  'deputy',
-  'derive',
-  'describe',
-  'desert',
-  'design',
-  'desk',
-  'despair',
-  'destroy',
-  'detail',
-  'detect',
-  'develop',
-  'device',
-  'devote',
-  'diagram',
-  'dial',
-  'diamond',
-  'diary',
-  'dice',
-  'diesel',
-  'diet',
-  'differ',
-  'digital',
-  'dignity',
-  'dilemma',
-  'dinner',
-  'dinosaur',
-  'direct',
-  'dirt',
-  'disagree',
-  'discover',
-  'disease',
-  'dish',
-  'dismiss',
-  'disorder',
-  'display',
-  'distance',
-  'divert',
-  'divide',
-  'divorce',
-  'dizzy',
-  'doctor',
-  'document',
-  'dog',
-  'doll',
-  'dolphin',
-  'domain',
-  'donate',
-  'donkey',
-  'donor',
-  'door',
-  'dose',
-  'double',
-  'dove',
-  'draft',
-  'dragon',
-  'drama',
-  'drastic',
-  'draw',
-  'dream',
-  'dress',
-  'drift',
-  'drill',
-  'drink',
-  'drip',
-  'drive',
-  'drop',
-  'drum',
-  'dry',
-  'duck',
-  'dumb',
-  'dune',
-  'during',
-  'dust',
-  'dutch',
-  'duty',
-  'dwarf',
-  'dynamic',
-  'eager',
-  'eagle',
-  'early',
-  'earn',
-  'earth',
-  'easily',
-  'east',
-  'easy',
-  'echo',
-  'ecology',
-  'economy',
-  'edge',
-  'edit',
-  'educate',
-  'effort',
-  'egg',
-  'eight',
-  'either',
-  'elbow',
-  'elder',
-  'electric',
-  'elegant',
-  'element',
-  'elephant',
-  'elevator',
-  'elite',
-  'else',
-  'embark',
-  'embody',
-  'embrace',
-  'emerge',
-  'emotion',
-  'employ',
-  'empower',
-  'empty',
-  'enable',
-  'enact',
-  'end',
-  'endless',
-  'endorse',
-  'enemy',
-  'energy',
-  'enforce',
-  'engage',
-  'engine',
-  'enhance',
-  'enjoy',
-  'enlist',
-  'enough',
-  'enrich',
-  'enroll',
-  'ensure',
-  'enter',
-  'entire',
-  'entry',
-  'envelope',
-  'episode',
-  'equal',
-  'equip',
-  'era',
-  'erase',
-  'erode',
-  'erosion',
-  'error',
-  'erupt',
-  'escape',
-  'essay',
-  'essence',
-  'estate',
-  'eternal',
-  'ethics',
-  'evidence',
-  'evil',
-  'evoke',
-  'evolve',
-  'exact',
-  'example',
-  'excess',
-  'exchange',
-  'excite',
-  'exclude',
-  'excuse',
-  'execute',
-  'exercise',
-  'exhaust',
-  'exhibit',
-  'exile',
-  'exist',
-  'exit',
-  'exotic',
-  'expand',
-  'expect',
-  'expire',
-  'explain',
-  'expose',
-  'express',
-  'extend',
-  'extra',
-  'eye',
-  'eyebrow',
-  'fabric',
-  'face',
-  'faculty',
-  'fade',
-  'faint',
-  'faith',
-  'fall',
-  'false',
-  'fame',
-  'family',
-  'famous',
-  'fan',
-  'fancy',
-  'fantasy',
-  'farm',
-  'fashion',
-  'fat',
-  'fatal',
-  'father',
-  'fatigue',
-  'fault',
-  'favorite',
-  'feature',
-  'february',
-  'federal',
-  'fee',
-  'feed',
-  'feel',
-  'female',
-  'fence',
-  'festival',
-  'fetch',
-  'fever',
-  'few',
-  'fiber',
-  'fiction',
-  'field',
-  'figure',
-  'file',
-  'film',
-  'filter',
-  'final',
-  'find',
-  'fine',
-  'finger',
-  'finish',
-  'fire',
-  'firm',
-  'first',
-  'fiscal',
-  'fish',
-  'fit',
-  'fitness',
-  'fix',
-  'flag',
-  'flame',
-  'flash',
-  'flat',
-  'flavor',
-  'flee',
-  'flight',
-  'flip',
-  'float',
-  'flock',
-  'floor',
-  'flower',
-  'fluid',
-  'flush',
-  'fly',
-  'foam',
-  'focus',
-  'fog',
-  'foil',
-  'fold',
-  'follow',
-  'food',
-  'foot',
-  'force',
-  'forest',
-  'forget',
-  'fork',
-  'fortune',
-  'forum',
-  'forward',
-  'fossil',
-  'foster',
-  'found',
-  'fox',
-  'fragile',
-  'frame',
-  'frequent',
-  'fresh',
-  'friend',
-  'fringe',
-  'frog',
-  'front',
-  'frost',
-  'frown',
-  'frozen',
-  'fruit',
-  'fuel',
-  'fun',
-  'funny',
-  'furnace',
-  'fury',
-  'future',
-  'gadget',
-  'gain',
-  'galaxy',
-  'gallery',
-  'game',
-  'gap',
-  'garage',
-  'garbage',
-  'garden',
-  'garlic',
-  'garment',
-  'gas',
-  'gasp',
-  'gate',
-  'gather',
-  'gauge',
-  'gaze',
-  'general',
-  'genius',
-  'genre',
-  'gentle',
-  'genuine',
-  'gesture',
-  'ghost',
-  'giant',
-  'gift',
-  'giggle',
-  'ginger',
-  'giraffe',
-  'girl',
-  'give',
-  'glad',
-  'glance',
-  'glare',
-  'glass',
-  'glide',
-  'glimpse',
-  'globe',
-  'gloom',
-  'glory',
-  'glove',
-  'glow',
-  'glue',
-  'goat',
-  'goddess',
-  'gold',
-  'good',
-  'goose',
-  'gorilla',
-  'gospel',
-  'gossip',
-  'govern',
-  'gown',
-  'grab',
-  'grace',
-  'grain',
-  'grant',
-  'grape',
-  'grass',
-  'gravity',
-  'great',
-  'green',
-  'grid',
-  'grief',
-  'grit',
-  'grocery',
-  'group',
-  'grow',
-  'grunt',
-  'guard',
-  'guess',
-  'guide',
-  'guilt',
-  'guitar',
-  'gun',
-  'gym',
-  'habit',
-  'hair',
-  'half',
-  'hammer',
-  'hamster',
-  'hand',
-  'happy',
-  'harbor',
-  'hard',
-  'harsh',
-  'harvest',
-  'hat',
-  'have',
-  'hawk',
-  'hazard',
-  'head',
-  'health',
-  'heart',
-  'heavy',
-  'hedgehog',
-  'height',
-  'hello',
-  'helmet',
-  'help',
-  'hen',
-  'hero',
-  'hidden',
-  'high',
-  'hill',
-  'hint',
-  'hip',
-  'hire',
-  'history',
-  'hobby',
-  'hockey',
-  'hold',
-  'hole',
-  'holiday',
-  'hollow',
-  'home',
-  'honey',
-  'hood',
-  'hope',
-  'horn',
-  'horror',
-  'horse',
-  'hospital',
-  'host',
-  'hotel',
-  'hour',
-  'hover',
-  'hub',
-  'huge',
-  'human',
-  'humble',
-  'humor',
-  'hundred',
-  'hungry',
-  'hunt',
-  'hurdle',
-  'hurry',
-  'hurt',
-  'husband',
-  'hybrid',
-  'ice',
-  'icon',
-  'idea',
-  'identify',
-  'idle',
-  'ignore',
-  'ill',
-  'illegal',
-  'illness',
-  'image',
-  'imitate',
-  'immense',
-  'immune',
-  'impact',
-  'impose',
-  'improve',
-  'impulse',
-  'inch',
-  'include',
-  'income',
-  'increase',
-  'index',
-  'indicate',
-  'indoor',
-  'industry',
-  'infant',
-  'inflict',
-  'inform',
-  'inhale',
-  'inherit',
-  'initial',
-  'inject',
-  'injury',
-  'inmate',
-  'inner',
-  'innocent',
-  'input',
-  'inquiry',
-  'insane',
-  'insect',
-  'inside',
-  'inspire',
-  'install',
-  'intact',
-  'interest',
-  'into',
-  'invest',
-  'invite',
-  'involve',
-  'iron',
-  'island',
-  'isolate',
-  'issue',
-  'item',
-  'ivory',
-  'jacket',
-  'jaguar',
-  'jar',
-  'jazz',
-  'jealous',
-  'jeans',
-  'jelly',
-  'jewel',
-  'job',
-  'join',
-  'joke',
-  'journey',
-  'joy',
-  'judge',
-  'juice',
-  'jump',
-  'jungle',
-  'junior',
-  'junk',
-  'just',
-  'kangaroo',
-  'keen',
-  'keep',
-  'ketchup',
-  'key',
-  'kick',
-  'kid',
-  'kidney',
-  'kind',
-  'kingdom',
-  'kiss',
-  'kit',
-  'kitchen',
-  'kite',
-  'kitten',
-  'kiwi',
-  'knee',
-  'knife',
-  'knock',
-  'know',
-  'lab',
-  'label',
-  'labor',
-  'ladder',
-  'lady',
-  'lake',
-  'lamp',
-  'language',
-  'laptop',
-  'large',
-  'later',
-  'latin',
-  'laugh',
-  'laundry',
-  'lava',
-  'law',
-  'lawn',
-  'lawsuit',
-  'layer',
-  'lazy',
-  'leader',
-  'leaf',
-  'learn',
-  'leave',
-  'lecture',
-  'left',
-  'leg',
-  'legal',
-  'legend',
-  'leisure',
-  'lemon',
-  'lend',
-  'length',
-  'lens',
-  'leopard',
-  'lesson',
-  'letter',
-  'level',
-  'liar',
-  'liberty',
-  'library',
-  'license',
-  'life',
-  'lift',
-  'light',
-  'like',
-  'limb',
-  'limit',
-  'link',
-  'lion',
-  'liquid',
-  'list',
-  'little',
-  'live',
-  'lizard',
-  'load',
-  'loan',
-  'lobster',
-  'local',
-  'lock',
-  'logic',
-  'lonely',
-  'long',
-  'loop',
-  'lottery',
-  'loud',
-  'lounge',
-  'love',
-  'loyal',
-  'lucky',
-  'luggage',
-  'lumber',
-  'lunar',
-  'lunch',
-  'luxury',
-  'lyrics',
-  'machine',
-  'mad',
-  'magic',
-  'magnet',
-  'maid',
-  'mail',
-  'main',
-  'major',
-  'make',
-  'mammal',
-  'man',
-  'manage',
-  'mandate',
-  'mango',
-  'mansion',
-  'manual',
-  'maple',
-  'marble',
-  'march',
-  'margin',
-  'marine',
-  'market',
-  'marriage',
-  'mask',
-  'mass',
-  'master',
-  'match',
-  'material',
-  'math',
-  'matrix',
-  'matter',
-  'maximum',
-  'maze',
-  'meadow',
-  'mean',
-  'measure',
-  'meat',
-  'mechanic',
-  'medal',
-  'media',
-  'melody',
-  'melt',
-  'member',
-  'memory',
-  'mention',
-  'menu',
-  'mercy',
-  'merge',
-  'merit',
-  'merry',
-  'mesh',
-  'message',
-  'metal',
-  'method',
-  'middle',
-  'midnight',
-  'milk',
-  'million',
-  'mimic',
-  'mind',
-  'minimum',
-  'minor',
-  'minute',
-  'miracle',
-  'mirror',
-  'misery',
-  'miss',
-  'mistake',
-  'mix',
-  'mixed',
-  'mixture',
-  'mobile',
-  'model',
-  'modify',
-  'mom',
-  'moment',
-  'monitor',
-  'monkey',
-  'monster',
-  'month',
-  'moon',
-  'moral',
-  'more',
-  'morning',
-  'mosquito',
-  'mother',
-  'motion',
-  'motor',
-  'mountain',
-  'mouse',
-  'move',
-  'movie',
-  'much',
-  'muffin',
-  'mule',
-  'multiply',
-  'muscle',
-  'museum',
-  'mushroom',
-  'music',
-  'must',
-  'mutual',
-  'myself',
-  'mystery',
-  'myth',
-  'naive',
-  'name',
-  'napkin',
-  'narrow',
-  'nasty',
-  'nation',
-  'nature',
-  'near',
-  'neck',
-  'need',
-  'negative',
-  'neglect',
-  'neither',
-  'nephew',
-  'nerve',
-  'nest',
-  'net',
-  'network',
-  'neutral',
-  'never',
-  'news',
-  'next',
-  'nice',
-  'night',
-  'noble',
-  'noise',
-  'nominee',
-  'noodle',
-  'normal',
-  'north',
-  'nose',
-  'notable',
-  'note',
-  'nothing',
-  'notice',
-  'novel',
-  'now',
-  'nuclear',
-  'number',
-  'nurse',
-  'nut',
-  'oak',
-  'obey',
-  'object',
-  'oblige',
-  'obscure',
-  'observe',
-  'obtain',
-  'obvious',
-  'occur',
-  'ocean',
-  'october',
-  'odor',
-  'off',
-  'offer',
-  'office',
-  'often',
-  'oil',
-  'okay',
-  'old',
-  'olive',
-  'olympic',
-  'omit',
-  'once',
-  'one',
-  'onion',
-  'online',
-  'only',
-  'open',
-  'opera',
-  'opinion',
-  'oppose',
-  'option',
-  'orange',
-  'orbit',
-  'orchard',
-  'order',
-  'ordinary',
-  'organ',
-  'orient',
-  'original',
-  'orphan',
-  'ostrich',
-  'other',
-  'outdoor',
-  'outer',
-  'output',
-  'outside',
-  'oval',
-  'oven',
-  'over',
-  'own',
-  'owner',
-  'oxygen',
-  'oyster',
-  'ozone',
-  'pact',
-  'paddle',
-  'page',
-  'pair',
-  'palace',
-  'palm',
-  'panda',
-  'panel',
-  'panic',
-  'panther',
-  'paper',
-  'parade',
-  'parent',
-  'park',
-  'parrot',
-  'party',
-  'pass',
-  'patch',
-  'path',
-  'patient',
-  'patrol',
-  'pattern',
-  'pause',
-  'pave',
-  'payment',
-  'peace',
-  'peanut',
-  'pear',
-  'peasant',
-  'pelican',
-  'pen',
-  'penalty',
-  'pencil',
-  'people',
-  'pepper',
-  'perfect',
-  'permit',
-  'person',
-  'pet',
-  'phone',
-  'photo',
-  'phrase',
-  'physical',
-  'piano',
-  'picnic',
-  'picture',
-  'piece',
-  'pig',
-  'pigeon',
-  'pill',
-  'pilot',
-  'pink',
-  'pioneer',
-  'pipe',
-  'pistol',
-  'pitch',
-  'pizza',
-  'place',
-  'planet',
-  'plastic',
-  'plate',
-  'play',
-  'please',
-  'pledge',
-  'pluck',
-  'plug',
-  'plunge',
-  'poem',
-  'poet',
-  'point',
-  'polar',
-  'pole',
-  'police',
-  'pond',
-  'pony',
-  'pool',
-  'popular',
-  'portion',
-  'position',
-  'possible',
-  'post',
-  'potato',
-  'pottery',
-  'poverty',
-  'powder',
-  'power',
-  'practice',
-  'praise',
-  'predict',
-  'prefer',
-  'prepare',
-  'present',
-  'pretty',
-  'prevent',
-  'price',
-  'pride',
-  'primary',
-  'print',
-  'priority',
-  'prison',
-  'private',
-  'prize',
-  'problem',
-  'process',
-  'produce',
-  'profit',
-  'program',
-  'project',
-  'promote',
-  'proof',
-  'property',
-  'prosper',
-  'protect',
-  'proud',
-  'provide',
-  'public',
-  'pudding',
-  'pull',
-  'pulp',
-  'pulse',
-  'pumpkin',
-  'punch',
-  'pupil',
-  'puppy',
-  'purchase',
-  'purity',
-  'purpose',
-  'purse',
-  'push',
-  'put',
-  'puzzle',
-  'pyramid',
-  'quality',
-  'quantum',
-  'quarter',
-  'question',
-  'quick',
-  'quit',
-  'quiz',
-  'quote',
-  'rabbit',
-  'raccoon',
-  'race',
-  'rack',
-  'radar',
-  'radio',
-  'rail',
-  'rain',
-  'raise',
-  'rally',
-  'ramp',
-  'ranch',
-  'random',
-  'range',
-  'rapid',
-  'rare',
-  'rate',
-  'rather',
-  'raven',
-  'raw',
-  'razor',
-  'ready',
-  'real',
-  'reason',
-  'rebel',
-  'rebuild',
-  'recall',
-  'receive',
-  'recipe',
-  'record',
-  'recycle',
-  'reduce',
-  'reflect',
-  'reform',
-  'refuse',
-  'region',
-  'regret',
-  'regular',
-  'reject',
-  'relax',
-  'release',
-  'relief',
-  'rely',
-  'remain',
-  'remember',
-  'remind',
-  'remove',
-  'render',
-  'renew',
-  'rent',
-  'reopen',
-  'repair',
-  'repeat',
-  'replace',
-  'report',
-  'require',
-  'rescue',
-  'resemble',
-  'resist',
-  'resource',
-  'response',
-  'result',
-  'retire',
-  'retreat',
-  'return',
-  'reunion',
-  'reveal',
-  'review',
-  'reward',
-  'rhythm',
-  'rib',
-  'ribbon',
-  'rice',
-  'rich',
-  'ride',
-  'ridge',
-  'rifle',
-  'right',
-  'rigid',
-  'ring',
-  'riot',
-  'ripple',
-  'risk',
-  'ritual',
-  'rival',
-  'river',
-  'road',
-  'roast',
-  'robot',
-  'robust',
-  'rocket',
-  'romance',
-  'roof',
-  'rookie',
-  'room',
-  'rose',
-  'rotate',
-  'rough',
-  'round',
-  'route',
-  'royal',
-  'rubber',
-  'rude',
-  'rug',
-  'rule',
-  'run',
-  'runway',
-  'rural',
-  'sad',
-  'saddle',
-  'sadness',
-  'safe',
-  'sail',
-  'salad',
-  'salmon',
-  'salon',
-  'salt',
-  'salute',
-  'same',
-  'sample',
-  'sand',
-  'satisfy',
-  'satoshi',
-  'sauce',
-  'sausage',
-  'save',
-  'say',
-  'scale',
-  'scan',
-  'scare',
-  'scatter',
-  'scene',
-  'scheme',
-  'school',
-  'science',
-  'scissors',
-  'scorpion',
-  'scout',
-  'scrap',
-  'screen',
-  'script',
-  'scrub',
-  'sea',
-  'search',
-  'season',
-  'seat',
-  'second',
-  'secret',
-  'section',
-  'security',
-  'seed',
-  'seek',
-  'segment',
-  'select',
-  'sell',
-  'seminar',
-  'senior',
-  'sense',
-  'sentence',
-  'series',
-  'service',
-  'session',
-  'settle',
-  'setup',
-  'seven',
-  'shadow',
-  'shaft',
-  'shallow',
-  'share',
-  'shed',
-  'shell',
-  'sheriff',
-  'shield',
-  'shift',
-  'shine',
-  'ship',
-  'shiver',
-  'shock',
-  'shoe',
-  'shoot',
-  'shop',
-  'short',
-  'shoulder',
-  'shove',
-  'shrimp',
-  'shrug',
-  'shuffle',
-  'shy',
-  'sibling',
-  'sick',
-  'side',
-  'siege',
-  'sight',
-  'sign',
-  'silent',
-  'silk',
-  'silly',
-  'silver',
-  'similar',
-  'simple',
-  'since',
-  'sing',
-  'siren',
-  'sister',
-  'situate',
-  'six',
-  'size',
-  'skate',
-  'sketch',
-  'ski',
-  'skill',
-  'skin',
-  'skirt',
-  'skull',
-  'slab',
-  'slam',
-  'sleep',
-  'slender',
-  'slice',
-  'slide',
-  'slight',
-  'slim',
-  'slogan',
-  'slot',
-  'slow',
-  'slush',
-  'small',
-  'smart',
-  'smile',
-  'smoke',
-  'smooth',
-  'snack',
-  'snake',
-  'snap',
-  'sniff',
-  'snow',
-  'soap',
-  'soccer',
-  'social',
-  'sock',
-  'soda',
-  'soft',
-  'solar',
-  'soldier',
-  'solid',
-  'solution',
-  'solve',
-  'someone',
-  'song',
-  'soon',
-  'sorry',
-  'sort',
-  'soul',
-  'sound',
-  'soup',
-  'source',
-  'south',
-  'space',
-  'spare',
-  'spatial',
-  'spawn',
-  'speak',
-  'special',
-  'speed',
-  'spell',
-  'spend',
-  'sphere',
-  'spice',
-  'spider',
-  'spike',
-  'spin',
-  'spirit',
-  'split',
-  'spoil',
-  'sponsor',
-  'spoon',
-  'sport',
-  'spot',
-  'spray',
-  'spread',
-  'spring',
-  'spy',
-  'square',
-  'squeeze',
-  'squirrel',
-  'stable',
-  'stadium',
-  'staff',
-  'stage',
-  'stairs',
-  'stamp',
-  'stand',
-  'start',
-  'state',
-  'stay',
-  'steak',
-  'steel',
-  'stem',
-  'step',
-  'stereo',
-  'stick',
-  'still',
-  'sting',
-  'stock',
-  'stomach',
-  'stone',
-  'stool',
-  'story',
-  'stove',
-  'strategy',
-  'street',
-  'strike',
-  'strong',
-  'struggle',
-  'student',
-  'stuff',
-  'stumble',
-  'style',
-  'subject',
-  'submit',
-  'subway',
-  'success',
-  'such',
-  'sudden',
-  'suffer',
-  'sugar',
-  'suggest',
-  'suit',
-  'summer',
-  'sun',
-  'sunny',
-  'sunset',
-  'super',
-  'supply',
-  'supreme',
-  'sure',
-  'surface',
-  'surge',
-  'surprise',
-  'surround',
-  'survey',
-  'suspect',
-  'sustain',
-  'swallow',
-  'swamp',
-  'swap',
-  'swarm',
-  'swear',
-  'sweet',
-  'swift',
-  'swim',
-  'swing',
-  'switch',
-  'sword',
-  'symbol',
-  'symptom',
-  'syrup',
-  'system',
-  'table',
-  'tackle',
-  'tag',
-  'tail',
-  'talent',
-  'talk',
-  'tank',
-  'tape',
-  'target',
-  'task',
-  'taste',
-  'tattoo',
-  'taxi',
-  'teach',
-  'team',
-  'tell',
-  'ten',
-  'tenant',
-  'tennis',
-  'tent',
-  'term',
-  'test',
-  'text',
-  'thank',
-  'that',
-  'theme',
-  'then',
-  'theory',
-  'there',
-  'they',
-  'thing',
-  'this',
-  'thought',
-  'three',
-  'thrive',
-  'throw',
-  'thumb',
-  'thunder',
-  'ticket',
-  'tide',
-  'tiger',
-  'tilt',
-  'timber',
-  'time',
-  'tiny',
-  'tip',
-  'tired',
-  'tissue',
-  'title',
-  'toast',
-  'tobacco',
-  'today',
-  'toddler',
-  'toe',
-  'together',
-  'toilet',
-  'token',
-  'tomato',
-  'tomorrow',
-  'tone',
-  'tongue',
-  'tonight',
-  'tool',
-  'tooth',
-  'top',
-  'topic',
-  'topple',
-  'torch',
-  'tornado',
-  'tortoise',
-  'toss',
-  'total',
-  'tourist',
-  'toward',
-  'tower',
-  'town',
-  'toy',
-  'track',
-  'trade',
-  'traffic',
-  'tragic',
-  'train',
-  'transfer',
-  'trap',
-  'trash',
-  'travel',
-  'tray',
-  'treat',
-  'tree',
-  'trend',
-  'trial',
-  'tribe',
-  'trick',
-  'trigger',
-  'trim',
-  'trip',
-  'trophy',
-  'trouble',
-  'truck',
-  'true',
-  'truly',
-  'trumpet',
-  'trust',
-  'truth',
-  'try',
-  'tube',
-  'tuition',
-  'tumble',
-  'tuna',
-  'tunnel',
-  'turkey',
-  'turn',
-  'turtle',
-  'twelve',
-  'twenty',
-  'twice',
-  'twin',
-  'twist',
-  'two',
-  'type',
-  'typical',
-  'ugly',
-  'umbrella',
-  'unable',
-  'unaware',
-  'uncle',
-  'uncover',
-  'under',
-  'undo',
-  'unfair',
-  'unfold',
-  'unhappy',
-  'uniform',
-  'unique',
-  'unit',
-  'universe',
-  'unknown',
-  'unlock',
-  'until',
-  'unusual',
-  'unveil',
-  'update',
-  'upgrade',
-  'uphold',
-  'upon',
-  'upper',
-  'upset',
-  'urban',
-  'urge',
-  'usage',
-  'use',
-  'used',
-  'useful',
-  'useless',
-  'usual',
-  'utility',
-  'vacant',
-  'vacuum',
-  'vague',
-  'valid',
-  'valley',
-  'valve',
-  'van',
-  'vanish',
-  'vapor',
-  'various',
-  'vast',
-  'vault',
-  'vehicle',
-  'velvet',
-  'vendor',
-  'venture',
-  'venue',
-  'verb',
-  'verify',
-  'version',
-  'very',
-  'vessel',
-  'veteran',
-  'viable',
-  'vibrant',
-  'vicious',
-  'victory',
-  'video',
-  'view',
-  'village',
-  'vintage',
-  'violin',
-  'virtual',
-  'virus',
-  'visa',
-  'visit',
-  'visual',
-  'vital',
-  'vivid',
-  'vocal',
-  'voice',
-  'void',
-  'volcano',
-  'volume',
-  'vote',
-  'voyage',
-  'wage',
-  'wagon',
-  'wait',
-  'walk',
-  'wall',
-  'walnut',
-  'want',
-  'warfare',
-  'warm',
-  'warrior',
-  'wash',
-  'wasp',
-  'waste',
-  'water',
-  'wave',
-  'way',
-  'wealth',
-  'weapon',
-  'wear',
-  'weasel',
-  'weather',
-  'web',
-  'wedding',
-  'weekend',
-  'weird',
-  'welcome',
-  'west',
-  'wet',
-  'whale',
-  'what',
-  'wheat',
-  'wheel',
-  'when',
-  'where',
-  'whip',
-  'whisper',
-  'wide',
-  'width',
-  'wife',
-  'wild',
-  'will',
-  'win',
-  'window',
-  'wine',
-  'wing',
-  'wink',
-  'winner',
-  'winter',
-  'wire',
-  'wisdom',
-  'wise',
-  'wish',
-  'witness',
-  'wolf',
-  'woman',
-  'wonder',
-  'wood',
-  'wool',
-  'word',
-  'work',
-  'world',
-  'worry',
-  'worth',
-  'wrap',
-  'wreck',
-  'wrestle',
-  'wrist',
-  'write',
-  'wrong',
-  'yard',
-  'year',
-  'yellow',
-  'you',
-  'young',
-  'youth',
-  'zebra',
-  'zero',
-  'zone',
-  'zoo'
+    'abandon',
+    'ability',
+    'able',
+    'about',
+    'above',
+    'absent',
+    'absorb',
+    'abstract',
+    'absurd',
+    'abuse',
+    'access',
+    'accident',
+    'account',
+    'accuse',
+    'achieve',
+    'acid',
+    'acoustic',
+    'acquire',
+    'across',
+    'act',
+    'action',
+    'actor',
+    'actress',
+    'actual',
+    'adapt',
+    'add',
+    'addict',
+    'address',
+    'adjust',
+    'admit',
+    'adult',
+    'advance',
+    'advice',
+    'aerobic',
+    'affair',
+    'afford',
+    'afraid',
+    'again',
+    'age',
+    'agent',
+    'agree',
+    'ahead',
+    'aim',
+    'air',
+    'airport',
+    'aisle',
+    'alarm',
+    'album',
+    'alcohol',
+    'alert',
+    'alien',
+    'all',
+    'alley',
+    'allow',
+    'almost',
+    'alone',
+    'alpha',
+    'already',
+    'also',
+    'alter',
+    'always',
+    'amateur',
+    'amazing',
+    'among',
+    'amount',
+    'amused',
+    'analyst',
+    'anchor',
+    'ancient',
+    'anger',
+    'angle',
+    'angry',
+    'animal',
+    'ankle',
+    'announce',
+    'annual',
+    'another',
+    'answer',
+    'antenna',
+    'antique',
+    'anxiety',
+    'any',
+    'apart',
+    'apology',
+    'appear',
+    'apple',
+    'approve',
+    'april',
+    'arch',
+    'arctic',
+    'area',
+    'arena',
+    'argue',
+    'arm',
+    'armed',
+    'armor',
+    'army',
+    'around',
+    'arrange',
+    'arrest',
+    'arrive',
+    'arrow',
+    'art',
+    'artefact',
+    'artist',
+    'artwork',
+    'ask',
+    'aspect',
+    'assault',
+    'asset',
+    'assist',
+    'assume',
+    'asthma',
+    'athlete',
+    'atom',
+    'attack',
+    'attend',
+    'attitude',
+    'attract',
+    'auction',
+    'audit',
+    'august',
+    'aunt',
+    'author',
+    'auto',
+    'autumn',
+    'average',
+    'avocado',
+    'avoid',
+    'awake',
+    'aware',
+    'away',
+    'awesome',
+    'awful',
+    'awkward',
+    'axis',
+    'baby',
+    'bachelor',
+    'bacon',
+    'badge',
+    'bag',
+    'balance',
+    'balcony',
+    'ball',
+    'bamboo',
+    'banana',
+    'banner',
+    'bar',
+    'barely',
+    'bargain',
+    'barrel',
+    'base',
+    'basic',
+    'basket',
+    'battle',
+    'beach',
+    'bean',
+    'beauty',
+    'because',
+    'become',
+    'beef',
+    'before',
+    'begin',
+    'behave',
+    'behind',
+    'believe',
+    'below',
+    'belt',
+    'bench',
+    'benefit',
+    'best',
+    'betray',
+    'better',
+    'between',
+    'beyond',
+    'bicycle',
+    'bid',
+    'bike',
+    'bind',
+    'biology',
+    'bird',
+    'birth',
+    'bitter',
+    'black',
+    'blade',
+    'blame',
+    'blanket',
+    'blast',
+    'bleak',
+    'bless',
+    'blind',
+    'blood',
+    'blossom',
+    'blouse',
+    'blue',
+    'blur',
+    'blush',
+    'board',
+    'boat',
+    'body',
+    'boil',
+    'bomb',
+    'bone',
+    'bonus',
+    'book',
+    'boost',
+    'border',
+    'boring',
+    'borrow',
+    'boss',
+    'bottom',
+    'bounce',
+    'box',
+    'boy',
+    'bracket',
+    'brain',
+    'brand',
+    'brass',
+    'brave',
+    'bread',
+    'breeze',
+    'brick',
+    'bridge',
+    'brief',
+    'bright',
+    'bring',
+    'brisk',
+    'broccoli',
+    'broken',
+    'bronze',
+    'broom',
+    'brother',
+    'brown',
+    'brush',
+    'bubble',
+    'buddy',
+    'budget',
+    'buffalo',
+    'build',
+    'bulb',
+    'bulk',
+    'bullet',
+    'bundle',
+    'bunker',
+    'burden',
+    'burger',
+    'burst',
+    'bus',
+    'business',
+    'busy',
+    'butter',
+    'buyer',
+    'buzz',
+    'cabbage',
+    'cabin',
+    'cable',
+    'cactus',
+    'cage',
+    'cake',
+    'call',
+    'calm',
+    'camera',
+    'camp',
+    'can',
+    'canal',
+    'cancel',
+    'candy',
+    'cannon',
+    'canoe',
+    'canvas',
+    'canyon',
+    'capable',
+    'capital',
+    'captain',
+    'car',
+    'carbon',
+    'card',
+    'cargo',
+    'carpet',
+    'carry',
+    'cart',
+    'case',
+    'cash',
+    'casino',
+    'castle',
+    'casual',
+    'cat',
+    'catalog',
+    'catch',
+    'category',
+    'cattle',
+    'caught',
+    'cause',
+    'caution',
+    'cave',
+    'ceiling',
+    'celery',
+    'cement',
+    'census',
+    'century',
+    'cereal',
+    'certain',
+    'chair',
+    'chalk',
+    'champion',
+    'change',
+    'chaos',
+    'chapter',
+    'charge',
+    'chase',
+    'chat',
+    'cheap',
+    'check',
+    'cheese',
+    'chef',
+    'cherry',
+    'chest',
+    'chicken',
+    'chief',
+    'child',
+    'chimney',
+    'choice',
+    'choose',
+    'chronic',
+    'chuckle',
+    'chunk',
+    'churn',
+    'cigar',
+    'cinnamon',
+    'circle',
+    'citizen',
+    'city',
+    'civil',
+    'claim',
+    'clap',
+    'clarify',
+    'claw',
+    'clay',
+    'clean',
+    'clerk',
+    'clever',
+    'click',
+    'client',
+    'cliff',
+    'climb',
+    'clinic',
+    'clip',
+    'clock',
+    'clog',
+    'close',
+    'cloth',
+    'cloud',
+    'clown',
+    'club',
+    'clump',
+    'cluster',
+    'clutch',
+    'coach',
+    'coast',
+    'coconut',
+    'code',
+    'coffee',
+    'coil',
+    'coin',
+    'collect',
+    'color',
+    'column',
+    'combine',
+    'come',
+    'comfort',
+    'comic',
+    'common',
+    'company',
+    'concert',
+    'conduct',
+    'confirm',
+    'congress',
+    'connect',
+    'consider',
+    'control',
+    'convince',
+    'cook',
+    'cool',
+    'copper',
+    'copy',
+    'coral',
+    'core',
+    'corn',
+    'correct',
+    'cost',
+    'cotton',
+    'couch',
+    'country',
+    'couple',
+    'course',
+    'cousin',
+    'cover',
+    'coyote',
+    'crack',
+    'cradle',
+    'craft',
+    'cram',
+    'crane',
+    'crash',
+    'crater',
+    'crawl',
+    'crazy',
+    'cream',
+    'credit',
+    'creek',
+    'crew',
+    'cricket',
+    'crime',
+    'crisp',
+    'critic',
+    'crop',
+    'cross',
+    'crouch',
+    'crowd',
+    'crucial',
+    'cruel',
+    'cruise',
+    'crumble',
+    'crunch',
+    'crush',
+    'cry',
+    'crystal',
+    'cube',
+    'culture',
+    'cup',
+    'cupboard',
+    'curious',
+    'current',
+    'curtain',
+    'curve',
+    'cushion',
+    'custom',
+    'cute',
+    'cycle',
+    'dad',
+    'damage',
+    'damp',
+    'dance',
+    'danger',
+    'daring',
+    'dash',
+    'daughter',
+    'dawn',
+    'day',
+    'deal',
+    'debate',
+    'debris',
+    'decade',
+    'december',
+    'decide',
+    'decline',
+    'decorate',
+    'decrease',
+    'deer',
+    'defense',
+    'define',
+    'defy',
+    'degree',
+    'delay',
+    'deliver',
+    'demand',
+    'demise',
+    'denial',
+    'dentist',
+    'deny',
+    'depart',
+    'depend',
+    'deposit',
+    'depth',
+    'deputy',
+    'derive',
+    'describe',
+    'desert',
+    'design',
+    'desk',
+    'despair',
+    'destroy',
+    'detail',
+    'detect',
+    'develop',
+    'device',
+    'devote',
+    'diagram',
+    'dial',
+    'diamond',
+    'diary',
+    'dice',
+    'diesel',
+    'diet',
+    'differ',
+    'digital',
+    'dignity',
+    'dilemma',
+    'dinner',
+    'dinosaur',
+    'direct',
+    'dirt',
+    'disagree',
+    'discover',
+    'disease',
+    'dish',
+    'dismiss',
+    'disorder',
+    'display',
+    'distance',
+    'divert',
+    'divide',
+    'divorce',
+    'dizzy',
+    'doctor',
+    'document',
+    'dog',
+    'doll',
+    'dolphin',
+    'domain',
+    'donate',
+    'donkey',
+    'donor',
+    'door',
+    'dose',
+    'double',
+    'dove',
+    'draft',
+    'dragon',
+    'drama',
+    'drastic',
+    'draw',
+    'dream',
+    'dress',
+    'drift',
+    'drill',
+    'drink',
+    'drip',
+    'drive',
+    'drop',
+    'drum',
+    'dry',
+    'duck',
+    'dumb',
+    'dune',
+    'during',
+    'dust',
+    'dutch',
+    'duty',
+    'dwarf',
+    'dynamic',
+    'eager',
+    'eagle',
+    'early',
+    'earn',
+    'earth',
+    'easily',
+    'east',
+    'easy',
+    'echo',
+    'ecology',
+    'economy',
+    'edge',
+    'edit',
+    'educate',
+    'effort',
+    'egg',
+    'eight',
+    'either',
+    'elbow',
+    'elder',
+    'electric',
+    'elegant',
+    'element',
+    'elephant',
+    'elevator',
+    'elite',
+    'else',
+    'embark',
+    'embody',
+    'embrace',
+    'emerge',
+    'emotion',
+    'employ',
+    'empower',
+    'empty',
+    'enable',
+    'enact',
+    'end',
+    'endless',
+    'endorse',
+    'enemy',
+    'energy',
+    'enforce',
+    'engage',
+    'engine',
+    'enhance',
+    'enjoy',
+    'enlist',
+    'enough',
+    'enrich',
+    'enroll',
+    'ensure',
+    'enter',
+    'entire',
+    'entry',
+    'envelope',
+    'episode',
+    'equal',
+    'equip',
+    'era',
+    'erase',
+    'erode',
+    'erosion',
+    'error',
+    'erupt',
+    'escape',
+    'essay',
+    'essence',
+    'estate',
+    'eternal',
+    'ethics',
+    'evidence',
+    'evil',
+    'evoke',
+    'evolve',
+    'exact',
+    'example',
+    'excess',
+    'exchange',
+    'excite',
+    'exclude',
+    'excuse',
+    'execute',
+    'exercise',
+    'exhaust',
+    'exhibit',
+    'exile',
+    'exist',
+    'exit',
+    'exotic',
+    'expand',
+    'expect',
+    'expire',
+    'explain',
+    'expose',
+    'express',
+    'extend',
+    'extra',
+    'eye',
+    'eyebrow',
+    'fabric',
+    'face',
+    'faculty',
+    'fade',
+    'faint',
+    'faith',
+    'fall',
+    'false',
+    'fame',
+    'family',
+    'famous',
+    'fan',
+    'fancy',
+    'fantasy',
+    'farm',
+    'fashion',
+    'fat',
+    'fatal',
+    'father',
+    'fatigue',
+    'fault',
+    'favorite',
+    'feature',
+    'february',
+    'federal',
+    'fee',
+    'feed',
+    'feel',
+    'female',
+    'fence',
+    'festival',
+    'fetch',
+    'fever',
+    'few',
+    'fiber',
+    'fiction',
+    'field',
+    'figure',
+    'file',
+    'film',
+    'filter',
+    'final',
+    'find',
+    'fine',
+    'finger',
+    'finish',
+    'fire',
+    'firm',
+    'first',
+    'fiscal',
+    'fish',
+    'fit',
+    'fitness',
+    'fix',
+    'flag',
+    'flame',
+    'flash',
+    'flat',
+    'flavor',
+    'flee',
+    'flight',
+    'flip',
+    'float',
+    'flock',
+    'floor',
+    'flower',
+    'fluid',
+    'flush',
+    'fly',
+    'foam',
+    'focus',
+    'fog',
+    'foil',
+    'fold',
+    'follow',
+    'food',
+    'foot',
+    'force',
+    'forest',
+    'forget',
+    'fork',
+    'fortune',
+    'forum',
+    'forward',
+    'fossil',
+    'foster',
+    'found',
+    'fox',
+    'fragile',
+    'frame',
+    'frequent',
+    'fresh',
+    'friend',
+    'fringe',
+    'frog',
+    'front',
+    'frost',
+    'frown',
+    'frozen',
+    'fruit',
+    'fuel',
+    'fun',
+    'funny',
+    'furnace',
+    'fury',
+    'future',
+    'gadget',
+    'gain',
+    'galaxy',
+    'gallery',
+    'game',
+    'gap',
+    'garage',
+    'garbage',
+    'garden',
+    'garlic',
+    'garment',
+    'gas',
+    'gasp',
+    'gate',
+    'gather',
+    'gauge',
+    'gaze',
+    'general',
+    'genius',
+    'genre',
+    'gentle',
+    'genuine',
+    'gesture',
+    'ghost',
+    'giant',
+    'gift',
+    'giggle',
+    'ginger',
+    'giraffe',
+    'girl',
+    'give',
+    'glad',
+    'glance',
+    'glare',
+    'glass',
+    'glide',
+    'glimpse',
+    'globe',
+    'gloom',
+    'glory',
+    'glove',
+    'glow',
+    'glue',
+    'goat',
+    'goddess',
+    'gold',
+    'good',
+    'goose',
+    'gorilla',
+    'gospel',
+    'gossip',
+    'govern',
+    'gown',
+    'grab',
+    'grace',
+    'grain',
+    'grant',
+    'grape',
+    'grass',
+    'gravity',
+    'great',
+    'green',
+    'grid',
+    'grief',
+    'grit',
+    'grocery',
+    'group',
+    'grow',
+    'grunt',
+    'guard',
+    'guess',
+    'guide',
+    'guilt',
+    'guitar',
+    'gun',
+    'gym',
+    'habit',
+    'hair',
+    'half',
+    'hammer',
+    'hamster',
+    'hand',
+    'happy',
+    'harbor',
+    'hard',
+    'harsh',
+    'harvest',
+    'hat',
+    'have',
+    'hawk',
+    'hazard',
+    'head',
+    'health',
+    'heart',
+    'heavy',
+    'hedgehog',
+    'height',
+    'hello',
+    'helmet',
+    'help',
+    'hen',
+    'hero',
+    'hidden',
+    'high',
+    'hill',
+    'hint',
+    'hip',
+    'hire',
+    'history',
+    'hobby',
+    'hockey',
+    'hold',
+    'hole',
+    'holiday',
+    'hollow',
+    'home',
+    'honey',
+    'hood',
+    'hope',
+    'horn',
+    'horror',
+    'horse',
+    'hospital',
+    'host',
+    'hotel',
+    'hour',
+    'hover',
+    'hub',
+    'huge',
+    'human',
+    'humble',
+    'humor',
+    'hundred',
+    'hungry',
+    'hunt',
+    'hurdle',
+    'hurry',
+    'hurt',
+    'husband',
+    'hybrid',
+    'ice',
+    'icon',
+    'idea',
+    'identify',
+    'idle',
+    'ignore',
+    'ill',
+    'illegal',
+    'illness',
+    'image',
+    'imitate',
+    'immense',
+    'immune',
+    'impact',
+    'impose',
+    'improve',
+    'impulse',
+    'inch',
+    'include',
+    'income',
+    'increase',
+    'index',
+    'indicate',
+    'indoor',
+    'industry',
+    'infant',
+    'inflict',
+    'inform',
+    'inhale',
+    'inherit',
+    'initial',
+    'inject',
+    'injury',
+    'inmate',
+    'inner',
+    'innocent',
+    'input',
+    'inquiry',
+    'insane',
+    'insect',
+    'inside',
+    'inspire',
+    'install',
+    'intact',
+    'interest',
+    'into',
+    'invest',
+    'invite',
+    'involve',
+    'iron',
+    'island',
+    'isolate',
+    'issue',
+    'item',
+    'ivory',
+    'jacket',
+    'jaguar',
+    'jar',
+    'jazz',
+    'jealous',
+    'jeans',
+    'jelly',
+    'jewel',
+    'job',
+    'join',
+    'joke',
+    'journey',
+    'joy',
+    'judge',
+    'juice',
+    'jump',
+    'jungle',
+    'junior',
+    'junk',
+    'just',
+    'kangaroo',
+    'keen',
+    'keep',
+    'ketchup',
+    'key',
+    'kick',
+    'kid',
+    'kidney',
+    'kind',
+    'kingdom',
+    'kiss',
+    'kit',
+    'kitchen',
+    'kite',
+    'kitten',
+    'kiwi',
+    'knee',
+    'knife',
+    'knock',
+    'know',
+    'lab',
+    'label',
+    'labor',
+    'ladder',
+    'lady',
+    'lake',
+    'lamp',
+    'language',
+    'laptop',
+    'large',
+    'later',
+    'latin',
+    'laugh',
+    'laundry',
+    'lava',
+    'law',
+    'lawn',
+    'lawsuit',
+    'layer',
+    'lazy',
+    'leader',
+    'leaf',
+    'learn',
+    'leave',
+    'lecture',
+    'left',
+    'leg',
+    'legal',
+    'legend',
+    'leisure',
+    'lemon',
+    'lend',
+    'length',
+    'lens',
+    'leopard',
+    'lesson',
+    'letter',
+    'level',
+    'liar',
+    'liberty',
+    'library',
+    'license',
+    'life',
+    'lift',
+    'light',
+    'like',
+    'limb',
+    'limit',
+    'link',
+    'lion',
+    'liquid',
+    'list',
+    'little',
+    'live',
+    'lizard',
+    'load',
+    'loan',
+    'lobster',
+    'local',
+    'lock',
+    'logic',
+    'lonely',
+    'long',
+    'loop',
+    'lottery',
+    'loud',
+    'lounge',
+    'love',
+    'loyal',
+    'lucky',
+    'luggage',
+    'lumber',
+    'lunar',
+    'lunch',
+    'luxury',
+    'lyrics',
+    'machine',
+    'mad',
+    'magic',
+    'magnet',
+    'maid',
+    'mail',
+    'main',
+    'major',
+    'make',
+    'mammal',
+    'man',
+    'manage',
+    'mandate',
+    'mango',
+    'mansion',
+    'manual',
+    'maple',
+    'marble',
+    'march',
+    'margin',
+    'marine',
+    'market',
+    'marriage',
+    'mask',
+    'mass',
+    'master',
+    'match',
+    'material',
+    'math',
+    'matrix',
+    'matter',
+    'maximum',
+    'maze',
+    'meadow',
+    'mean',
+    'measure',
+    'meat',
+    'mechanic',
+    'medal',
+    'media',
+    'melody',
+    'melt',
+    'member',
+    'memory',
+    'mention',
+    'menu',
+    'mercy',
+    'merge',
+    'merit',
+    'merry',
+    'mesh',
+    'message',
+    'metal',
+    'method',
+    'middle',
+    'midnight',
+    'milk',
+    'million',
+    'mimic',
+    'mind',
+    'minimum',
+    'minor',
+    'minute',
+    'miracle',
+    'mirror',
+    'misery',
+    'miss',
+    'mistake',
+    'mix',
+    'mixed',
+    'mixture',
+    'mobile',
+    'model',
+    'modify',
+    'mom',
+    'moment',
+    'monitor',
+    'monkey',
+    'monster',
+    'month',
+    'moon',
+    'moral',
+    'more',
+    'morning',
+    'mosquito',
+    'mother',
+    'motion',
+    'motor',
+    'mountain',
+    'mouse',
+    'move',
+    'movie',
+    'much',
+    'muffin',
+    'mule',
+    'multiply',
+    'muscle',
+    'museum',
+    'mushroom',
+    'music',
+    'must',
+    'mutual',
+    'myself',
+    'mystery',
+    'myth',
+    'naive',
+    'name',
+    'napkin',
+    'narrow',
+    'nasty',
+    'nation',
+    'nature',
+    'near',
+    'neck',
+    'need',
+    'negative',
+    'neglect',
+    'neither',
+    'nephew',
+    'nerve',
+    'nest',
+    'net',
+    'network',
+    'neutral',
+    'never',
+    'news',
+    'next',
+    'nice',
+    'night',
+    'noble',
+    'noise',
+    'nominee',
+    'noodle',
+    'normal',
+    'north',
+    'nose',
+    'notable',
+    'note',
+    'nothing',
+    'notice',
+    'novel',
+    'now',
+    'nuclear',
+    'number',
+    'nurse',
+    'nut',
+    'oak',
+    'obey',
+    'object',
+    'oblige',
+    'obscure',
+    'observe',
+    'obtain',
+    'obvious',
+    'occur',
+    'ocean',
+    'october',
+    'odor',
+    'off',
+    'offer',
+    'office',
+    'often',
+    'oil',
+    'okay',
+    'old',
+    'olive',
+    'olympic',
+    'omit',
+    'once',
+    'one',
+    'onion',
+    'online',
+    'only',
+    'open',
+    'opera',
+    'opinion',
+    'oppose',
+    'option',
+    'orange',
+    'orbit',
+    'orchard',
+    'order',
+    'ordinary',
+    'organ',
+    'orient',
+    'original',
+    'orphan',
+    'ostrich',
+    'other',
+    'outdoor',
+    'outer',
+    'output',
+    'outside',
+    'oval',
+    'oven',
+    'over',
+    'own',
+    'owner',
+    'oxygen',
+    'oyster',
+    'ozone',
+    'pact',
+    'paddle',
+    'page',
+    'pair',
+    'palace',
+    'palm',
+    'panda',
+    'panel',
+    'panic',
+    'panther',
+    'paper',
+    'parade',
+    'parent',
+    'park',
+    'parrot',
+    'party',
+    'pass',
+    'patch',
+    'path',
+    'patient',
+    'patrol',
+    'pattern',
+    'pause',
+    'pave',
+    'payment',
+    'peace',
+    'peanut',
+    'pear',
+    'peasant',
+    'pelican',
+    'pen',
+    'penalty',
+    'pencil',
+    'people',
+    'pepper',
+    'perfect',
+    'permit',
+    'person',
+    'pet',
+    'phone',
+    'photo',
+    'phrase',
+    'physical',
+    'piano',
+    'picnic',
+    'picture',
+    'piece',
+    'pig',
+    'pigeon',
+    'pill',
+    'pilot',
+    'pink',
+    'pioneer',
+    'pipe',
+    'pistol',
+    'pitch',
+    'pizza',
+    'place',
+    'planet',
+    'plastic',
+    'plate',
+    'play',
+    'please',
+    'pledge',
+    'pluck',
+    'plug',
+    'plunge',
+    'poem',
+    'poet',
+    'point',
+    'polar',
+    'pole',
+    'police',
+    'pond',
+    'pony',
+    'pool',
+    'popular',
+    'portion',
+    'position',
+    'possible',
+    'post',
+    'potato',
+    'pottery',
+    'poverty',
+    'powder',
+    'power',
+    'practice',
+    'praise',
+    'predict',
+    'prefer',
+    'prepare',
+    'present',
+    'pretty',
+    'prevent',
+    'price',
+    'pride',
+    'primary',
+    'print',
+    'priority',
+    'prison',
+    'private',
+    'prize',
+    'problem',
+    'process',
+    'produce',
+    'profit',
+    'program',
+    'project',
+    'promote',
+    'proof',
+    'property',
+    'prosper',
+    'protect',
+    'proud',
+    'provide',
+    'public',
+    'pudding',
+    'pull',
+    'pulp',
+    'pulse',
+    'pumpkin',
+    'punch',
+    'pupil',
+    'puppy',
+    'purchase',
+    'purity',
+    'purpose',
+    'purse',
+    'push',
+    'put',
+    'puzzle',
+    'pyramid',
+    'quality',
+    'quantum',
+    'quarter',
+    'question',
+    'quick',
+    'quit',
+    'quiz',
+    'quote',
+    'rabbit',
+    'raccoon',
+    'race',
+    'rack',
+    'radar',
+    'radio',
+    'rail',
+    'rain',
+    'raise',
+    'rally',
+    'ramp',
+    'ranch',
+    'random',
+    'range',
+    'rapid',
+    'rare',
+    'rate',
+    'rather',
+    'raven',
+    'raw',
+    'razor',
+    'ready',
+    'real',
+    'reason',
+    'rebel',
+    'rebuild',
+    'recall',
+    'receive',
+    'recipe',
+    'record',
+    'recycle',
+    'reduce',
+    'reflect',
+    'reform',
+    'refuse',
+    'region',
+    'regret',
+    'regular',
+    'reject',
+    'relax',
+    'release',
+    'relief',
+    'rely',
+    'remain',
+    'remember',
+    'remind',
+    'remove',
+    'render',
+    'renew',
+    'rent',
+    'reopen',
+    'repair',
+    'repeat',
+    'replace',
+    'report',
+    'require',
+    'rescue',
+    'resemble',
+    'resist',
+    'resource',
+    'response',
+    'result',
+    'retire',
+    'retreat',
+    'return',
+    'reunion',
+    'reveal',
+    'review',
+    'reward',
+    'rhythm',
+    'rib',
+    'ribbon',
+    'rice',
+    'rich',
+    'ride',
+    'ridge',
+    'rifle',
+    'right',
+    'rigid',
+    'ring',
+    'riot',
+    'ripple',
+    'risk',
+    'ritual',
+    'rival',
+    'river',
+    'road',
+    'roast',
+    'robot',
+    'robust',
+    'rocket',
+    'romance',
+    'roof',
+    'rookie',
+    'room',
+    'rose',
+    'rotate',
+    'rough',
+    'round',
+    'route',
+    'royal',
+    'rubber',
+    'rude',
+    'rug',
+    'rule',
+    'run',
+    'runway',
+    'rural',
+    'sad',
+    'saddle',
+    'sadness',
+    'safe',
+    'sail',
+    'salad',
+    'salmon',
+    'salon',
+    'salt',
+    'salute',
+    'same',
+    'sample',
+    'sand',
+    'satisfy',
+    'satoshi',
+    'sauce',
+    'sausage',
+    'save',
+    'say',
+    'scale',
+    'scan',
+    'scare',
+    'scatter',
+    'scene',
+    'scheme',
+    'school',
+    'science',
+    'scissors',
+    'scorpion',
+    'scout',
+    'scrap',
+    'screen',
+    'script',
+    'scrub',
+    'sea',
+    'search',
+    'season',
+    'seat',
+    'second',
+    'secret',
+    'section',
+    'security',
+    'seed',
+    'seek',
+    'segment',
+    'select',
+    'sell',
+    'seminar',
+    'senior',
+    'sense',
+    'sentence',
+    'series',
+    'service',
+    'session',
+    'settle',
+    'setup',
+    'seven',
+    'shadow',
+    'shaft',
+    'shallow',
+    'share',
+    'shed',
+    'shell',
+    'sheriff',
+    'shield',
+    'shift',
+    'shine',
+    'ship',
+    'shiver',
+    'shock',
+    'shoe',
+    'shoot',
+    'shop',
+    'short',
+    'shoulder',
+    'shove',
+    'shrimp',
+    'shrug',
+    'shuffle',
+    'shy',
+    'sibling',
+    'sick',
+    'side',
+    'siege',
+    'sight',
+    'sign',
+    'silent',
+    'silk',
+    'silly',
+    'silver',
+    'similar',
+    'simple',
+    'since',
+    'sing',
+    'siren',
+    'sister',
+    'situate',
+    'six',
+    'size',
+    'skate',
+    'sketch',
+    'ski',
+    'skill',
+    'skin',
+    'skirt',
+    'skull',
+    'slab',
+    'slam',
+    'sleep',
+    'slender',
+    'slice',
+    'slide',
+    'slight',
+    'slim',
+    'slogan',
+    'slot',
+    'slow',
+    'slush',
+    'small',
+    'smart',
+    'smile',
+    'smoke',
+    'smooth',
+    'snack',
+    'snake',
+    'snap',
+    'sniff',
+    'snow',
+    'soap',
+    'soccer',
+    'social',
+    'sock',
+    'soda',
+    'soft',
+    'solar',
+    'soldier',
+    'solid',
+    'solution',
+    'solve',
+    'someone',
+    'song',
+    'soon',
+    'sorry',
+    'sort',
+    'soul',
+    'sound',
+    'soup',
+    'source',
+    'south',
+    'space',
+    'spare',
+    'spatial',
+    'spawn',
+    'speak',
+    'special',
+    'speed',
+    'spell',
+    'spend',
+    'sphere',
+    'spice',
+    'spider',
+    'spike',
+    'spin',
+    'spirit',
+    'split',
+    'spoil',
+    'sponsor',
+    'spoon',
+    'sport',
+    'spot',
+    'spray',
+    'spread',
+    'spring',
+    'spy',
+    'square',
+    'squeeze',
+    'squirrel',
+    'stable',
+    'stadium',
+    'staff',
+    'stage',
+    'stairs',
+    'stamp',
+    'stand',
+    'start',
+    'state',
+    'stay',
+    'steak',
+    'steel',
+    'stem',
+    'step',
+    'stereo',
+    'stick',
+    'still',
+    'sting',
+    'stock',
+    'stomach',
+    'stone',
+    'stool',
+    'story',
+    'stove',
+    'strategy',
+    'street',
+    'strike',
+    'strong',
+    'struggle',
+    'student',
+    'stuff',
+    'stumble',
+    'style',
+    'subject',
+    'submit',
+    'subway',
+    'success',
+    'such',
+    'sudden',
+    'suffer',
+    'sugar',
+    'suggest',
+    'suit',
+    'summer',
+    'sun',
+    'sunny',
+    'sunset',
+    'super',
+    'supply',
+    'supreme',
+    'sure',
+    'surface',
+    'surge',
+    'surprise',
+    'surround',
+    'survey',
+    'suspect',
+    'sustain',
+    'swallow',
+    'swamp',
+    'swap',
+    'swarm',
+    'swear',
+    'sweet',
+    'swift',
+    'swim',
+    'swing',
+    'switch',
+    'sword',
+    'symbol',
+    'symptom',
+    'syrup',
+    'system',
+    'table',
+    'tackle',
+    'tag',
+    'tail',
+    'talent',
+    'talk',
+    'tank',
+    'tape',
+    'target',
+    'task',
+    'taste',
+    'tattoo',
+    'taxi',
+    'teach',
+    'team',
+    'tell',
+    'ten',
+    'tenant',
+    'tennis',
+    'tent',
+    'term',
+    'test',
+    'text',
+    'thank',
+    'that',
+    'theme',
+    'then',
+    'theory',
+    'there',
+    'they',
+    'thing',
+    'this',
+    'thought',
+    'three',
+    'thrive',
+    'throw',
+    'thumb',
+    'thunder',
+    'ticket',
+    'tide',
+    'tiger',
+    'tilt',
+    'timber',
+    'time',
+    'tiny',
+    'tip',
+    'tired',
+    'tissue',
+    'title',
+    'toast',
+    'tobacco',
+    'today',
+    'toddler',
+    'toe',
+    'together',
+    'toilet',
+    'token',
+    'tomato',
+    'tomorrow',
+    'tone',
+    'tongue',
+    'tonight',
+    'tool',
+    'tooth',
+    'top',
+    'topic',
+    'topple',
+    'torch',
+    'tornado',
+    'tortoise',
+    'toss',
+    'total',
+    'tourist',
+    'toward',
+    'tower',
+    'town',
+    'toy',
+    'track',
+    'trade',
+    'traffic',
+    'tragic',
+    'train',
+    'transfer',
+    'trap',
+    'trash',
+    'travel',
+    'tray',
+    'treat',
+    'tree',
+    'trend',
+    'trial',
+    'tribe',
+    'trick',
+    'trigger',
+    'trim',
+    'trip',
+    'trophy',
+    'trouble',
+    'truck',
+    'true',
+    'truly',
+    'trumpet',
+    'trust',
+    'truth',
+    'try',
+    'tube',
+    'tuition',
+    'tumble',
+    'tuna',
+    'tunnel',
+    'turkey',
+    'turn',
+    'turtle',
+    'twelve',
+    'twenty',
+    'twice',
+    'twin',
+    'twist',
+    'two',
+    'type',
+    'typical',
+    'ugly',
+    'umbrella',
+    'unable',
+    'unaware',
+    'uncle',
+    'uncover',
+    'under',
+    'undo',
+    'unfair',
+    'unfold',
+    'unhappy',
+    'uniform',
+    'unique',
+    'unit',
+    'universe',
+    'unknown',
+    'unlock',
+    'until',
+    'unusual',
+    'unveil',
+    'update',
+    'upgrade',
+    'uphold',
+    'upon',
+    'upper',
+    'upset',
+    'urban',
+    'urge',
+    'usage',
+    'use',
+    'used',
+    'useful',
+    'useless',
+    'usual',
+    'utility',
+    'vacant',
+    'vacuum',
+    'vague',
+    'valid',
+    'valley',
+    'valve',
+    'van',
+    'vanish',
+    'vapor',
+    'various',
+    'vast',
+    'vault',
+    'vehicle',
+    'velvet',
+    'vendor',
+    'venture',
+    'venue',
+    'verb',
+    'verify',
+    'version',
+    'very',
+    'vessel',
+    'veteran',
+    'viable',
+    'vibrant',
+    'vicious',
+    'victory',
+    'video',
+    'view',
+    'village',
+    'vintage',
+    'violin',
+    'virtual',
+    'virus',
+    'visa',
+    'visit',
+    'visual',
+    'vital',
+    'vivid',
+    'vocal',
+    'voice',
+    'void',
+    'volcano',
+    'volume',
+    'vote',
+    'voyage',
+    'wage',
+    'wagon',
+    'wait',
+    'walk',
+    'wall',
+    'walnut',
+    'want',
+    'warfare',
+    'warm',
+    'warrior',
+    'wash',
+    'wasp',
+    'waste',
+    'water',
+    'wave',
+    'way',
+    'wealth',
+    'weapon',
+    'wear',
+    'weasel',
+    'weather',
+    'web',
+    'wedding',
+    'weekend',
+    'weird',
+    'welcome',
+    'west',
+    'wet',
+    'whale',
+    'what',
+    'wheat',
+    'wheel',
+    'when',
+    'where',
+    'whip',
+    'whisper',
+    'wide',
+    'width',
+    'wife',
+    'wild',
+    'will',
+    'win',
+    'window',
+    'wine',
+    'wing',
+    'wink',
+    'winner',
+    'winter',
+    'wire',
+    'wisdom',
+    'wise',
+    'wish',
+    'witness',
+    'wolf',
+    'woman',
+    'wonder',
+    'wood',
+    'wool',
+    'word',
+    'work',
+    'world',
+    'worry',
+    'worth',
+    'wrap',
+    'wreck',
+    'wrestle',
+    'wrist',
+    'write',
+    'wrong',
+    'yard',
+    'year',
+    'yellow',
+    'you',
+    'young',
+    'youth',
+    'zebra',
+    'zero',
+    'zone',
+    'zoo'
 ];
 
 class Mnemonic {
@@ -14269,11 +14470,11 @@ var hasRequiredErrorCorrectionLevel;
 function requireErrorCorrectionLevel () {
 	if (hasRequiredErrorCorrectionLevel) return errorCorrectionLevel;
 	hasRequiredErrorCorrectionLevel = 1;
-	(function (exports$1) {
-		exports$1.L = { bit: 1 };
-		exports$1.M = { bit: 0 };
-		exports$1.Q = { bit: 3 };
-		exports$1.H = { bit: 2 };
+	(function (exports) {
+		exports.L = { bit: 1 };
+		exports.M = { bit: 0 };
+		exports.Q = { bit: 3 };
+		exports.H = { bit: 2 };
 
 		function fromString (string) {
 		  if (typeof string !== 'string') {
@@ -14285,32 +14486,32 @@ function requireErrorCorrectionLevel () {
 		  switch (lcStr) {
 		    case 'l':
 		    case 'low':
-		      return exports$1.L
+		      return exports.L
 
 		    case 'm':
 		    case 'medium':
-		      return exports$1.M
+		      return exports.M
 
 		    case 'q':
 		    case 'quartile':
-		      return exports$1.Q
+		      return exports.Q
 
 		    case 'h':
 		    case 'high':
-		      return exports$1.H
+		      return exports.H
 
 		    default:
 		      throw new Error('Unknown EC Level: ' + string)
 		  }
 		}
 
-		exports$1.isValid = function isValid (level) {
+		exports.isValid = function isValid (level) {
 		  return level && typeof level.bit !== 'undefined' &&
 		    level.bit >= 0 && level.bit < 4
 		};
 
-		exports$1.from = function from (value, defaultValue) {
-		  if (exports$1.isValid(value)) {
+		exports.from = function from (value, defaultValue) {
+		  if (exports.isValid(value)) {
 		    return value
 		  }
 
@@ -14462,7 +14663,7 @@ var hasRequiredAlignmentPattern;
 function requireAlignmentPattern () {
 	if (hasRequiredAlignmentPattern) return alignmentPattern;
 	hasRequiredAlignmentPattern = 1;
-	(function (exports$1) {
+	(function (exports) {
 		const getSymbolSize = requireUtils$1().getSymbolSize;
 
 		/**
@@ -14479,7 +14680,7 @@ function requireAlignmentPattern () {
 		 * @param  {Number} version QR Code version
 		 * @return {Array}          Array of coordinate
 		 */
-		exports$1.getRowColCoords = function getRowColCoords (version) {
+		exports.getRowColCoords = function getRowColCoords (version) {
 		  if (version === 1) return []
 
 		  const posCount = Math.floor(version / 7) + 2;
@@ -14516,9 +14717,9 @@ function requireAlignmentPattern () {
 		 * @param  {Number} version QR Code version
 		 * @return {Array}          Array of coordinates
 		 */
-		exports$1.getPositions = function getPositions (version) {
+		exports.getPositions = function getPositions (version) {
 		  const coords = [];
-		  const pos = exports$1.getRowColCoords(version);
+		  const pos = exports.getRowColCoords(version);
 		  const posLength = pos.length;
 
 		  for (let i = 0; i < posLength; i++) {
@@ -14584,8 +14785,8 @@ var hasRequiredMaskPattern;
 function requireMaskPattern () {
 	if (hasRequiredMaskPattern) return maskPattern;
 	hasRequiredMaskPattern = 1;
-	(function (exports$1) {
-		exports$1.Patterns = {
+	(function (exports) {
+		exports.Patterns = {
 		  PATTERN000: 0,
 		  PATTERN001: 1,
 		  PATTERN010: 2,
@@ -14613,7 +14814,7 @@ function requireMaskPattern () {
 		 * @param  {Number}  mask    Mask pattern
 		 * @return {Boolean}         true if valid, false otherwise
 		 */
-		exports$1.isValid = function isValid (mask) {
+		exports.isValid = function isValid (mask) {
 		  return mask != null && mask !== '' && !isNaN(mask) && mask >= 0 && mask <= 7
 		};
 
@@ -14624,8 +14825,8 @@ function requireMaskPattern () {
 		 * @param  {Number|String} value        Mask pattern value
 		 * @return {Number}                     Valid mask pattern or undefined
 		 */
-		exports$1.from = function from (value) {
-		  return exports$1.isValid(value) ? parseInt(value, 10) : undefined
+		exports.from = function from (value) {
+		  return exports.isValid(value) ? parseInt(value, 10) : undefined
 		};
 
 		/**
@@ -14635,7 +14836,7 @@ function requireMaskPattern () {
 		* Points: N1 + i
 		* i is the amount by which the number of adjacent modules of the same color exceeds 5
 		*/
-		exports$1.getPenaltyN1 = function getPenaltyN1 (data) {
+		exports.getPenaltyN1 = function getPenaltyN1 (data) {
 		  const size = data.size;
 		  let points = 0;
 		  let sameCountCol = 0;
@@ -14679,7 +14880,7 @@ function requireMaskPattern () {
 		 *
 		 * Points: N2 * (m - 1) * (n - 1)
 		 */
-		exports$1.getPenaltyN2 = function getPenaltyN2 (data) {
+		exports.getPenaltyN2 = function getPenaltyN2 (data) {
 		  const size = data.size;
 		  let points = 0;
 
@@ -14703,7 +14904,7 @@ function requireMaskPattern () {
 		 *
 		 * Points: N3 * number of pattern found
 		 */
-		exports$1.getPenaltyN3 = function getPenaltyN3 (data) {
+		exports.getPenaltyN3 = function getPenaltyN3 (data) {
 		  const size = data.size;
 		  let points = 0;
 		  let bitsCol = 0;
@@ -14731,7 +14932,7 @@ function requireMaskPattern () {
 		 * k is the rating of the deviation of the proportion of dark modules
 		 * in the symbol from 50% in steps of 5%
 		 */
-		exports$1.getPenaltyN4 = function getPenaltyN4 (data) {
+		exports.getPenaltyN4 = function getPenaltyN4 (data) {
 		  let darkCount = 0;
 		  const modulesCount = data.data.length;
 
@@ -14752,14 +14953,14 @@ function requireMaskPattern () {
 		 */
 		function getMaskAt (maskPattern, i, j) {
 		  switch (maskPattern) {
-		    case exports$1.Patterns.PATTERN000: return (i + j) % 2 === 0
-		    case exports$1.Patterns.PATTERN001: return i % 2 === 0
-		    case exports$1.Patterns.PATTERN010: return j % 3 === 0
-		    case exports$1.Patterns.PATTERN011: return (i + j) % 3 === 0
-		    case exports$1.Patterns.PATTERN100: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0
-		    case exports$1.Patterns.PATTERN101: return (i * j) % 2 + (i * j) % 3 === 0
-		    case exports$1.Patterns.PATTERN110: return ((i * j) % 2 + (i * j) % 3) % 2 === 0
-		    case exports$1.Patterns.PATTERN111: return ((i * j) % 3 + (i + j) % 2) % 2 === 0
+		    case exports.Patterns.PATTERN000: return (i + j) % 2 === 0
+		    case exports.Patterns.PATTERN001: return i % 2 === 0
+		    case exports.Patterns.PATTERN010: return j % 3 === 0
+		    case exports.Patterns.PATTERN011: return (i + j) % 3 === 0
+		    case exports.Patterns.PATTERN100: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0
+		    case exports.Patterns.PATTERN101: return (i * j) % 2 + (i * j) % 3 === 0
+		    case exports.Patterns.PATTERN110: return ((i * j) % 2 + (i * j) % 3) % 2 === 0
+		    case exports.Patterns.PATTERN111: return ((i * j) % 3 + (i + j) % 2) % 2 === 0
 
 		    default: throw new Error('bad maskPattern:' + maskPattern)
 		  }
@@ -14771,7 +14972,7 @@ function requireMaskPattern () {
 		 * @param  {Number}    pattern Pattern reference number
 		 * @param  {BitMatrix} data    BitMatrix data
 		 */
-		exports$1.applyMask = function applyMask (pattern, data) {
+		exports.applyMask = function applyMask (pattern, data) {
 		  const size = data.size;
 
 		  for (let col = 0; col < size; col++) {
@@ -14788,24 +14989,24 @@ function requireMaskPattern () {
 		 * @param  {BitMatrix} data
 		 * @return {Number} Mask pattern reference number
 		 */
-		exports$1.getBestMask = function getBestMask (data, setupFormatFunc) {
-		  const numPatterns = Object.keys(exports$1.Patterns).length;
+		exports.getBestMask = function getBestMask (data, setupFormatFunc) {
+		  const numPatterns = Object.keys(exports.Patterns).length;
 		  let bestPattern = 0;
 		  let lowerPenalty = Infinity;
 
 		  for (let p = 0; p < numPatterns; p++) {
 		    setupFormatFunc(p);
-		    exports$1.applyMask(p, data);
+		    exports.applyMask(p, data);
 
 		    // Calculate penalty
 		    const penalty =
-		      exports$1.getPenaltyN1(data) +
-		      exports$1.getPenaltyN2(data) +
-		      exports$1.getPenaltyN3(data) +
-		      exports$1.getPenaltyN4(data);
+		      exports.getPenaltyN1(data) +
+		      exports.getPenaltyN2(data) +
+		      exports.getPenaltyN3(data) +
+		      exports.getPenaltyN4(data);
 
 		    // Undo previously applied mask
-		    exports$1.applyMask(p, data);
+		    exports.applyMask(p, data);
 
 		    if (penalty < lowerPenalty) {
 		      lowerPenalty = penalty;
@@ -15050,7 +15251,7 @@ var hasRequiredPolynomial;
 function requirePolynomial () {
 	if (hasRequiredPolynomial) return polynomial;
 	hasRequiredPolynomial = 1;
-	(function (exports$1) {
+	(function (exports) {
 		const GF = requireGaloisField();
 
 		/**
@@ -15060,7 +15261,7 @@ function requirePolynomial () {
 		 * @param  {Uint8Array} p2 Polynomial
 		 * @return {Uint8Array}    Product of p1 and p2
 		 */
-		exports$1.mul = function mul (p1, p2) {
+		exports.mul = function mul (p1, p2) {
 		  const coeff = new Uint8Array(p1.length + p2.length - 1);
 
 		  for (let i = 0; i < p1.length; i++) {
@@ -15079,7 +15280,7 @@ function requirePolynomial () {
 		 * @param  {Uint8Array} divisor  Polynomial
 		 * @return {Uint8Array}          Remainder
 		 */
-		exports$1.mod = function mod (divident, divisor) {
+		exports.mod = function mod (divident, divisor) {
 		  let result = new Uint8Array(divident);
 
 		  while ((result.length - divisor.length) >= 0) {
@@ -15105,10 +15306,10 @@ function requirePolynomial () {
 		 * @param  {Number} degree Degree of the generator polynomial
 		 * @return {Uint8Array}    Buffer containing polynomial coefficients
 		 */
-		exports$1.generateECPolynomial = function generateECPolynomial (degree) {
+		exports.generateECPolynomial = function generateECPolynomial (degree) {
 		  let poly = new Uint8Array([1]);
 		  for (let i = 0; i < degree; i++) {
-		    poly = exports$1.mul(poly, new Uint8Array([1, GF.exp(i)]));
+		    poly = exports.mul(poly, new Uint8Array([1, GF.exp(i)]));
 		  }
 
 		  return poly
@@ -15252,7 +15453,7 @@ var hasRequiredMode;
 function requireMode () {
 	if (hasRequiredMode) return mode;
 	hasRequiredMode = 1;
-	(function (exports$1) {
+	(function (exports) {
 		const VersionCheck = requireVersionCheck();
 		const Regex = requireRegex();
 
@@ -15263,7 +15464,7 @@ function requireMode () {
 		 *
 		 * @type {Object}
 		 */
-		exports$1.NUMERIC = {
+		exports.NUMERIC = {
 		  id: 'Numeric',
 		  bit: 1 << 0,
 		  ccBits: [10, 12, 14]
@@ -15278,7 +15479,7 @@ function requireMode () {
 		 *
 		 * @type {Object}
 		 */
-		exports$1.ALPHANUMERIC = {
+		exports.ALPHANUMERIC = {
 		  id: 'Alphanumeric',
 		  bit: 1 << 1,
 		  ccBits: [9, 11, 13]
@@ -15289,7 +15490,7 @@ function requireMode () {
 		 *
 		 * @type {Object}
 		 */
-		exports$1.BYTE = {
+		exports.BYTE = {
 		  id: 'Byte',
 		  bit: 1 << 2,
 		  ccBits: [8, 16, 16]
@@ -15304,7 +15505,7 @@ function requireMode () {
 		 *
 		 * @type {Object}
 		 */
-		exports$1.KANJI = {
+		exports.KANJI = {
 		  id: 'Kanji',
 		  bit: 1 << 3,
 		  ccBits: [8, 10, 12]
@@ -15316,7 +15517,7 @@ function requireMode () {
 		 *
 		 * @type {Object}
 		 */
-		exports$1.MIXED = {
+		exports.MIXED = {
 		  bit: -1
 		};
 
@@ -15328,7 +15529,7 @@ function requireMode () {
 		 * @param  {Number} version QR Code version
 		 * @return {Number}         Number of bits
 		 */
-		exports$1.getCharCountIndicator = function getCharCountIndicator (mode, version) {
+		exports.getCharCountIndicator = function getCharCountIndicator (mode, version) {
 		  if (!mode.ccBits) throw new Error('Invalid mode: ' + mode)
 
 		  if (!VersionCheck.isValid(version)) {
@@ -15346,11 +15547,11 @@ function requireMode () {
 		 * @param  {String} dataStr Input data string
 		 * @return {Mode}           Best mode
 		 */
-		exports$1.getBestModeForData = function getBestModeForData (dataStr) {
-		  if (Regex.testNumeric(dataStr)) return exports$1.NUMERIC
-		  else if (Regex.testAlphanumeric(dataStr)) return exports$1.ALPHANUMERIC
-		  else if (Regex.testKanji(dataStr)) return exports$1.KANJI
-		  else return exports$1.BYTE
+		exports.getBestModeForData = function getBestModeForData (dataStr) {
+		  if (Regex.testNumeric(dataStr)) return exports.NUMERIC
+		  else if (Regex.testAlphanumeric(dataStr)) return exports.ALPHANUMERIC
+		  else if (Regex.testKanji(dataStr)) return exports.KANJI
+		  else return exports.BYTE
 		};
 
 		/**
@@ -15359,7 +15560,7 @@ function requireMode () {
 		 * @param {Mode} mode Mode object
 		 * @returns {String}  Mode name
 		 */
-		exports$1.toString = function toString (mode) {
+		exports.toString = function toString (mode) {
 		  if (mode && mode.id) return mode.id
 		  throw new Error('Invalid mode')
 		};
@@ -15370,7 +15571,7 @@ function requireMode () {
 		 * @param   {Mode}    mode Mode object
 		 * @returns {Boolean} True if valid mode, false otherwise
 		 */
-		exports$1.isValid = function isValid (mode) {
+		exports.isValid = function isValid (mode) {
 		  return mode && mode.bit && mode.ccBits
 		};
 
@@ -15389,13 +15590,13 @@ function requireMode () {
 
 		  switch (lcStr) {
 		    case 'numeric':
-		      return exports$1.NUMERIC
+		      return exports.NUMERIC
 		    case 'alphanumeric':
-		      return exports$1.ALPHANUMERIC
+		      return exports.ALPHANUMERIC
 		    case 'kanji':
-		      return exports$1.KANJI
+		      return exports.KANJI
 		    case 'byte':
-		      return exports$1.BYTE
+		      return exports.BYTE
 		    default:
 		      throw new Error('Unknown mode: ' + string)
 		  }
@@ -15409,8 +15610,8 @@ function requireMode () {
 		 * @param  {Mode}        defaultValue Fallback value
 		 * @return {Mode}                     Encoding mode
 		 */
-		exports$1.from = function from (value, defaultValue) {
-		  if (exports$1.isValid(value)) {
+		exports.from = function from (value, defaultValue) {
+		  if (exports.isValid(value)) {
 		    return value
 		  }
 
@@ -15429,7 +15630,7 @@ var hasRequiredVersion;
 function requireVersion () {
 	if (hasRequiredVersion) return version;
 	hasRequiredVersion = 1;
-	(function (exports$1) {
+	(function (exports) {
 		const Utils = requireUtils$1();
 		const ECCode = requireErrorCorrectionCode();
 		const ECLevel = requireErrorCorrectionLevel();
@@ -15442,7 +15643,7 @@ function requireVersion () {
 
 		function getBestVersionForDataLength (mode, length, errorCorrectionLevel) {
 		  for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
-		    if (length <= exports$1.getCapacity(currentVersion, errorCorrectionLevel, mode)) {
+		    if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel, mode)) {
 		      return currentVersion
 		    }
 		  }
@@ -15469,7 +15670,7 @@ function requireVersion () {
 		function getBestVersionForMixedData (segments, errorCorrectionLevel) {
 		  for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
 		    const length = getTotalBitsFromDataArray(segments, currentVersion);
-		    if (length <= exports$1.getCapacity(currentVersion, errorCorrectionLevel, Mode.MIXED)) {
+		    if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel, Mode.MIXED)) {
 		      return currentVersion
 		    }
 		  }
@@ -15485,7 +15686,7 @@ function requireVersion () {
 		 * @param  {Number}        defaultValue Fallback value
 		 * @return {Number}                     QR Code version number
 		 */
-		exports$1.from = function from (value, defaultValue) {
+		exports.from = function from (value, defaultValue) {
 		  if (VersionCheck.isValid(value)) {
 		    return parseInt(value, 10)
 		  }
@@ -15502,7 +15703,7 @@ function requireVersion () {
 		 * @param  {Mode}   mode                 Data mode
 		 * @return {Number}                      Quantity of storable data
 		 */
-		exports$1.getCapacity = function getCapacity (version, errorCorrectionLevel, mode) {
+		exports.getCapacity = function getCapacity (version, errorCorrectionLevel, mode) {
 		  if (!VersionCheck.isValid(version)) {
 		    throw new Error('Invalid QR Code version')
 		  }
@@ -15548,7 +15749,7 @@ function requireVersion () {
 		 * @param  {Mode} mode                       Data mode
 		 * @return {Number}                          QR Code version
 		 */
-		exports$1.getBestVersionForData = function getBestVersionForData (data, errorCorrectionLevel) {
+		exports.getBestVersionForData = function getBestVersionForData (data, errorCorrectionLevel) {
 		  let seg;
 
 		  const ecl = ECLevel.from(errorCorrectionLevel, ECLevel.M);
@@ -15580,7 +15781,7 @@ function requireVersion () {
 		 * @param  {Number} version QR Code version
 		 * @return {Number}         Encoded version info bits
 		 */
-		exports$1.getEncodedBits = function getEncodedBits (version) {
+		exports.getEncodedBits = function getEncodedBits (version) {
 		  if (!VersionCheck.isValid(version) || version < 7) {
 		    throw new Error('Invalid QR Code version')
 		  }
@@ -16040,7 +16241,7 @@ var hasRequiredSegments;
 function requireSegments () {
 	if (hasRequiredSegments) return segments;
 	hasRequiredSegments = 1;
-	(function (exports$1) {
+	(function (exports) {
 		const Mode = requireMode();
 		const NumericData = requireNumericData();
 		const AlphanumericData = requireAlphanumericData();
@@ -16321,7 +16522,7 @@ function requireSegments () {
 		 * @param  {Array} array Array of objects with segments data
 		 * @return {Array}       Array of Segments
 		 */
-		exports$1.fromArray = function fromArray (array) {
+		exports.fromArray = function fromArray (array) {
 		  return array.reduce(function (acc, seg) {
 		    if (typeof seg === 'string') {
 		      acc.push(buildSingleSegment(seg, null));
@@ -16341,7 +16542,7 @@ function requireSegments () {
 		 * @param  {Number} version QR Code version
 		 * @return {Array}          Array of segments
 		 */
-		exports$1.fromString = function fromString (data, version) {
+		exports.fromString = function fromString (data, version) {
 		  const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
 
 		  const nodes = buildNodes(segs);
@@ -16353,7 +16554,7 @@ function requireSegments () {
 		    optimizedSegs.push(graph.table[path[i]].node);
 		  }
 
-		  return exports$1.fromArray(mergeSegments(optimizedSegs))
+		  return exports.fromArray(mergeSegments(optimizedSegs))
 		};
 
 		/**
@@ -16366,8 +16567,8 @@ function requireSegments () {
 		 * @param  {string} data Input string
 		 * @return {Array}       Array of segments
 		 */
-		exports$1.rawSplit = function rawSplit (data) {
-		  return exports$1.fromArray(
+		exports.rawSplit = function rawSplit (data) {
+		  return exports.fromArray(
 		    getSegmentsFromString(data, Utils.isKanjiModeEnabled())
 		  )
 		}; 
@@ -16887,7 +17088,7 @@ var hasRequiredUtils;
 function requireUtils () {
 	if (hasRequiredUtils) return utils;
 	hasRequiredUtils = 1;
-	(function (exports$1) {
+	(function (exports) {
 		function hex2rgba (hex) {
 		  if (typeof hex === 'number') {
 		    hex = hex.toString();
@@ -16923,7 +17124,7 @@ function requireUtils () {
 		  }
 		}
 
-		exports$1.getOptions = function getOptions (options) {
+		exports.getOptions = function getOptions (options) {
 		  if (!options) options = {};
 		  if (!options.color) options.color = {};
 
@@ -16949,21 +17150,21 @@ function requireUtils () {
 		  }
 		};
 
-		exports$1.getScale = function getScale (qrSize, opts) {
+		exports.getScale = function getScale (qrSize, opts) {
 		  return opts.width && opts.width >= qrSize + opts.margin * 2
 		    ? opts.width / (qrSize + opts.margin * 2)
 		    : opts.scale
 		};
 
-		exports$1.getImageWidth = function getImageWidth (qrSize, opts) {
-		  const scale = exports$1.getScale(qrSize, opts);
+		exports.getImageWidth = function getImageWidth (qrSize, opts) {
+		  const scale = exports.getScale(qrSize, opts);
 		  return Math.floor((qrSize + opts.margin * 2) * scale)
 		};
 
-		exports$1.qrToImageData = function qrToImageData (imgData, qr, opts) {
+		exports.qrToImageData = function qrToImageData (imgData, qr, opts) {
 		  const size = qr.modules.size;
 		  const data = qr.modules.data;
-		  const scale = exports$1.getScale(size, opts);
+		  const scale = exports.getScale(size, opts);
 		  const symbolSize = Math.floor((size + opts.margin * 2) * scale);
 		  const scaledMargin = opts.margin * scale;
 		  const palette = [opts.color.light, opts.color.dark];
@@ -16996,7 +17197,7 @@ var hasRequiredCanvas;
 function requireCanvas () {
 	if (hasRequiredCanvas) return canvas;
 	hasRequiredCanvas = 1;
-	(function (exports$1) {
+	(function (exports) {
 		const Utils = requireUtils();
 
 		function clearCanvas (ctx, canvas, size) {
@@ -17017,7 +17218,7 @@ function requireCanvas () {
 		  }
 		}
 
-		exports$1.render = function render (qrData, canvas, options) {
+		exports.render = function render (qrData, canvas, options) {
 		  let opts = options;
 		  let canvasEl = canvas;
 
@@ -17043,7 +17244,7 @@ function requireCanvas () {
 		  return canvasEl
 		};
 
-		exports$1.renderToDataURL = function renderToDataURL (qrData, canvas, options) {
+		exports.renderToDataURL = function renderToDataURL (qrData, canvas, options) {
 		  let opts = options;
 
 		  if (typeof opts === 'undefined' && (!canvas || !canvas.getContext)) {
@@ -17053,7 +17254,7 @@ function requireCanvas () {
 
 		  if (!opts) opts = {};
 
-		  const canvasEl = exports$1.render(qrData, canvas, opts);
+		  const canvasEl = exports.render(qrData, canvas, opts);
 
 		  const type = opts.type || 'image/png';
 		  const rendererOpts = opts.rendererOpts || {};
@@ -17280,7 +17481,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-D_MPeSmw.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-BMd3d9G1.js');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -17326,4 +17527,4 @@ class Identity {
     }
 }
 
-export { Identity as I, MultiWallet as M, base58$1 as a, base$1 as b, index$3 as c, index$2 as d, index$4 as e, createSHA512 as f, createSHA384 as g, createSHA256 as h, index$5 as i, createSHA224 as j, createSHA1 as k, encrypt as l, getDefaultExportFromCjs as m, commonjsGlobal as n, requireInherits_browser as o, require$$3 as r };
+export { Identity as I, MultiWallet as M, base58$1 as a, base$1 as b, commonjsGlobal as c, createSHA1 as d, createSHA224 as e, createSHA256 as f, createSHA384 as g, createSHA512 as h, encrypt as i, getDefaultExportFromCjs as j, index$3 as k, index$5 as l, index$2 as m, index$4 as n, requireInherits_browser as o, require$$3 as r };