diff --git a/qa/pull-tester/rpc-tests.py b/qa/pull-tester/rpc-tests.py index 47087bd7a..0add94371 100755 --- a/qa/pull-tester/rpc-tests.py +++ b/qa/pull-tester/rpc-tests.py @@ -173,7 +173,7 @@ 'hardfork-451.py', 'hardfork-452.py', 'staticr-tx-send.py', - + 'mnemonic.py', 'sendtoaddress.py', 'stakeimmaturebalance.py', 'rpc-help.py', diff --git a/qa/rpc-tests/mnemonic.py b/qa/rpc-tests/mnemonic.py new file mode 100755 index 000000000..987ccbed8 --- /dev/null +++ b/qa/rpc-tests/mnemonic.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +# Copyright (c) 2019 Navcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or http://www.opensource.org/licenses/mit-license.php. + +from test_framework.test_framework import NavCoinTestFramework +from test_framework.util import ( + start_node, + assert_equal, + slow_gen, +) +import os + +class MnemonicTest(NavCoinTestFramework): + + def __init__(self): + super().__init__() + self.setup_clean_chain = True + self.num_nodes = 1 + self.languages = ["english", "spanish", "italian", "japanese",\ + "french", "russian", "czech", "ukrainian",\ + "simplified chinese", "traditional chinese"] + self.mnemonics = {} + + def setup_network(self): + self.nodes = [] + self.nodes.append(start_node(0, self.options.tmpdir, [])) + self.is_network_split = False + + def run_test (self): + # Record masterkeyid in base58 + masterkeyid = self.nodes[0].dumpmasterprivkey() + + # Record default mnemonic in English + mnemonic_eng = self.nodes[0].dumpmnemonic() + + # Record mnemonics in other languages + for language in self.languages: + self.mnemonics[language] = self.nodes[0].dumpmnemonic(language) + + print("Restoring from mnemonic ...") + self.check_mnemonic_works(masterkeyid, mnemonic_eng) + + for language in self.languages: + self.check_mnemonic_works(masterkeyid, self.mnemonics[language], language) + + def check_mnemonic_works(self, masterprivkey, mnemonic, language="english"): + self.stop_node(0) + os.remove(self.options.tmpdir + "/node0/devnet/wallet.dat") + + self.nodes[0] = start_node(0, self.options.tmpdir, ["-importmnemonic=" + mnemonic, "-mnemoniclanguage=" + language]) + assert_equal(masterprivkey, self.nodes[0].dumpmasterprivkey()) + +if __name__ == '__main__': + MnemonicTest().main () diff --git a/src/Makefile.am b/src/Makefile.am index d343556fa..b52608304 100755 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -156,6 +156,8 @@ NAVCOIN_CORE_H = \ wallet/rpcwallet.h \ wallet/wallet.h \ wallet/walletdb.h \ + mnemonic/dictionary.h \ + mnemonic/mnemonic.h \ zmq/zmqabstractnotifier.h \ zmq/zmqconfig.h\ zmq/zmqnotificationinterface.h \ @@ -229,6 +231,8 @@ libnavcoin_wallet_a_CPPFLAGS = $(AM_CPPFLAGS) $(NAVCOIN_INCLUDES) libnavcoin_wallet_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS) libnavcoin_wallet_a_SOURCES = \ consensus/cfund.cpp \ + mnemonic/dictionary.cpp \ + mnemonic/mnemonic.cpp \ wallet/crypter.cpp \ wallet/db.cpp \ wallet/navtech.cpp \ @@ -252,6 +256,18 @@ crypto_libnavcoin_crypto_a_SOURCES = \ crypto/hmac_sha512.h \ crypto/ripemd160.cpp \ crypto/ripemd160.h \ + crypto/external/hmac_sha256.c \ + crypto/external/hmac_sha256.h \ + crypto/external/hmac_sha512.c \ + crypto/external/hmac_sha512.h \ + crypto/external/pkcs5_pbkdf2.c \ + crypto/external/pkcs5_pbkdf2.h \ + crypto/external/sha256.c \ + crypto/external/sha256.h \ + crypto/external/sha512.c \ + crypto/external/sha512.h \ + crypto/external/zeroize.c \ + crypto/external/zeroize.h \ crypto/sha1.cpp \ crypto/sha1.h \ crypto/sha256.cpp \ diff --git a/src/Makefile.test.include b/src/Makefile.test.include index 07c64e930..5fe2efeee 100755 --- a/src/Makefile.test.include +++ b/src/Makefile.test.include @@ -149,14 +149,14 @@ NAVCOIN_TESTS =\ test_test_navcoin_SOURCES = $(NAVCOIN_TESTS) $(JSON_TEST_FILES) $(RAW_TEST_FILES) test_test_navcoin_CPPFLAGS = $(AM_CPPFLAGS) $(NAVCOIN_INCLUDES) -I$(builddir)/test/ $(TESTDEFS) -test_test_navcoin_LDADD = $(LIBNAVCOIN_SERVER) $(LIBNAVCOIN_CLI) $(LIBNAVCOIN_COMMON) $(LIBNAVCOIN_UTIL) $(LIBNAVCOIN_CONSENSUS) $(LIBNAVCOIN_CRYPTO) $(LIBUNIVALUE) $(LIBLEVELDB) $(LIBMEMENV) \ +test_test_navcoin_LDADD = $(LIBNAVCOIN_SERVER) $(LIBNAVCOIN_CLI) $(LIBNAVCOIN_COMMON) $(LIBNAVCOIN_UTIL) $(LIBNAVCOIN_CONSENSUS) $(LIBUNIVALUE) $(LIBLEVELDB) $(LIBMEMENV) \ $(BOOST_LIBS) $(BOOST_UNIT_TEST_FRAMEWORK_LIB) $(LIBSECP256K1) test_test_navcoin_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS) if ENABLE_WALLET test_test_navcoin_LDADD += $(LIBNAVCOIN_WALLET) endif -test_test_navcoin_LDADD += $(LIBNAVCOIN_CONSENSUS) $(BDB_LIBS) $(SSL_LIBS) $(UNBOUND_LIBS) $(CURL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS) $(LIBNAVCOIN_ZMQ) $(EVENT_LIBS) $(EVENT_PTHREADS_LIBS) +test_test_navcoin_LDADD += $(LIBNAVCOIN_CRYPTO) $(LIBNAVCOIN_CONSENSUS) $(BDB_LIBS) $(SSL_LIBS) $(UNBOUND_LIBS) $(CURL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS) $(LIBNAVCOIN_ZMQ) $(EVENT_LIBS) $(EVENT_PTHREADS_LIBS) test_test_navcoin_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) -static if ENABLE_ZMQ diff --git a/src/compat/byteswap.h b/src/compat/byteswap.h index 57ba3316f..137fff47c 100755 --- a/src/compat/byteswap.h +++ b/src/compat/byteswap.h @@ -1,13 +1,9 @@ -// Copyright (c) 2014 The Bitcoin developers +// Copyright (c) 2014-2018 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. -#ifndef NAVCOIN_COMPAT_BYTESWAP_H -#define NAVCOIN_COMPAT_BYTESWAP_H - -#if defined(HAVE_CONFIG_H) -#include "config/navcoin-config.h" -#endif +#ifndef BITCOIN_COMPAT_BYTESWAP_H +#define BITCOIN_COMPAT_BYTESWAP_H #include @@ -15,12 +11,29 @@ #include #endif +#if defined(MAC_OSX) + +#if !defined(bswap_16) + +// Mac OS X / Darwin features; we include a check for bswap_16 because if it is already defined, protobuf has +// defined these macros for us already; if it isn't, we do it ourselves. In either case, we get the exact same +// result regardless which path was taken +#include +#define bswap_16(x) OSSwapInt16(x) +#define bswap_32(x) OSSwapInt32(x) +#define bswap_64(x) OSSwapInt64(x) + +#endif // !defined(bswap_16) + +#else +// Non-Mac OS X / non-Darwin + #if HAVE_DECL_BSWAP_16 == 0 inline uint16_t bswap_16(uint16_t x) { - return (x >> 8) | ((x & 0x00ff) << 8); + return (x >> 8) | (x << 8); } -#endif // HAVE_DECL_BSWAP16 +#endif // HAVE_DECL_BSWAP16 == 0 #if HAVE_DECL_BSWAP_32 == 0 inline uint32_t bswap_32(uint32_t x) @@ -28,7 +41,7 @@ inline uint32_t bswap_32(uint32_t x) return (((x & 0xff000000U) >> 24) | ((x & 0x00ff0000U) >> 8) | ((x & 0x0000ff00U) << 8) | ((x & 0x000000ffU) << 24)); } -#endif // HAVE_DECL_BSWAP32 +#endif // HAVE_DECL_BSWAP32 == 0 #if HAVE_DECL_BSWAP_64 == 0 inline uint64_t bswap_64(uint64_t x) @@ -42,6 +55,8 @@ inline uint64_t bswap_64(uint64_t x) | ((x & 0x000000000000ff00ull) << 40) | ((x & 0x00000000000000ffull) << 56)); } -#endif // HAVE_DECL_BSWAP64 +#endif // HAVE_DECL_BSWAP64 == 0 + +#endif // defined(MAC_OSX) -#endif // NAVCOIN_COMPAT_BYTESWAP_H +#endif // BITCOIN_COMPAT_BYTESWAP_H diff --git a/src/crypto/external/hmac_sha256.c b/src/crypto/external/hmac_sha256.c new file mode 100644 index 000000000..fcf80fc59 --- /dev/null +++ b/src/crypto/external/hmac_sha256.c @@ -0,0 +1,91 @@ +/* libsodium: hmac_hmacsha256.c, v0.4.5 2014/04/16 */ +/** + * Copyright 2005,2007,2009 Colin Percival. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include "hmac_sha256.h" + +#include +#include +#include "sha256.h" +#include "zeroize.h" + +void HMACSHA256(const uint8_t* input, size_t length, const uint8_t* key, + size_t key_length, uint8_t digest[HMACSHA256_DIGEST_LENGTH]) +{ + HMACSHA256CTX context; + HMACSHA256Init(&context, key, key_length); + HMACSHA256Update(&context, input, length); + HMACSHA256Final(&context, digest); +} + +void HMACSHA256Final(HMACSHA256CTX* context, + uint8_t digest[HMACSHA256_DIGEST_LENGTH]) +{ + uint8_t hash[HMACSHA256_DIGEST_LENGTH]; + + SHA256Final(&context->ictx, hash); + SHA256Update(&context->octx, hash, HMACSHA256_DIGEST_LENGTH); + SHA256Final(&context->octx, digest); + + zeroize((void*)hash, sizeof hash); +} + +void HMACSHA256Init(HMACSHA256CTX* context, const uint8_t* key, + size_t key_length) +{ + size_t i; + uint8_t pad[SHA256_BLOCK_LENGTH]; + uint8_t key_hash[SHA256_DIGEST_LENGTH]; + + if (key_length > SHA256_BLOCK_LENGTH) + { + SHA256Init(&context->ictx); + SHA256Update(&context->ictx, key, key_length); + SHA256Final(&context->ictx, key_hash); + key = key_hash; + key_length = SHA256_DIGEST_LENGTH; + } + + SHA256Init(&context->ictx); + memset(pad, 0x36, SHA256_BLOCK_LENGTH); + + for (i = 0; i < key_length; i++) + pad[i] ^= key[i]; + + SHA256Update(&context->ictx, pad, SHA256_BLOCK_LENGTH); + SHA256Init(&context->octx); + memset(pad, 0x5c, SHA256_BLOCK_LENGTH); + + for (i = 0; i < key_length; i++) + pad[i] ^= key[i]; + + SHA256Update(&context->octx, pad, SHA256_BLOCK_LENGTH); + zeroize((void*)key_hash, sizeof key_hash); +} + +void HMACSHA256Update(HMACSHA256CTX* context, const uint8_t* input, + size_t length) +{ + SHA256Update(&context->ictx, input, length); +} diff --git a/src/crypto/external/hmac_sha256.h b/src/crypto/external/hmac_sha256.h new file mode 100644 index 000000000..3093c7329 --- /dev/null +++ b/src/crypto/external/hmac_sha256.h @@ -0,0 +1,63 @@ +/* libsodium: hmac_hmacsha512.c, v0.4.5 2014/04/16 */ +/** + * Copyright 2005,2007,2009 Colin Percival. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef LIBBITCOIN_HMACSHA256_H +#define LIBBITCOIN_HMACSHA256_H + +#include +#include +#include "sha256.h" + +#define HMACSHA256_DIGEST_LENGTH 32U + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct HMACSHA256CTX +{ + SHA256CTX ctx; + SHA256CTX ictx; + SHA256CTX octx; +} HMACSHA256CTX; + +void HMACSHA256(const uint8_t* input, size_t length, const uint8_t* key, + size_t key_length, uint8_t digest[HMACSHA256_DIGEST_LENGTH]); + +void HMACSHA256Final(HMACSHA256CTX* context, + uint8_t digest[HMACSHA256_DIGEST_LENGTH]); + +void HMACSHA256Init(HMACSHA256CTX* context, const uint8_t* key, + size_t key_length); + +void HMACSHA256Update(HMACSHA256CTX* context, const uint8_t* input, + size_t length); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/crypto/external/hmac_sha512.c b/src/crypto/external/hmac_sha512.c new file mode 100644 index 000000000..53706f592 --- /dev/null +++ b/src/crypto/external/hmac_sha512.c @@ -0,0 +1,91 @@ +/* libsodium: hmac_hmacsha512.c, v0.4.5 2014/04/16 */ +/** + * Copyright 2005,2007,2009 Colin Percival. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include "hmac_sha512.h" + +#include +#include +#include "sha512.h" +#include "zeroize.h" + +void HMACSHA512(const uint8_t* input, size_t length, const uint8_t* key, + size_t key_length, uint8_t digest[HMACSHA512_DIGEST_LENGTH]) +{ + HMACSHA512CTX context; + HMACSHA512Init(&context, key, key_length); + HMACSHA512Update(&context, input, length); + HMACSHA512Final(&context, digest); +} + +void HMACSHA512Final(HMACSHA512CTX* context, + uint8_t digest[HMACSHA512_DIGEST_LENGTH]) +{ + uint8_t hash[HMACSHA512_DIGEST_LENGTH]; + + SHA512Final(&context->ictx, hash); + SHA512Update(&context->octx, hash, HMACSHA512_DIGEST_LENGTH); + SHA512Final(&context->octx, digest); + + zeroize((void*)hash, sizeof hash); +} + +void HMACSHA512Init(HMACSHA512CTX* context, const uint8_t* key, + size_t key_length) +{ + size_t i; + uint8_t pad[SHA512_BLOCK_LENGTH]; + uint8_t key_hash[SHA512_DIGEST_LENGTH]; + + if (key_length > SHA512_BLOCK_LENGTH) + { + SHA512Init(&context->ictx); + SHA512Update(&context->ictx, key, key_length); + SHA512Final(&context->ictx, key_hash); + key = key_hash; + key_length = SHA512_DIGEST_LENGTH; + } + + SHA512Init(&context->ictx); + memset(pad, 0x36, SHA512_BLOCK_LENGTH); + + for (i = 0; i < key_length; i++) + pad[i] ^= key[i]; + + SHA512Update(&context->ictx, pad, SHA512_BLOCK_LENGTH); + SHA512Init(&context->octx); + memset(pad, 0x5c, SHA512_BLOCK_LENGTH); + + for (i = 0; i < key_length; i++) + pad[i] ^= key[i]; + + SHA512Update(&context->octx, pad, SHA512_BLOCK_LENGTH); + zeroize((void*)key_hash, sizeof key_hash); +} + +void HMACSHA512Update(HMACSHA512CTX* context, const uint8_t* input, + size_t length) +{ + SHA512Update(&context->ictx, input, length); +} diff --git a/src/crypto/external/hmac_sha512.h b/src/crypto/external/hmac_sha512.h new file mode 100644 index 000000000..bfb1d5117 --- /dev/null +++ b/src/crypto/external/hmac_sha512.h @@ -0,0 +1,62 @@ +/* libsodium: crypto_auth_hmacsha512.h, v0.4.5 2014/04/16 */ +/** + * Copyright 2005,2007,2009 Colin Percival. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef LIBBITCOIN_HMACSHA512_H +#define LIBBITCOIN_HMACSHA512_H + +#include +#include +#include "sha512.h" + +#define HMACSHA512_DIGEST_LENGTH 64U + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct HMACSHA512CTX +{ + SHA512CTX ictx; + SHA512CTX octx; +} HMACSHA512CTX; + +void HMACSHA512(const uint8_t* input, size_t length, const uint8_t* key, + size_t key_length, uint8_t digest[HMACSHA512_DIGEST_LENGTH]); + +void HMACSHA512Final(HMACSHA512CTX* context, + uint8_t digest[HMACSHA512_DIGEST_LENGTH]); + +void HMACSHA512Init(HMACSHA512CTX* context, const uint8_t* key, + size_t key_length); + +void HMACSHA512Update(HMACSHA512CTX* context, const uint8_t* input, + size_t length); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/crypto/external/pkcs5_pbkdf2.c b/src/crypto/external/pkcs5_pbkdf2.c new file mode 100644 index 000000000..16f775268 --- /dev/null +++ b/src/crypto/external/pkcs5_pbkdf2.c @@ -0,0 +1,80 @@ +/* OpenBSD: pkcs5_pbkdf2.c, v 1.9 2015/02/05 12:59:57 millert */ +/** + * Copyright (c) 2008 Damien Bergamini + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#include "pkcs5_pbkdf2.h" + +#include +#include +#include +#include +#include "hmac_sha512.h" +#include "zeroize.h" + +int pkcs5_pbkdf2(const uint8_t* passphrase, size_t passphrase_length, + const uint8_t* salt, size_t salt_length, uint8_t* key, size_t key_length, + size_t iterations) +{ + uint8_t* asalt; + size_t asalt_size; + size_t count, index, iteration, length; + uint8_t buffer[HMACSHA512_DIGEST_LENGTH]; + uint8_t digest1[HMACSHA512_DIGEST_LENGTH]; + uint8_t digest2[HMACSHA512_DIGEST_LENGTH]; + + /* An iteration count of 0 is equivalent to a count of 1. */ + /* A key_length of 0 is a no-op. */ + /* A salt_length of 0 is perfectly valid. */ + + if (salt_length > SIZE_MAX - 4) + return -1; + asalt_size = salt_length + 4; + asalt = malloc(asalt_size); + if (asalt == NULL) + return -1; + + memcpy(asalt, salt, salt_length); + for (count = 1; key_length > 0; count++) + { + asalt[salt_length + 0] = (count >> 24) & 0xff; + asalt[salt_length + 1] = (count >> 16) & 0xff; + asalt[salt_length + 2] = (count >> 8) & 0xff; + asalt[salt_length + 3] = (count >> 0) & 0xff; + HMACSHA512(asalt, asalt_size, passphrase, passphrase_length, digest1); + memcpy(buffer, digest1, sizeof(buffer)); + + for (iteration = 1; iteration < iterations; iteration++) + { + HMACSHA512(digest1, sizeof(digest1), passphrase, passphrase_length, + digest2); + memcpy(digest1, digest2, sizeof(digest1)); + for (index = 0; index < sizeof(buffer); index++) + buffer[index] ^= digest1[index]; + } + + length = (key_length < sizeof(buffer) ? key_length : sizeof(buffer)); + memcpy(key, buffer, length); + key += length; + key_length -= length; + }; + + zeroize(digest1, sizeof(digest1)); + zeroize(digest2, sizeof(digest2)); + zeroize(buffer, sizeof(buffer)); + zeroize(asalt, asalt_size); + free(asalt); + + return 0; +} diff --git a/src/crypto/external/pkcs5_pbkdf2.h b/src/crypto/external/pkcs5_pbkdf2.h new file mode 100644 index 000000000..0a7f16acd --- /dev/null +++ b/src/crypto/external/pkcs5_pbkdf2.h @@ -0,0 +1,40 @@ +/* OpenBSD: pkcs5_pbkdf2.c, v 1.9 2015/02/05 12:59:57 millert */ +/** + * Copyright (c) 2008 Damien Bergamini + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#ifndef LIBBITCOIN_PKCS5PBKDF2_H +#define LIBBITCOIN_PKCS5PBKDF2_H + +#include +#include +#include "pkcs5_pbkdf2.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* Password-Based Key Derivation Function 2 (PKCS #5 v2.0). */ +/* Code based on IEEE Std 802.11-2007, Annex H.4.2. */ +/* returns 0 if successful. */ +int pkcs5_pbkdf2(const uint8_t* passphrase, size_t passphrase_length, + const uint8_t* salt, size_t salt_length, uint8_t* key, size_t key_length, + size_t iterations); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/crypto/external/sha256.c b/src/crypto/external/sha256.c new file mode 100644 index 000000000..80aa76962 --- /dev/null +++ b/src/crypto/external/sha256.c @@ -0,0 +1,276 @@ +/* libsodium: hash_sha256.c, v0.4.5 2014/04/16 */ +/** + * Copyright 2005,2007,2009 Colin Percival. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include "sha256.h" + +#include +#include +#include "zeroize.h" + +static uint32_t be32dec(const void* pp) +{ + const uint8_t* p = (uint8_t const*)pp; + + return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) + + ((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24)); +} + +static void be32enc(void* pp, uint32_t x) +{ + uint8_t* p = (uint8_t*)pp; + + p[3] = x & 0xff; + p[2] = (x >> 8) & 0xff; + p[1] = (x >> 16) & 0xff; + p[0] = (x >> 24) & 0xff; +} + +static void be32enc_vect(uint8_t* dst, const uint32_t* src, size_t len) +{ + size_t i; + for (i = 0; i < len / 4; i++) + { + be32enc(dst + i * 4, src[i]); + } +} + +static void be32dec_vect(uint32_t* dst, const uint8_t* src, size_t len) +{ + size_t i; + for (i = 0; i < len / 4; i++) + { + dst[i] = be32dec(src + i * 4); + } +} + +#define Ch(x, y, z) ((x & (y ^ z)) ^ z) +#define Maj(x, y, z) ((x & (y | z)) | (y & z)) +#define SHR(x, n) (x >> n) +#define ROTR(x, n) ((x >> n) | (x << (32 - n))) +#define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)) +#define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)) +#define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3)) +#define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10)) + +#define RND(a, b, c, d, e, f, g, h, k) \ + t0 = h + S1(e) + Ch(e, f, g) + k; \ + t1 = S0(a) + Maj(a, b, c); \ + d += t0; \ + h = t0 + t1; + +#define RNDr(S, W, i, k) \ + RND(S[(64 - i) % 8], S[(65 - i) % 8], \ + S[(66 - i) % 8], S[(67 - i) % 8], \ + S[(68 - i) % 8], S[(69 - i) % 8], \ + S[(70 - i) % 8], S[(71 - i) % 8], \ + W[i] + k) + +static unsigned char PAD[SHA256_BLOCK_LENGTH] = +{ + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +void SHA256Pad(SHA256CTX* context); +void SHA256Transform(uint32_t state[SHA256_STATE_LENGTH], + const uint8_t block[SHA256_BLOCK_LENGTH]); + +void SHA256_(const uint8_t* input, size_t length, + uint8_t digest[SHA256_DIGEST_LENGTH]) +{ + SHA256CTX context; + SHA256Init(&context); + SHA256Update(&context, input, length); + SHA256Final(&context, digest); +} + +void SHA256Init(SHA256CTX* context) +{ + context->count[0] = context->count[1] = 0; + + context->state[0] = 0x6A09E667; + context->state[1] = 0xBB67AE85; + context->state[2] = 0x3C6EF372; + context->state[3] = 0xA54FF53A; + context->state[4] = 0x510E527F; + context->state[5] = 0x9B05688C; + context->state[6] = 0x1F83D9AB; + context->state[7] = 0x5BE0CD19; +} + +void SHA256Update(SHA256CTX* context, const uint8_t* input, size_t length) +{ + uint32_t bitlen[2]; + uint32_t r = (context->count[1] >> 3) & 0x3f; + + bitlen[1] = ((uint32_t)length) << 3; + bitlen[0] = (uint32_t)(length >> 29); + + if ((context->count[1] += bitlen[1]) < bitlen[1]) + { + context->count[0]++; + } + + context->count[0] += bitlen[0]; + + if (length < 64 - r) + { + memcpy(&context->buf[r], input, length); + return; + } + + memcpy(&context->buf[r], input, 64 - r); + SHA256Transform(context->state, context->buf); + + input += 64 - r; + length -= 64 - r; + + while (length >= 64) + { + SHA256Transform(context->state, input); + input += 64; + length -= 64; + } + + memcpy(context->buf, input, length); +} + +void SHA256Final(SHA256CTX* context, uint8_t digest[SHA256_DIGEST_LENGTH]) +{ + SHA256Pad(context); + be32enc_vect(digest, context->state, SHA256_DIGEST_LENGTH); + zeroize((void*)context, sizeof *context); +} + +/* Local */ + +void SHA256Pad(SHA256CTX* context) +{ + uint8_t len[8]; + uint32_t r, plen; + + be32enc_vect(len, context->count, 8); + + r = (context->count[1] >> 3) & 0x3f; + plen = (r < 56) ? (56 - r) : (120 - r); + + SHA256Update(context, PAD, plen); + SHA256Update(context, len, 8); +} + +void SHA256Transform(uint32_t state[SHA256_STATE_LENGTH], + const uint8_t block[SHA256_BLOCK_LENGTH]) +{ + int i; + uint32_t W[64]; + uint32_t S[8]; + uint32_t t0, t1; + + be32dec_vect(W, block, SHA256_BLOCK_LENGTH); + + for (i = 16; i < 64; i++) + { + W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16]; + } + + memcpy(S, state, 32); + + RNDr(S, W, 0, 0x428a2f98); + RNDr(S, W, 1, 0x71374491); + RNDr(S, W, 2, 0xb5c0fbcf); + RNDr(S, W, 3, 0xe9b5dba5); + RNDr(S, W, 4, 0x3956c25b); + RNDr(S, W, 5, 0x59f111f1); + RNDr(S, W, 6, 0x923f82a4); + RNDr(S, W, 7, 0xab1c5ed5); + RNDr(S, W, 8, 0xd807aa98); + RNDr(S, W, 9, 0x12835b01); + RNDr(S, W, 10, 0x243185be); + RNDr(S, W, 11, 0x550c7dc3); + RNDr(S, W, 12, 0x72be5d74); + RNDr(S, W, 13, 0x80deb1fe); + RNDr(S, W, 14, 0x9bdc06a7); + RNDr(S, W, 15, 0xc19bf174); + RNDr(S, W, 16, 0xe49b69c1); + RNDr(S, W, 17, 0xefbe4786); + RNDr(S, W, 18, 0x0fc19dc6); + RNDr(S, W, 19, 0x240ca1cc); + RNDr(S, W, 20, 0x2de92c6f); + RNDr(S, W, 21, 0x4a7484aa); + RNDr(S, W, 22, 0x5cb0a9dc); + RNDr(S, W, 23, 0x76f988da); + RNDr(S, W, 24, 0x983e5152); + RNDr(S, W, 25, 0xa831c66d); + RNDr(S, W, 26, 0xb00327c8); + RNDr(S, W, 27, 0xbf597fc7); + RNDr(S, W, 28, 0xc6e00bf3); + RNDr(S, W, 29, 0xd5a79147); + RNDr(S, W, 30, 0x06ca6351); + RNDr(S, W, 31, 0x14292967); + RNDr(S, W, 32, 0x27b70a85); + RNDr(S, W, 33, 0x2e1b2138); + RNDr(S, W, 34, 0x4d2c6dfc); + RNDr(S, W, 35, 0x53380d13); + RNDr(S, W, 36, 0x650a7354); + RNDr(S, W, 37, 0x766a0abb); + RNDr(S, W, 38, 0x81c2c92e); + RNDr(S, W, 39, 0x92722c85); + RNDr(S, W, 40, 0xa2bfe8a1); + RNDr(S, W, 41, 0xa81a664b); + RNDr(S, W, 42, 0xc24b8b70); + RNDr(S, W, 43, 0xc76c51a3); + RNDr(S, W, 44, 0xd192e819); + RNDr(S, W, 45, 0xd6990624); + RNDr(S, W, 46, 0xf40e3585); + RNDr(S, W, 47, 0x106aa070); + RNDr(S, W, 48, 0x19a4c116); + RNDr(S, W, 49, 0x1e376c08); + RNDr(S, W, 50, 0x2748774c); + RNDr(S, W, 51, 0x34b0bcb5); + RNDr(S, W, 52, 0x391c0cb3); + RNDr(S, W, 53, 0x4ed8aa4a); + RNDr(S, W, 54, 0x5b9cca4f); + RNDr(S, W, 55, 0x682e6ff3); + RNDr(S, W, 56, 0x748f82ee); + RNDr(S, W, 57, 0x78a5636f); + RNDr(S, W, 58, 0x84c87814); + RNDr(S, W, 59, 0x8cc70208); + RNDr(S, W, 60, 0x90befffa); + RNDr(S, W, 61, 0xa4506ceb); + RNDr(S, W, 62, 0xbef9a3f7); + RNDr(S, W, 63, 0xc67178f2); + + for (i = 0; i < 8; i++) + { + state[i] += S[i]; + } + + zeroize((void*)W, sizeof W); + zeroize((void*)S, sizeof S); + zeroize((void*)&t0, sizeof t0); + zeroize((void*)&t1, sizeof t1); +} diff --git a/src/crypto/external/sha256.h b/src/crypto/external/sha256.h new file mode 100644 index 000000000..647e34de0 --- /dev/null +++ b/src/crypto/external/sha256.h @@ -0,0 +1,60 @@ +/* libsodium: crypto_hash_sha256.h, v0.4.5 2014/04/16 */ +/** + * Copyright 2005,2007,2009 Colin Percival. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef LIBBITCOIN_SHA256_H +#define LIBBITCOIN_SHA256_H + +#include +#include + +#define SHA256_STATE_LENGTH 8U +#define SHA256_COUNT_LENGTH 2U +#define SHA256_BLOCK_LENGTH 64U +#define SHA256_DIGEST_LENGTH 32U + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct SHA256CTX +{ + uint32_t state[SHA256_STATE_LENGTH]; + uint32_t count[SHA256_COUNT_LENGTH]; + uint8_t buf[SHA256_BLOCK_LENGTH]; +} SHA256CTX; + +void SHA256_(const uint8_t* input, size_t length, + uint8_t digest[SHA256_DIGEST_LENGTH]); + +void SHA256Init(SHA256CTX* context); +void SHA256Update(SHA256CTX* context, const uint8_t* input, size_t length); +void SHA256Final(SHA256CTX* context, uint8_t digest[SHA256_DIGEST_LENGTH]); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/crypto/external/sha512.c b/src/crypto/external/sha512.c new file mode 100644 index 000000000..cabc74790 --- /dev/null +++ b/src/crypto/external/sha512.c @@ -0,0 +1,302 @@ +/* libsodium: hash_sha512.c, v0.4.5 2014/04/16 */ +/** + * Copyright 2005,2007,2009 Colin Percival, All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include "sha512.h" + +#include +#include +#include "zeroize.h" + +static uint64_t be64dec(const void* pp) +{ + const uint8_t* p = (uint8_t const*)pp; + + return ((uint64_t)(p[7]) + ((uint64_t)(p[6]) << 8) + + ((uint64_t)(p[5]) << 16) + ((uint64_t)(p[4]) << 24) + + ((uint64_t)(p[3]) << 32) + ((uint64_t)(p[2]) << 40) + + ((uint64_t)(p[1]) << 48) + ((uint64_t)(p[0]) << 56)); +} + +static void be64enc(void *pp, uint64_t x) +{ + uint8_t* p = (uint8_t*)pp; + + p[7] = x & 0xff; + p[6] = (x >> 8) & 0xff; + p[5] = (x >> 16) & 0xff; + p[4] = (x >> 24) & 0xff; + p[3] = (x >> 32) & 0xff; + p[2] = (x >> 40) & 0xff; + p[1] = (x >> 48) & 0xff; + p[0] = (x >> 56) & 0xff; +} + +static void be64enc_vect(unsigned char* dst, const uint64_t* src, size_t len) +{ + size_t i; + for (i = 0; i < len / 8; i++) + { + be64enc(dst + i * 8, src[i]); + } +} + +static void be64dec_vect(uint64_t* dst, const unsigned char* src, size_t len) +{ + size_t i; + for (i = 0; i < len / 8; i++) + { + dst[i] = be64dec(src + i * 8); + } +} + +#define Ch(x, y, z) ((x & (y ^ z)) ^ z) +#define Maj(x, y, z) ((x & (y | z)) | (y & z)) +#define SHR(x, n) (x >> n) +#define ROTR(x, n) ((x >> n) | (x << (64 - n))) +#define S0(x) (ROTR(x, 28) ^ ROTR(x, 34) ^ ROTR(x, 39)) +#define S1(x) (ROTR(x, 14) ^ ROTR(x, 18) ^ ROTR(x, 41)) +#define s0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x, 7)) +#define s1(x) (ROTR(x, 19) ^ ROTR(x, 61) ^ SHR(x, 6)) + +#define RND(a, b, c, d, e, f, g, h, k) \ + t0 = h + S1(e) + Ch(e, f, g) + k; \ + t1 = S0(a) + Maj(a, b, c); \ + d += t0; \ + h = t0 + t1; + +#define RNDr(S, W, i, k) \ + RND(S[(80 - i) % 8], S[(81 - i) % 8], \ + S[(82 - i) % 8], S[(83 - i) % 8], \ + S[(84 - i) % 8], S[(85 - i) % 8], \ + S[(86 - i) % 8], S[(87 - i) % 8], \ + W[i] + k) + +static unsigned char PAD[SHA512_BLOCK_LENGTH] = +{ + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +void SHA512Pad(SHA512CTX* context); +void SHA512Transform(uint64_t state[SHA512_STATE_LENGTH], + const uint8_t block[SHA512_BLOCK_LENGTH]); + +void SHA512_(const uint8_t* input, size_t length, + uint8_t digest[SHA512_DIGEST_LENGTH]) +{ + SHA512CTX context; + SHA512Init(&context); + SHA512Update(&context, input, length); + SHA512Final(&context, digest); +} + +void SHA512Init(SHA512CTX* context) +{ + context->count[0] = context->count[1] = 0; + + context->state[0] = 0x6a09e667f3bcc908ULL; + context->state[1] = 0xbb67ae8584caa73bULL; + context->state[2] = 0x3c6ef372fe94f82bULL; + context->state[3] = 0xa54ff53a5f1d36f1ULL; + context->state[4] = 0x510e527fade682d1ULL; + context->state[5] = 0x9b05688c2b3e6c1fULL; + context->state[6] = 0x1f83d9abfb41bd6bULL; + context->state[7] = 0x5be0cd19137e2179ULL; +} + +void SHA512Update(SHA512CTX* context, const uint8_t* input, size_t length) +{ + uint64_t bitlen[2]; + size_t r = (context->count[1] >> 3) & 0x7f; + + bitlen[1] = ((uint64_t)length) << 3; + bitlen[0] = ((uint64_t)length) >> 61; + + if ((context->count[1] += bitlen[1]) < bitlen[1]) + { + context->count[0]++; + } + + context->count[0] += bitlen[0]; + + if (length < 128 - r) + { + memcpy(&context->buf[r], input, length); + return; + } + + memcpy(&context->buf[r], input, 128 - r); + SHA512Transform(context->state, context->buf); + + input += 128 - r; + length -= 128 - r; + + while (length >= 128) + { + SHA512Transform(context->state, input); + input += 128; + length -= 128; + } + + memcpy(context->buf, input, length); +} + +void SHA512Final(SHA512CTX* context, uint8_t digest[SHA512_DIGEST_LENGTH]) +{ + SHA512Pad(context); + be64enc_vect(digest, context->state, SHA512_DIGEST_LENGTH); + zeroize((void*)context, sizeof *context); +} + +/* Local */ + +void SHA512Pad(SHA512CTX* context) +{ + uint8_t len[16]; + size_t r, plen; + + be64enc_vect(len, context->count, 16); + + r = (context->count[1] >> 3) & 0x7f; + plen = (r < 112) ? (112 - r) : (240 - r); + + SHA512Update(context, PAD, plen); + SHA512Update(context, len, 16); +} + +void SHA512Transform(uint64_t state[SHA512_STATE_LENGTH], + const uint8_t block[SHA512_BLOCK_LENGTH]) +{ + int i; + uint64_t W[80]; + uint64_t S[8]; + uint64_t t0, t1; + + be64dec_vect(W, block, SHA512_BLOCK_LENGTH); + + for (i = 16; i < 80; i++) + { + W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16]; + } + + memcpy(S, state, 64); + + RNDr(S, W, 0, 0x428a2f98d728ae22ULL); + RNDr(S, W, 1, 0x7137449123ef65cdULL); + RNDr(S, W, 2, 0xb5c0fbcfec4d3b2fULL); + RNDr(S, W, 3, 0xe9b5dba58189dbbcULL); + RNDr(S, W, 4, 0x3956c25bf348b538ULL); + RNDr(S, W, 5, 0x59f111f1b605d019ULL); + RNDr(S, W, 6, 0x923f82a4af194f9bULL); + RNDr(S, W, 7, 0xab1c5ed5da6d8118ULL); + RNDr(S, W, 8, 0xd807aa98a3030242ULL); + RNDr(S, W, 9, 0x12835b0145706fbeULL); + RNDr(S, W, 10, 0x243185be4ee4b28cULL); + RNDr(S, W, 11, 0x550c7dc3d5ffb4e2ULL); + RNDr(S, W, 12, 0x72be5d74f27b896fULL); + RNDr(S, W, 13, 0x80deb1fe3b1696b1ULL); + RNDr(S, W, 14, 0x9bdc06a725c71235ULL); + RNDr(S, W, 15, 0xc19bf174cf692694ULL); + RNDr(S, W, 16, 0xe49b69c19ef14ad2ULL); + RNDr(S, W, 17, 0xefbe4786384f25e3ULL); + RNDr(S, W, 18, 0x0fc19dc68b8cd5b5ULL); + RNDr(S, W, 19, 0x240ca1cc77ac9c65ULL); + RNDr(S, W, 20, 0x2de92c6f592b0275ULL); + RNDr(S, W, 21, 0x4a7484aa6ea6e483ULL); + RNDr(S, W, 22, 0x5cb0a9dcbd41fbd4ULL); + RNDr(S, W, 23, 0x76f988da831153b5ULL); + RNDr(S, W, 24, 0x983e5152ee66dfabULL); + RNDr(S, W, 25, 0xa831c66d2db43210ULL); + RNDr(S, W, 26, 0xb00327c898fb213fULL); + RNDr(S, W, 27, 0xbf597fc7beef0ee4ULL); + RNDr(S, W, 28, 0xc6e00bf33da88fc2ULL); + RNDr(S, W, 29, 0xd5a79147930aa725ULL); + RNDr(S, W, 30, 0x06ca6351e003826fULL); + RNDr(S, W, 31, 0x142929670a0e6e70ULL); + RNDr(S, W, 32, 0x27b70a8546d22ffcULL); + RNDr(S, W, 33, 0x2e1b21385c26c926ULL); + RNDr(S, W, 34, 0x4d2c6dfc5ac42aedULL); + RNDr(S, W, 35, 0x53380d139d95b3dfULL); + RNDr(S, W, 36, 0x650a73548baf63deULL); + RNDr(S, W, 37, 0x766a0abb3c77b2a8ULL); + RNDr(S, W, 38, 0x81c2c92e47edaee6ULL); + RNDr(S, W, 39, 0x92722c851482353bULL); + RNDr(S, W, 40, 0xa2bfe8a14cf10364ULL); + RNDr(S, W, 41, 0xa81a664bbc423001ULL); + RNDr(S, W, 42, 0xc24b8b70d0f89791ULL); + RNDr(S, W, 43, 0xc76c51a30654be30ULL); + RNDr(S, W, 44, 0xd192e819d6ef5218ULL); + RNDr(S, W, 45, 0xd69906245565a910ULL); + RNDr(S, W, 46, 0xf40e35855771202aULL); + RNDr(S, W, 47, 0x106aa07032bbd1b8ULL); + RNDr(S, W, 48, 0x19a4c116b8d2d0c8ULL); + RNDr(S, W, 49, 0x1e376c085141ab53ULL); + RNDr(S, W, 50, 0x2748774cdf8eeb99ULL); + RNDr(S, W, 51, 0x34b0bcb5e19b48a8ULL); + RNDr(S, W, 52, 0x391c0cb3c5c95a63ULL); + RNDr(S, W, 53, 0x4ed8aa4ae3418acbULL); + RNDr(S, W, 54, 0x5b9cca4f7763e373ULL); + RNDr(S, W, 55, 0x682e6ff3d6b2b8a3ULL); + RNDr(S, W, 56, 0x748f82ee5defb2fcULL); + RNDr(S, W, 57, 0x78a5636f43172f60ULL); + RNDr(S, W, 58, 0x84c87814a1f0ab72ULL); + RNDr(S, W, 59, 0x8cc702081a6439ecULL); + RNDr(S, W, 60, 0x90befffa23631e28ULL); + RNDr(S, W, 61, 0xa4506cebde82bde9ULL); + RNDr(S, W, 62, 0xbef9a3f7b2c67915ULL); + RNDr(S, W, 63, 0xc67178f2e372532bULL); + RNDr(S, W, 64, 0xca273eceea26619cULL); + RNDr(S, W, 65, 0xd186b8c721c0c207ULL); + RNDr(S, W, 66, 0xeada7dd6cde0eb1eULL); + RNDr(S, W, 67, 0xf57d4f7fee6ed178ULL); + RNDr(S, W, 68, 0x06f067aa72176fbaULL); + RNDr(S, W, 69, 0x0a637dc5a2c898a6ULL); + RNDr(S, W, 70, 0x113f9804bef90daeULL); + RNDr(S, W, 71, 0x1b710b35131c471bULL); + RNDr(S, W, 72, 0x28db77f523047d84ULL); + RNDr(S, W, 73, 0x32caab7b40c72493ULL); + RNDr(S, W, 74, 0x3c9ebe0a15c9bebcULL); + RNDr(S, W, 75, 0x431d67c49c100d4cULL); + RNDr(S, W, 76, 0x4cc5d4becb3e42b6ULL); + RNDr(S, W, 77, 0x597f299cfc657e2aULL); + RNDr(S, W, 78, 0x5fcb6fab3ad6faecULL); + RNDr(S, W, 79, 0x6c44198c4a475817ULL); + + for (i = 0; i < 8; i++) + { + state[i] += S[i]; + } + + zeroize((void*)W, sizeof W); + zeroize((void*)S, sizeof S); + zeroize((void*)&t0, sizeof t0); + zeroize((void*)&t1, sizeof t1); +} diff --git a/src/crypto/external/sha512.h b/src/crypto/external/sha512.h new file mode 100644 index 000000000..df78505d0 --- /dev/null +++ b/src/crypto/external/sha512.h @@ -0,0 +1,60 @@ +/* libsodium: crypto_hash_sha512.h, v0.4.5 2014/04/16 */ +/** + * Copyright 2005,2007,2009 Colin Percival. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef LIBBITCOIN_SHA512_H +#define LIBBITCOIN_SHA512_H + +#include +#include + +#define SHA512_STATE_LENGTH 8U +#define SHA512_COUNT_LENGTH 2U +#define SHA512_BLOCK_LENGTH 128U +#define SHA512_DIGEST_LENGTH 64U + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct SHA512CTX +{ + uint64_t state[SHA512_STATE_LENGTH]; + uint64_t count[SHA512_COUNT_LENGTH]; + uint8_t buf[SHA512_BLOCK_LENGTH]; +} SHA512CTX; + +void SHA512_(const uint8_t* input, size_t length, + uint8_t digest[SHA512_DIGEST_LENGTH]); + +void SHA512Init(SHA512CTX* context); +void SHA512Update(SHA512CTX* context, const uint8_t* input, size_t length); +void SHA512Final(SHA512CTX* context, uint8_t digest[SHA512_DIGEST_LENGTH]); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/crypto/external/zeroize.c b/src/crypto/external/zeroize.c new file mode 100644 index 000000000..89c7659cb --- /dev/null +++ b/src/crypto/external/zeroize.c @@ -0,0 +1,40 @@ +/* libsodium: utils.c, v0.4.5 2014/04/16 */ +/** + * Copyright (c) 2013-2014 + * Frank Denis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#include "zeroize.h" + +#include +#include +#include + +void zeroize(void* const buffer, size_t length) +{ +/* +#ifdef HAVE_SECUREZEROMEMORY + SecureZeroMemory(buffer, length); +#elif defined(HAVE_MEMSET_S) +*/ +#if defined(HAVE_MEMSET_S) + if (memset_s(buffer, (rsize_t)length, 0, (rsize_t)length) != 0) + abort(); +#else + size_t i; + volatile uint8_t* vbuffer = (volatile uint8_t*)buffer; + for (i = 0; i < length; i++) + vbuffer[i] = 0; +#endif +} diff --git a/src/crypto/external/zeroize.h b/src/crypto/external/zeroize.h new file mode 100644 index 000000000..1c79ee93d --- /dev/null +++ b/src/crypto/external/zeroize.h @@ -0,0 +1,34 @@ +/* libsodium: utils.c, v0.4.5 2014/04/16 */ +/** + * Copyright (c) 2013-2014 + * Frank Denis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#ifndef LIBBITCOIN_ZEROIZE_HPP +#define LIBBITCOIN_ZEROIZE_HPP + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +void zeroize(void* const buffer, size_t length); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/mnemonic/arrayslice.h b/src/mnemonic/arrayslice.h new file mode 100644 index 000000000..04a206f0a --- /dev/null +++ b/src/mnemonic/arrayslice.h @@ -0,0 +1,45 @@ +/** + * Copyright (c) 2011-2019 libbitcoin developers (see AUTHORS) + * + * This file is part of libbitcoin. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#ifndef VEIL_ARRAYSLICE_H +#define VEIL_ARRAYSLICE_H + +#include + +template +class array_slice +{ +public: + template + array_slice(const Container& container) : begin_(container.data()), end_(container.data() + container.size()) {} + + array_slice(const Iterable* begin, const Iterable* end) : begin_(begin), end_(end) {} + + const Iterable* begin() const { return begin_; } + const Iterable* end() const { return end_; } + const Iterable* data() const { return begin_; } + std::size_t size() const { return end_ - begin_; } + bool empty() const { return end_ == begin_; } + +private: + const Iterable* begin_; + const Iterable* end_; +}; + +#endif //VEIL_ARRAYSLICE_H diff --git a/src/mnemonic/dictionary.cpp b/src/mnemonic/dictionary.cpp new file mode 100644 index 000000000..8e45b27a8 --- /dev/null +++ b/src/mnemonic/dictionary.cpp @@ -0,0 +1,20560 @@ +#include "dictionary.h" + +namespace language { + const dictionary en = + { + { + "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" + } + }; + + const dictionary es = + { + { + "ábaco", + "abdomen", + "abeja", + "abierto", + "abogado", + "abono", + "aborto", + "abrazo", + "abrir", + "abuelo", + "abuso", + "acabar", + "academia", + "acceso", + "acción", + "aceite", + "acelga", + "acento", + "aceptar", + "ácido", + "aclarar", + "acné", + "acoger", + "acoso", + "activo", + "acto", + "actriz", + "actuar", + "acudir", + "acuerdo", + "acusar", + "adicto", + "admitir", + "adoptar", + "adorno", + "aduana", + "adulto", + "aéreo", + "afectar", + "afición", + "afinar", + "afirmar", + "ágil", + "agitar", + "agonía", + "agosto", + "agotar", + "agregar", + "agrio", + "agua", + "agudo", + "águila", + "aguja", + "ahogo", + "ahorro", + "aire", + "aislar", + "ajedrez", + "ajeno", + "ajuste", + "alacrán", + "alambre", + "alarma", + "alba", + "álbum", + "alcalde", + "aldea", + "alegre", + "alejar", + "alerta", + "aleta", + "alfiler", + "alga", + "algodón", + "aliado", + "aliento", + "alivio", + "alma", + "almeja", + "almíbar", + "altar", + "alteza", + "altivo", + "alto", + "altura", + "alumno", + "alzar", + "amable", + "amante", + "amapola", + "amargo", + "amasar", + "ámbar", + "ámbito", + "ameno", + "amigo", + "amistad", + "amor", + "amparo", + "amplio", + "ancho", + "anciano", + "ancla", + "andar", + "andén", + "anemia", + "ángulo", + "anillo", + "ánimo", + "anís", + "anotar", + "antena", + "antiguo", + "antojo", + "anual", + "anular", + "anuncio", + "añadir", + "añejo", + "año", + "apagar", + "aparato", + "apetito", + "apio", + "aplicar", + "apodo", + "aporte", + "apoyo", + "aprender", + "aprobar", + "apuesta", + "apuro", + "arado", + "araña", + "arar", + "árbitro", + "árbol", + "arbusto", + "archivo", + "arco", + "arder", + "ardilla", + "arduo", + "área", + "árido", + "aries", + "armonía", + "arnés", + "aroma", + "arpa", + "arpón", + "arreglo", + "arroz", + "arruga", + "arte", + "artista", + "asa", + "asado", + "asalto", + "ascenso", + "asegurar", + "aseo", + "asesor", + "asiento", + "asilo", + "asistir", + "asno", + "asombro", + "áspero", + "astilla", + "astro", + "astuto", + "asumir", + "asunto", + "atajo", + "ataque", + "atar", + "atento", + "ateo", + "ático", + "atleta", + "átomo", + "atraer", + "atroz", + "atún", + "audaz", + "audio", + "auge", + "aula", + "aumento", + "ausente", + "autor", + "aval", + "avance", + "avaro", + "ave", + "avellana", + "avena", + "avestruz", + "avión", + "aviso", + "ayer", + "ayuda", + "ayuno", + "azafrán", + "azar", + "azote", + "azúcar", + "azufre", + "azul", + "baba", + "babor", + "bache", + "bahía", + "baile", + "bajar", + "balanza", + "balcón", + "balde", + "bambú", + "banco", + "banda", + "baño", + "barba", + "barco", + "barniz", + "barro", + "báscula", + "bastón", + "basura", + "batalla", + "batería", + "batir", + "batuta", + "baúl", + "bazar", + "bebé", + "bebida", + "bello", + "besar", + "beso", + "bestia", + "bicho", + "bien", + "bingo", + "blanco", + "bloque", + "blusa", + "boa", + "bobina", + "bobo", + "boca", + "bocina", + "boda", + "bodega", + "boina", + "bola", + "bolero", + "bolsa", + "bomba", + "bondad", + "bonito", + "bono", + "bonsái", + "borde", + "borrar", + "bosque", + "bote", + "botín", + "bóveda", + "bozal", + "bravo", + "brazo", + "brecha", + "breve", + "brillo", + "brinco", + "brisa", + "broca", + "broma", + "bronce", + "brote", + "bruja", + "brusco", + "bruto", + "buceo", + "bucle", + "bueno", + "buey", + "bufanda", + "bufón", + "búho", + "buitre", + "bulto", + "burbuja", + "burla", + "burro", + "buscar", + "butaca", + "buzón", + "caballo", + "cabeza", + "cabina", + "cabra", + "cacao", + "cadáver", + "cadena", + "caer", + "café", + "caída", + "caimán", + "caja", + "cajón", + "cal", + "calamar", + "calcio", + "caldo", + "calidad", + "calle", + "calma", + "calor", + "calvo", + "cama", + "cambio", + "camello", + "camino", + "campo", + "cáncer", + "candil", + "canela", + "canguro", + "canica", + "canto", + "caña", + "cañón", + "caoba", + "caos", + "capaz", + "capitán", + "capote", + "captar", + "capucha", + "cara", + "carbón", + "cárcel", + "careta", + "carga", + "cariño", + "carne", + "carpeta", + "carro", + "carta", + "casa", + "casco", + "casero", + "caspa", + "castor", + "catorce", + "catre", + "caudal", + "causa", + "cazo", + "cebolla", + "ceder", + "cedro", + "celda", + "célebre", + "celoso", + "célula", + "cemento", + "ceniza", + "centro", + "cerca", + "cerdo", + "cereza", + "cero", + "cerrar", + "certeza", + "césped", + "cetro", + "chacal", + "chaleco", + "champú", + "chancla", + "chapa", + "charla", + "chico", + "chiste", + "chivo", + "choque", + "choza", + "chuleta", + "chupar", + "ciclón", + "ciego", + "cielo", + "cien", + "cierto", + "cifra", + "cigarro", + "cima", + "cinco", + "cine", + "cinta", + "ciprés", + "circo", + "ciruela", + "cisne", + "cita", + "ciudad", + "clamor", + "clan", + "claro", + "clase", + "clave", + "cliente", + "clima", + "clínica", + "cobre", + "cocción", + "cochino", + "cocina", + "coco", + "código", + "codo", + "cofre", + "coger", + "cohete", + "cojín", + "cojo", + "cola", + "colcha", + "colegio", + "colgar", + "colina", + "collar", + "colmo", + "columna", + "combate", + "comer", + "comida", + "cómodo", + "compra", + "conde", + "conejo", + "conga", + "conocer", + "consejo", + "contar", + "copa", + "copia", + "corazón", + "corbata", + "corcho", + "cordón", + "corona", + "correr", + "coser", + "cosmos", + "costa", + "cráneo", + "cráter", + "crear", + "crecer", + "creído", + "crema", + "cría", + "crimen", + "cripta", + "crisis", + "cromo", + "crónica", + "croqueta", + "crudo", + "cruz", + "cuadro", + "cuarto", + "cuatro", + "cubo", + "cubrir", + "cuchara", + "cuello", + "cuento", + "cuerda", + "cuesta", + "cueva", + "cuidar", + "culebra", + "culpa", + "culto", + "cumbre", + "cumplir", + "cuna", + "cuneta", + "cuota", + "cupón", + "cúpula", + "curar", + "curioso", + "curso", + "curva", + "cutis", + "dama", + "danza", + "dar", + "dardo", + "dátil", + "deber", + "débil", + "década", + "decir", + "dedo", + "defensa", + "definir", + "dejar", + "delfín", + "delgado", + "delito", + "demora", + "denso", + "dental", + "deporte", + "derecho", + "derrota", + "desayuno", + "deseo", + "desfile", + "desnudo", + "destino", + "desvío", + "detalle", + "detener", + "deuda", + "día", + "diablo", + "diadema", + "diamante", + "diana", + "diario", + "dibujo", + "dictar", + "diente", + "dieta", + "diez", + "difícil", + "digno", + "dilema", + "diluir", + "dinero", + "directo", + "dirigir", + "disco", + "diseño", + "disfraz", + "diva", + "divino", + "doble", + "doce", + "dolor", + "domingo", + "don", + "donar", + "dorado", + "dormir", + "dorso", + "dos", + "dosis", + "dragón", + "droga", + "ducha", + "duda", + "duelo", + "dueño", + "dulce", + "dúo", + "duque", + "durar", + "dureza", + "duro", + "ébano", + "ebrio", + "echar", + "eco", + "ecuador", + "edad", + "edición", + "edificio", + "editor", + "educar", + "efecto", + "eficaz", + "eje", + "ejemplo", + "elefante", + "elegir", + "elemento", + "elevar", + "elipse", + "élite", + "elixir", + "elogio", + "eludir", + "embudo", + "emitir", + "emoción", + "empate", + "empeño", + "empleo", + "empresa", + "enano", + "encargo", + "enchufe", + "encía", + "enemigo", + "enero", + "enfado", + "enfermo", + "engaño", + "enigma", + "enlace", + "enorme", + "enredo", + "ensayo", + "enseñar", + "entero", + "entrar", + "envase", + "envío", + "época", + "equipo", + "erizo", + "escala", + "escena", + "escolar", + "escribir", + "escudo", + "esencia", + "esfera", + "esfuerzo", + "espada", + "espejo", + "espía", + "esposa", + "espuma", + "esquí", + "estar", + "este", + "estilo", + "estufa", + "etapa", + "eterno", + "ética", + "etnia", + "evadir", + "evaluar", + "evento", + "evitar", + "exacto", + "examen", + "exceso", + "excusa", + "exento", + "exigir", + "exilio", + "existir", + "éxito", + "experto", + "explicar", + "exponer", + "extremo", + "fábrica", + "fábula", + "fachada", + "fácil", + "factor", + "faena", + "faja", + "falda", + "fallo", + "falso", + "faltar", + "fama", + "familia", + "famoso", + "faraón", + "farmacia", + "farol", + "farsa", + "fase", + "fatiga", + "fauna", + "favor", + "fax", + "febrero", + "fecha", + "feliz", + "feo", + "feria", + "feroz", + "fértil", + "fervor", + "festín", + "fiable", + "fianza", + "fiar", + "fibra", + "ficción", + "ficha", + "fideo", + "fiebre", + "fiel", + "fiera", + "fiesta", + "figura", + "fijar", + "fijo", + "fila", + "filete", + "filial", + "filtro", + "fin", + "finca", + "fingir", + "finito", + "firma", + "flaco", + "flauta", + "flecha", + "flor", + "flota", + "fluir", + "flujo", + "flúor", + "fobia", + "foca", + "fogata", + "fogón", + "folio", + "folleto", + "fondo", + "forma", + "forro", + "fortuna", + "forzar", + "fosa", + "foto", + "fracaso", + "frágil", + "franja", + "frase", + "fraude", + "freír", + "freno", + "fresa", + "frío", + "frito", + "fruta", + "fuego", + "fuente", + "fuerza", + "fuga", + "fumar", + "función", + "funda", + "furgón", + "furia", + "fusil", + "fútbol", + "futuro", + "gacela", + "gafas", + "gaita", + "gajo", + "gala", + "galería", + "gallo", + "gamba", + "ganar", + "gancho", + "ganga", + "ganso", + "garaje", + "garza", + "gasolina", + "gastar", + "gato", + "gavilán", + "gemelo", + "gemir", + "gen", + "género", + "genio", + "gente", + "geranio", + "gerente", + "germen", + "gesto", + "gigante", + "gimnasio", + "girar", + "giro", + "glaciar", + "globo", + "gloria", + "gol", + "golfo", + "goloso", + "golpe", + "goma", + "gordo", + "gorila", + "gorra", + "gota", + "goteo", + "gozar", + "grada", + "gráfico", + "grano", + "grasa", + "gratis", + "grave", + "grieta", + "grillo", + "gripe", + "gris", + "grito", + "grosor", + "grúa", + "grueso", + "grumo", + "grupo", + "guante", + "guapo", + "guardia", + "guerra", + "guía", + "guiño", + "guion", + "guiso", + "guitarra", + "gusano", + "gustar", + "haber", + "hábil", + "hablar", + "hacer", + "hacha", + "hada", + "hallar", + "hamaca", + "harina", + "haz", + "hazaña", + "hebilla", + "hebra", + "hecho", + "helado", + "helio", + "hembra", + "herir", + "hermano", + "héroe", + "hervir", + "hielo", + "hierro", + "hígado", + "higiene", + "hijo", + "himno", + "historia", + "hocico", + "hogar", + "hoguera", + "hoja", + "hombre", + "hongo", + "honor", + "honra", + "hora", + "hormiga", + "horno", + "hostil", + "hoyo", + "hueco", + "huelga", + "huerta", + "hueso", + "huevo", + "huida", + "huir", + "humano", + "húmedo", + "humilde", + "humo", + "hundir", + "huracán", + "hurto", + "icono", + "ideal", + "idioma", + "ídolo", + "iglesia", + "iglú", + "igual", + "ilegal", + "ilusión", + "imagen", + "imán", + "imitar", + "impar", + "imperio", + "imponer", + "impulso", + "incapaz", + "índice", + "inerte", + "infiel", + "informe", + "ingenio", + "inicio", + "inmenso", + "inmune", + "innato", + "insecto", + "instante", + "interés", + "íntimo", + "intuir", + "inútil", + "invierno", + "ira", + "iris", + "ironía", + "isla", + "islote", + "jabalí", + "jabón", + "jamón", + "jarabe", + "jardín", + "jarra", + "jaula", + "jazmín", + "jefe", + "jeringa", + "jinete", + "jornada", + "joroba", + "joven", + "joya", + "juerga", + "jueves", + "juez", + "jugador", + "jugo", + "juguete", + "juicio", + "junco", + "jungla", + "junio", + "juntar", + "júpiter", + "jurar", + "justo", + "juvenil", + "juzgar", + "kilo", + "koala", + "labio", + "lacio", + "lacra", + "lado", + "ladrón", + "lagarto", + "lágrima", + "laguna", + "laico", + "lamer", + "lámina", + "lámpara", + "lana", + "lancha", + "langosta", + "lanza", + "lápiz", + "largo", + "larva", + "lástima", + "lata", + "látex", + "latir", + "laurel", + "lavar", + "lazo", + "leal", + "lección", + "leche", + "lector", + "leer", + "legión", + "legumbre", + "lejano", + "lengua", + "lento", + "leña", + "león", + "leopardo", + "lesión", + "letal", + "letra", + "leve", + "leyenda", + "libertad", + "libro", + "licor", + "líder", + "lidiar", + "lienzo", + "liga", + "ligero", + "lima", + "límite", + "limón", + "limpio", + "lince", + "lindo", + "línea", + "lingote", + "lino", + "linterna", + "líquido", + "liso", + "lista", + "litera", + "litio", + "litro", + "llaga", + "llama", + "llanto", + "llave", + "llegar", + "llenar", + "llevar", + "llorar", + "llover", + "lluvia", + "lobo", + "loción", + "loco", + "locura", + "lógica", + "logro", + "lombriz", + "lomo", + "lonja", + "lote", + "lucha", + "lucir", + "lugar", + "lujo", + "luna", + "lunes", + "lupa", + "lustro", + "luto", + "luz", + "maceta", + "macho", + "madera", + "madre", + "maduro", + "maestro", + "mafia", + "magia", + "mago", + "maíz", + "maldad", + "maleta", + "malla", + "malo", + "mamá", + "mambo", + "mamut", + "manco", + "mando", + "manejar", + "manga", + "maniquí", + "manjar", + "mano", + "manso", + "manta", + "mañana", + "mapa", + "máquina", + "mar", + "marco", + "marea", + "marfil", + "margen", + "marido", + "mármol", + "marrón", + "martes", + "marzo", + "masa", + "máscara", + "masivo", + "matar", + "materia", + "matiz", + "matriz", + "máximo", + "mayor", + "mazorca", + "mecha", + "medalla", + "medio", + "médula", + "mejilla", + "mejor", + "melena", + "melón", + "memoria", + "menor", + "mensaje", + "mente", + "menú", + "mercado", + "merengue", + "mérito", + "mes", + "mesón", + "meta", + "meter", + "método", + "metro", + "mezcla", + "miedo", + "miel", + "miembro", + "miga", + "mil", + "milagro", + "militar", + "millón", + "mimo", + "mina", + "minero", + "mínimo", + "minuto", + "miope", + "mirar", + "misa", + "miseria", + "misil", + "mismo", + "mitad", + "mito", + "mochila", + "moción", + "moda", + "modelo", + "moho", + "mojar", + "molde", + "moler", + "molino", + "momento", + "momia", + "monarca", + "moneda", + "monja", + "monto", + "moño", + "morada", + "morder", + "moreno", + "morir", + "morro", + "morsa", + "mortal", + "mosca", + "mostrar", + "motivo", + "mover", + "móvil", + "mozo", + "mucho", + "mudar", + "mueble", + "muela", + "muerte", + "muestra", + "mugre", + "mujer", + "mula", + "muleta", + "multa", + "mundo", + "muñeca", + "mural", + "muro", + "músculo", + "museo", + "musgo", + "música", + "muslo", + "nácar", + "nación", + "nadar", + "naipe", + "naranja", + "nariz", + "narrar", + "nasal", + "natal", + "nativo", + "natural", + "náusea", + "naval", + "nave", + "navidad", + "necio", + "néctar", + "negar", + "negocio", + "negro", + "neón", + "nervio", + "neto", + "neutro", + "nevar", + "nevera", + "nicho", + "nido", + "niebla", + "nieto", + "niñez", + "niño", + "nítido", + "nivel", + "nobleza", + "noche", + "nómina", + "noria", + "norma", + "norte", + "nota", + "noticia", + "novato", + "novela", + "novio", + "nube", + "nuca", + "núcleo", + "nudillo", + "nudo", + "nuera", + "nueve", + "nuez", + "nulo", + "número", + "nutria", + "oasis", + "obeso", + "obispo", + "objeto", + "obra", + "obrero", + "observar", + "obtener", + "obvio", + "oca", + "ocaso", + "océano", + "ochenta", + "ocho", + "ocio", + "ocre", + "octavo", + "octubre", + "oculto", + "ocupar", + "ocurrir", + "odiar", + "odio", + "odisea", + "oeste", + "ofensa", + "oferta", + "oficio", + "ofrecer", + "ogro", + "oído", + "oír", + "ojo", + "ola", + "oleada", + "olfato", + "olivo", + "olla", + "olmo", + "olor", + "olvido", + "ombligo", + "onda", + "onza", + "opaco", + "opción", + "ópera", + "opinar", + "oponer", + "optar", + "óptica", + "opuesto", + "oración", + "orador", + "oral", + "órbita", + "orca", + "orden", + "oreja", + "órgano", + "orgía", + "orgullo", + "oriente", + "origen", + "orilla", + "oro", + "orquesta", + "oruga", + "osadía", + "oscuro", + "osezno", + "oso", + "ostra", + "otoño", + "otro", + "oveja", + "óvulo", + "óxido", + "oxígeno", + "oyente", + "ozono", + "pacto", + "padre", + "paella", + "página", + "pago", + "país", + "pájaro", + "palabra", + "palco", + "paleta", + "pálido", + "palma", + "paloma", + "palpar", + "pan", + "panal", + "pánico", + "pantera", + "pañuelo", + "papá", + "papel", + "papilla", + "paquete", + "parar", + "parcela", + "pared", + "parir", + "paro", + "párpado", + "parque", + "párrafo", + "parte", + "pasar", + "paseo", + "pasión", + "paso", + "pasta", + "pata", + "patio", + "patria", + "pausa", + "pauta", + "pavo", + "payaso", + "peatón", + "pecado", + "pecera", + "pecho", + "pedal", + "pedir", + "pegar", + "peine", + "pelar", + "peldaño", + "pelea", + "peligro", + "pellejo", + "pelo", + "peluca", + "pena", + "pensar", + "peñón", + "peón", + "peor", + "pepino", + "pequeño", + "pera", + "percha", + "perder", + "pereza", + "perfil", + "perico", + "perla", + "permiso", + "perro", + "persona", + "pesa", + "pesca", + "pésimo", + "pestaña", + "pétalo", + "petróleo", + "pez", + "pezuña", + "picar", + "pichón", + "pie", + "piedra", + "pierna", + "pieza", + "pijama", + "pilar", + "piloto", + "pimienta", + "pino", + "pintor", + "pinza", + "piña", + "piojo", + "pipa", + "pirata", + "pisar", + "piscina", + "piso", + "pista", + "pitón", + "pizca", + "placa", + "plan", + "plata", + "playa", + "plaza", + "pleito", + "pleno", + "plomo", + "pluma", + "plural", + "pobre", + "poco", + "poder", + "podio", + "poema", + "poesía", + "poeta", + "polen", + "policía", + "pollo", + "polvo", + "pomada", + "pomelo", + "pomo", + "pompa", + "poner", + "porción", + "portal", + "posada", + "poseer", + "posible", + "poste", + "potencia", + "potro", + "pozo", + "prado", + "precoz", + "pregunta", + "premio", + "prensa", + "preso", + "previo", + "primo", + "príncipe", + "prisión", + "privar", + "proa", + "probar", + "proceso", + "producto", + "proeza", + "profesor", + "programa", + "prole", + "promesa", + "pronto", + "propio", + "próximo", + "prueba", + "público", + "puchero", + "pudor", + "pueblo", + "puerta", + "puesto", + "pulga", + "pulir", + "pulmón", + "pulpo", + "pulso", + "puma", + "punto", + "puñal", + "puño", + "pupa", + "pupila", + "puré", + "quedar", + "queja", + "quemar", + "querer", + "queso", + "quieto", + "química", + "quince", + "quitar", + "rábano", + "rabia", + "rabo", + "ración", + "radical", + "raíz", + "rama", + "rampa", + "rancho", + "rango", + "rapaz", + "rápido", + "rapto", + "rasgo", + "raspa", + "rato", + "rayo", + "raza", + "razón", + "reacción", + "realidad", + "rebaño", + "rebote", + "recaer", + "receta", + "rechazo", + "recoger", + "recreo", + "recto", + "recurso", + "red", + "redondo", + "reducir", + "reflejo", + "reforma", + "refrán", + "refugio", + "regalo", + "regir", + "regla", + "regreso", + "rehén", + "reino", + "reír", + "reja", + "relato", + "relevo", + "relieve", + "relleno", + "reloj", + "remar", + "remedio", + "remo", + "rencor", + "rendir", + "renta", + "reparto", + "repetir", + "reposo", + "reptil", + "res", + "rescate", + "resina", + "respeto", + "resto", + "resumen", + "retiro", + "retorno", + "retrato", + "reunir", + "revés", + "revista", + "rey", + "rezar", + "rico", + "riego", + "rienda", + "riesgo", + "rifa", + "rígido", + "rigor", + "rincón", + "riñón", + "río", + "riqueza", + "risa", + "ritmo", + "rito", + "rizo", + "roble", + "roce", + "rociar", + "rodar", + "rodeo", + "rodilla", + "roer", + "rojizo", + "rojo", + "romero", + "romper", + "ron", + "ronco", + "ronda", + "ropa", + "ropero", + "rosa", + "rosca", + "rostro", + "rotar", + "rubí", + "rubor", + "rudo", + "rueda", + "rugir", + "ruido", + "ruina", + "ruleta", + "rulo", + "rumbo", + "rumor", + "ruptura", + "ruta", + "rutina", + "sábado", + "saber", + "sabio", + "sable", + "sacar", + "sagaz", + "sagrado", + "sala", + "saldo", + "salero", + "salir", + "salmón", + "salón", + "salsa", + "salto", + "salud", + "salvar", + "samba", + "sanción", + "sandía", + "sanear", + "sangre", + "sanidad", + "sano", + "santo", + "sapo", + "saque", + "sardina", + "sartén", + "sastre", + "satán", + "sauna", + "saxofón", + "sección", + "seco", + "secreto", + "secta", + "sed", + "seguir", + "seis", + "sello", + "selva", + "semana", + "semilla", + "senda", + "sensor", + "señal", + "señor", + "separar", + "sepia", + "sequía", + "ser", + "serie", + "sermón", + "servir", + "sesenta", + "sesión", + "seta", + "setenta", + "severo", + "sexo", + "sexto", + "sidra", + "siesta", + "siete", + "siglo", + "signo", + "sílaba", + "silbar", + "silencio", + "silla", + "símbolo", + "simio", + "sirena", + "sistema", + "sitio", + "situar", + "sobre", + "socio", + "sodio", + "sol", + "solapa", + "soldado", + "soledad", + "sólido", + "soltar", + "solución", + "sombra", + "sondeo", + "sonido", + "sonoro", + "sonrisa", + "sopa", + "soplar", + "soporte", + "sordo", + "sorpresa", + "sorteo", + "sostén", + "sótano", + "suave", + "subir", + "suceso", + "sudor", + "suegra", + "suelo", + "sueño", + "suerte", + "sufrir", + "sujeto", + "sultán", + "sumar", + "superar", + "suplir", + "suponer", + "supremo", + "sur", + "surco", + "sureño", + "surgir", + "susto", + "sutil", + "tabaco", + "tabique", + "tabla", + "tabú", + "taco", + "tacto", + "tajo", + "talar", + "talco", + "talento", + "talla", + "talón", + "tamaño", + "tambor", + "tango", + "tanque", + "tapa", + "tapete", + "tapia", + "tapón", + "taquilla", + "tarde", + "tarea", + "tarifa", + "tarjeta", + "tarot", + "tarro", + "tarta", + "tatuaje", + "tauro", + "taza", + "tazón", + "teatro", + "techo", + "tecla", + "técnica", + "tejado", + "tejer", + "tejido", + "tela", + "teléfono", + "tema", + "temor", + "templo", + "tenaz", + "tender", + "tener", + "tenis", + "tenso", + "teoría", + "terapia", + "terco", + "término", + "ternura", + "terror", + "tesis", + "tesoro", + "testigo", + "tetera", + "texto", + "tez", + "tibio", + "tiburón", + "tiempo", + "tienda", + "tierra", + "tieso", + "tigre", + "tijera", + "tilde", + "timbre", + "tímido", + "timo", + "tinta", + "tío", + "típico", + "tipo", + "tira", + "tirón", + "titán", + "títere", + "título", + "tiza", + "toalla", + "tobillo", + "tocar", + "tocino", + "todo", + "toga", + "toldo", + "tomar", + "tono", + "tonto", + "topar", + "tope", + "toque", + "tórax", + "torero", + "tormenta", + "torneo", + "toro", + "torpedo", + "torre", + "torso", + "tortuga", + "tos", + "tosco", + "toser", + "tóxico", + "trabajo", + "tractor", + "traer", + "tráfico", + "trago", + "traje", + "tramo", + "trance", + "trato", + "trauma", + "trazar", + "trébol", + "tregua", + "treinta", + "tren", + "trepar", + "tres", + "tribu", + "trigo", + "tripa", + "triste", + "triunfo", + "trofeo", + "trompa", + "tronco", + "tropa", + "trote", + "trozo", + "truco", + "trueno", + "trufa", + "tubería", + "tubo", + "tuerto", + "tumba", + "tumor", + "túnel", + "túnica", + "turbina", + "turismo", + "turno", + "tutor", + "ubicar", + "úlcera", + "umbral", + "unidad", + "unir", + "universo", + "uno", + "untar", + "uña", + "urbano", + "urbe", + "urgente", + "urna", + "usar", + "usuario", + "útil", + "utopía", + "uva", + "vaca", + "vacío", + "vacuna", + "vagar", + "vago", + "vaina", + "vajilla", + "vale", + "válido", + "valle", + "valor", + "válvula", + "vampiro", + "vara", + "variar", + "varón", + "vaso", + "vecino", + "vector", + "vehículo", + "veinte", + "vejez", + "vela", + "velero", + "veloz", + "vena", + "vencer", + "venda", + "veneno", + "vengar", + "venir", + "venta", + "venus", + "ver", + "verano", + "verbo", + "verde", + "vereda", + "verja", + "verso", + "verter", + "vía", + "viaje", + "vibrar", + "vicio", + "víctima", + "vida", + "vídeo", + "vidrio", + "viejo", + "viernes", + "vigor", + "vil", + "villa", + "vinagre", + "vino", + "viñedo", + "violín", + "viral", + "virgo", + "virtud", + "visor", + "víspera", + "vista", + "vitamina", + "viudo", + "vivaz", + "vivero", + "vivir", + "vivo", + "volcán", + "volumen", + "volver", + "voraz", + "votar", + "voto", + "voz", + "vuelo", + "vulgar", + "yacer", + "yate", + "yegua", + "yema", + "yerno", + "yeso", + "yodo", + "yoga", + "yogur", + "zafiro", + "zanja", + "zapato", + "zarza", + "zona", + "zorro", + "zumo", + "zurdo" + } + }; + + const dictionary ja = + { + { + "あいこくしん", + "あいさつ", + "あいだ", + "あおぞら", + "あかちゃん", + "あきる", + "あけがた", + "あける", + "あこがれる", + "あさい", + "あさひ", + "あしあと", + "あじわう", + "あずかる", + "あずき", + "あそぶ", + "あたえる", + "あたためる", + "あたりまえ", + "あたる", + "あつい", + "あつかう", + "あっしゅく", + "あつまり", + "あつめる", + "あてな", + "あてはまる", + "あひる", + "あぶら", + "あぶる", + "あふれる", + "あまい", + "あまど", + "あまやかす", + "あまり", + "あみもの", + "あめりか", + "あやまる", + "あゆむ", + "あらいぐま", + "あらし", + "あらすじ", + "あらためる", + "あらゆる", + "あらわす", + "ありがとう", + "あわせる", + "あわてる", + "あんい", + "あんがい", + "あんこ", + "あんぜん", + "あんてい", + "あんない", + "あんまり", + "いいだす", + "いおん", + "いがい", + "いがく", + "いきおい", + "いきなり", + "いきもの", + "いきる", + "いくじ", + "いくぶん", + "いけばな", + "いけん", + "いこう", + "いこく", + "いこつ", + "いさましい", + "いさん", + "いしき", + "いじゅう", + "いじょう", + "いじわる", + "いずみ", + "いずれ", + "いせい", + "いせえび", + "いせかい", + "いせき", + "いぜん", + "いそうろう", + "いそがしい", + "いだい", + "いだく", + "いたずら", + "いたみ", + "いたりあ", + "いちおう", + "いちじ", + "いちど", + "いちば", + "いちぶ", + "いちりゅう", + "いつか", + "いっしゅん", + "いっせい", + "いっそう", + "いったん", + "いっち", + "いってい", + "いっぽう", + "いてざ", + "いてん", + "いどう", + "いとこ", + "いない", + "いなか", + "いねむり", + "いのち", + "いのる", + "いはつ", + "いばる", + "いはん", + "いびき", + "いひん", + "いふく", + "いへん", + "いほう", + "いみん", + "いもうと", + "いもたれ", + "いもり", + "いやがる", + "いやす", + "いよかん", + "いよく", + "いらい", + "いらすと", + "いりぐち", + "いりょう", + "いれい", + "いれもの", + "いれる", + "いろえんぴつ", + "いわい", + "いわう", + "いわかん", + "いわば", + "いわゆる", + "いんげんまめ", + "いんさつ", + "いんしょう", + "いんよう", + "うえき", + "うえる", + "うおざ", + "うがい", + "うかぶ", + "うかべる", + "うきわ", + "うくらいな", + "うくれれ", + "うけたまわる", + "うけつけ", + "うけとる", + "うけもつ", + "うける", + "うごかす", + "うごく", + "うこん", + "うさぎ", + "うしなう", + "うしろがみ", + "うすい", + "うすぎ", + "うすぐらい", + "うすめる", + "うせつ", + "うちあわせ", + "うちがわ", + "うちき", + "うちゅう", + "うっかり", + "うつくしい", + "うったえる", + "うつる", + "うどん", + "うなぎ", + "うなじ", + "うなずく", + "うなる", + "うねる", + "うのう", + "うぶげ", + "うぶごえ", + "うまれる", + "うめる", + "うもう", + "うやまう", + "うよく", + "うらがえす", + "うらぐち", + "うらない", + "うりあげ", + "うりきれ", + "うるさい", + "うれしい", + "うれゆき", + "うれる", + "うろこ", + "うわき", + "うわさ", + "うんこう", + "うんちん", + "うんてん", + "うんどう", + "えいえん", + "えいが", + "えいきょう", + "えいご", + "えいせい", + "えいぶん", + "えいよう", + "えいわ", + "えおり", + "えがお", + "えがく", + "えきたい", + "えくせる", + "えしゃく", + "えすて", + "えつらん", + "えのぐ", + "えほうまき", + "えほん", + "えまき", + "えもじ", + "えもの", + "えらい", + "えらぶ", + "えりあ", + "えんえん", + "えんかい", + "えんぎ", + "えんげき", + "えんしゅう", + "えんぜつ", + "えんそく", + "えんちょう", + "えんとつ", + "おいかける", + "おいこす", + "おいしい", + "おいつく", + "おうえん", + "おうさま", + "おうじ", + "おうせつ", + "おうたい", + "おうふく", + "おうべい", + "おうよう", + "おえる", + "おおい", + "おおう", + "おおどおり", + "おおや", + "おおよそ", + "おかえり", + "おかず", + "おがむ", + "おかわり", + "おぎなう", + "おきる", + "おくさま", + "おくじょう", + "おくりがな", + "おくる", + "おくれる", + "おこす", + "おこなう", + "おこる", + "おさえる", + "おさない", + "おさめる", + "おしいれ", + "おしえる", + "おじぎ", + "おじさん", + "おしゃれ", + "おそらく", + "おそわる", + "おたがい", + "おたく", + "おだやか", + "おちつく", + "おっと", + "おつり", + "おでかけ", + "おとしもの", + "おとなしい", + "おどり", + "おどろかす", + "おばさん", + "おまいり", + "おめでとう", + "おもいで", + "おもう", + "おもたい", + "おもちゃ", + "おやつ", + "おやゆび", + "およぼす", + "おらんだ", + "おろす", + "おんがく", + "おんけい", + "おんしゃ", + "おんせん", + "おんだん", + "おんちゅう", + "おんどけい", + "かあつ", + "かいが", + "がいき", + "がいけん", + "がいこう", + "かいさつ", + "かいしゃ", + "かいすいよく", + "かいぜん", + "かいぞうど", + "かいつう", + "かいてん", + "かいとう", + "かいふく", + "がいへき", + "かいほう", + "かいよう", + "がいらい", + "かいわ", + "かえる", + "かおり", + "かかえる", + "かがく", + "かがし", + "かがみ", + "かくご", + "かくとく", + "かざる", + "がぞう", + "かたい", + "かたち", + "がちょう", + "がっきゅう", + "がっこう", + "がっさん", + "がっしょう", + "かなざわし", + "かのう", + "がはく", + "かぶか", + "かほう", + "かほご", + "かまう", + "かまぼこ", + "かめれおん", + "かゆい", + "かようび", + "からい", + "かるい", + "かろう", + "かわく", + "かわら", + "がんか", + "かんけい", + "かんこう", + "かんしゃ", + "かんそう", + "かんたん", + "かんち", + "がんばる", + "きあい", + "きあつ", + "きいろ", + "ぎいん", + "きうい", + "きうん", + "きえる", + "きおう", + "きおく", + "きおち", + "きおん", + "きかい", + "きかく", + "きかんしゃ", + "ききて", + "きくばり", + "きくらげ", + "きけんせい", + "きこう", + "きこえる", + "きこく", + "きさい", + "きさく", + "きさま", + "きさらぎ", + "ぎじかがく", + "ぎしき", + "ぎじたいけん", + "ぎじにってい", + "ぎじゅつしゃ", + "きすう", + "きせい", + "きせき", + "きせつ", + "きそう", + "きぞく", + "きぞん", + "きたえる", + "きちょう", + "きつえん", + "ぎっちり", + "きつつき", + "きつね", + "きてい", + "きどう", + "きどく", + "きない", + "きなが", + "きなこ", + "きぬごし", + "きねん", + "きのう", + "きのした", + "きはく", + "きびしい", + "きひん", + "きふく", + "きぶん", + "きぼう", + "きほん", + "きまる", + "きみつ", + "きむずかしい", + "きめる", + "きもだめし", + "きもち", + "きもの", + "きゃく", + "きやく", + "ぎゅうにく", + "きよう", + "きょうりゅう", + "きらい", + "きらく", + "きりん", + "きれい", + "きれつ", + "きろく", + "ぎろん", + "きわめる", + "ぎんいろ", + "きんかくじ", + "きんじょ", + "きんようび", + "ぐあい", + "くいず", + "くうかん", + "くうき", + "くうぐん", + "くうこう", + "ぐうせい", + "くうそう", + "ぐうたら", + "くうふく", + "くうぼ", + "くかん", + "くきょう", + "くげん", + "ぐこう", + "くさい", + "くさき", + "くさばな", + "くさる", + "くしゃみ", + "くしょう", + "くすのき", + "くすりゆび", + "くせげ", + "くせん", + "ぐたいてき", + "くださる", + "くたびれる", + "くちこみ", + "くちさき", + "くつした", + "ぐっすり", + "くつろぐ", + "くとうてん", + "くどく", + "くなん", + "くねくね", + "くのう", + "くふう", + "くみあわせ", + "くみたてる", + "くめる", + "くやくしょ", + "くらす", + "くらべる", + "くるま", + "くれる", + "くろう", + "くわしい", + "ぐんかん", + "ぐんしょく", + "ぐんたい", + "ぐんて", + "けあな", + "けいかく", + "けいけん", + "けいこ", + "けいさつ", + "げいじゅつ", + "けいたい", + "げいのうじん", + "けいれき", + "けいろ", + "けおとす", + "けおりもの", + "げきか", + "げきげん", + "げきだん", + "げきちん", + "げきとつ", + "げきは", + "げきやく", + "げこう", + "げこくじょう", + "げざい", + "けさき", + "げざん", + "けしき", + "けしごむ", + "けしょう", + "げすと", + "けたば", + "けちゃっぷ", + "けちらす", + "けつあつ", + "けつい", + "けつえき", + "けっこん", + "けつじょ", + "けっせき", + "けってい", + "けつまつ", + "げつようび", + "げつれい", + "けつろん", + "げどく", + "けとばす", + "けとる", + "けなげ", + "けなす", + "けなみ", + "けぬき", + "げねつ", + "けねん", + "けはい", + "げひん", + "けぶかい", + "げぼく", + "けまり", + "けみかる", + "けむし", + "けむり", + "けもの", + "けらい", + "けろけろ", + "けわしい", + "けんい", + "けんえつ", + "けんお", + "けんか", + "げんき", + "けんげん", + "けんこう", + "けんさく", + "けんしゅう", + "けんすう", + "げんそう", + "けんちく", + "けんてい", + "けんとう", + "けんない", + "けんにん", + "げんぶつ", + "けんま", + "けんみん", + "けんめい", + "けんらん", + "けんり", + "こあくま", + "こいぬ", + "こいびと", + "ごうい", + "こうえん", + "こうおん", + "こうかん", + "ごうきゅう", + "ごうけい", + "こうこう", + "こうさい", + "こうじ", + "こうすい", + "ごうせい", + "こうそく", + "こうたい", + "こうちゃ", + "こうつう", + "こうてい", + "こうどう", + "こうない", + "こうはい", + "ごうほう", + "ごうまん", + "こうもく", + "こうりつ", + "こえる", + "こおり", + "ごかい", + "ごがつ", + "ごかん", + "こくご", + "こくさい", + "こくとう", + "こくない", + "こくはく", + "こぐま", + "こけい", + "こける", + "ここのか", + "こころ", + "こさめ", + "こしつ", + "こすう", + "こせい", + "こせき", + "こぜん", + "こそだて", + "こたい", + "こたえる", + "こたつ", + "こちょう", + "こっか", + "こつこつ", + "こつばん", + "こつぶ", + "こてい", + "こてん", + "ことがら", + "ことし", + "ことば", + "ことり", + "こなごな", + "こねこね", + "このまま", + "このみ", + "このよ", + "ごはん", + "こひつじ", + "こふう", + "こふん", + "こぼれる", + "ごまあぶら", + "こまかい", + "ごますり", + "こまつな", + "こまる", + "こむぎこ", + "こもじ", + "こもち", + "こもの", + "こもん", + "こやく", + "こやま", + "こゆう", + "こゆび", + "こよい", + "こよう", + "こりる", + "これくしょん", + "ころっけ", + "こわもて", + "こわれる", + "こんいん", + "こんかい", + "こんき", + "こんしゅう", + "こんすい", + "こんだて", + "こんとん", + "こんなん", + "こんびに", + "こんぽん", + "こんまけ", + "こんや", + "こんれい", + "こんわく", + "ざいえき", + "さいかい", + "さいきん", + "ざいげん", + "ざいこ", + "さいしょ", + "さいせい", + "ざいたく", + "ざいちゅう", + "さいてき", + "ざいりょう", + "さうな", + "さかいし", + "さがす", + "さかな", + "さかみち", + "さがる", + "さぎょう", + "さくし", + "さくひん", + "さくら", + "さこく", + "さこつ", + "さずかる", + "ざせき", + "さたん", + "さつえい", + "ざつおん", + "ざっか", + "ざつがく", + "さっきょく", + "ざっし", + "さつじん", + "ざっそう", + "さつたば", + "さつまいも", + "さてい", + "さといも", + "さとう", + "さとおや", + "さとし", + "さとる", + "さのう", + "さばく", + "さびしい", + "さべつ", + "さほう", + "さほど", + "さます", + "さみしい", + "さみだれ", + "さむけ", + "さめる", + "さやえんどう", + "さゆう", + "さよう", + "さよく", + "さらだ", + "ざるそば", + "さわやか", + "さわる", + "さんいん", + "さんか", + "さんきゃく", + "さんこう", + "さんさい", + "ざんしょ", + "さんすう", + "さんせい", + "さんそ", + "さんち", + "さんま", + "さんみ", + "さんらん", + "しあい", + "しあげ", + "しあさって", + "しあわせ", + "しいく", + "しいん", + "しうち", + "しえい", + "しおけ", + "しかい", + "しかく", + "じかん", + "しごと", + "しすう", + "じだい", + "したうけ", + "したぎ", + "したて", + "したみ", + "しちょう", + "しちりん", + "しっかり", + "しつじ", + "しつもん", + "してい", + "してき", + "してつ", + "じてん", + "じどう", + "しなぎれ", + "しなもの", + "しなん", + "しねま", + "しねん", + "しのぐ", + "しのぶ", + "しはい", + "しばかり", + "しはつ", + "しはらい", + "しはん", + "しひょう", + "しふく", + "じぶん", + "しへい", + "しほう", + "しほん", + "しまう", + "しまる", + "しみん", + "しむける", + "じむしょ", + "しめい", + "しめる", + "しもん", + "しゃいん", + "しゃうん", + "しゃおん", + "じゃがいも", + "しやくしょ", + "しゃくほう", + "しゃけん", + "しゃこ", + "しゃざい", + "しゃしん", + "しゃせん", + "しゃそう", + "しゃたい", + "しゃちょう", + "しゃっきん", + "じゃま", + "しゃりん", + "しゃれい", + "じゆう", + "じゅうしょ", + "しゅくはく", + "じゅしん", + "しゅっせき", + "しゅみ", + "しゅらば", + "じゅんばん", + "しょうかい", + "しょくたく", + "しょっけん", + "しょどう", + "しょもつ", + "しらせる", + "しらべる", + "しんか", + "しんこう", + "じんじゃ", + "しんせいじ", + "しんちく", + "しんりん", + "すあげ", + "すあし", + "すあな", + "ずあん", + "すいえい", + "すいか", + "すいとう", + "ずいぶん", + "すいようび", + "すうがく", + "すうじつ", + "すうせん", + "すおどり", + "すきま", + "すくう", + "すくない", + "すける", + "すごい", + "すこし", + "ずさん", + "すずしい", + "すすむ", + "すすめる", + "すっかり", + "ずっしり", + "ずっと", + "すてき", + "すてる", + "すねる", + "すのこ", + "すはだ", + "すばらしい", + "ずひょう", + "ずぶぬれ", + "すぶり", + "すふれ", + "すべて", + "すべる", + "ずほう", + "すぼん", + "すまい", + "すめし", + "すもう", + "すやき", + "すらすら", + "するめ", + "すれちがう", + "すろっと", + "すわる", + "すんぜん", + "すんぽう", + "せあぶら", + "せいかつ", + "せいげん", + "せいじ", + "せいよう", + "せおう", + "せかいかん", + "せきにん", + "せきむ", + "せきゆ", + "せきらんうん", + "せけん", + "せこう", + "せすじ", + "せたい", + "せたけ", + "せっかく", + "せっきゃく", + "ぜっく", + "せっけん", + "せっこつ", + "せっさたくま", + "せつぞく", + "せつだん", + "せつでん", + "せっぱん", + "せつび", + "せつぶん", + "せつめい", + "せつりつ", + "せなか", + "せのび", + "せはば", + "せびろ", + "せぼね", + "せまい", + "せまる", + "せめる", + "せもたれ", + "せりふ", + "ぜんあく", + "せんい", + "せんえい", + "せんか", + "せんきょ", + "せんく", + "せんげん", + "ぜんご", + "せんさい", + "せんしゅ", + "せんすい", + "せんせい", + "せんぞ", + "せんたく", + "せんちょう", + "せんてい", + "せんとう", + "せんぬき", + "せんねん", + "せんぱい", + "ぜんぶ", + "ぜんぽう", + "せんむ", + "せんめんじょ", + "せんもん", + "せんやく", + "せんゆう", + "せんよう", + "ぜんら", + "ぜんりゃく", + "せんれい", + "せんろ", + "そあく", + "そいとげる", + "そいね", + "そうがんきょう", + "そうき", + "そうご", + "そうしん", + "そうだん", + "そうなん", + "そうび", + "そうめん", + "そうり", + "そえもの", + "そえん", + "そがい", + "そげき", + "そこう", + "そこそこ", + "そざい", + "そしな", + "そせい", + "そせん", + "そそぐ", + "そだてる", + "そつう", + "そつえん", + "そっかん", + "そつぎょう", + "そっけつ", + "そっこう", + "そっせん", + "そっと", + "そとがわ", + "そとづら", + "そなえる", + "そなた", + "そふぼ", + "そぼく", + "そぼろ", + "そまつ", + "そまる", + "そむく", + "そむりえ", + "そめる", + "そもそも", + "そよかぜ", + "そらまめ", + "そろう", + "そんかい", + "そんけい", + "そんざい", + "そんしつ", + "そんぞく", + "そんちょう", + "ぞんび", + "ぞんぶん", + "そんみん", + "たあい", + "たいいん", + "たいうん", + "たいえき", + "たいおう", + "だいがく", + "たいき", + "たいぐう", + "たいけん", + "たいこ", + "たいざい", + "だいじょうぶ", + "だいすき", + "たいせつ", + "たいそう", + "だいたい", + "たいちょう", + "たいてい", + "だいどころ", + "たいない", + "たいねつ", + "たいのう", + "たいはん", + "だいひょう", + "たいふう", + "たいへん", + "たいほ", + "たいまつばな", + "たいみんぐ", + "たいむ", + "たいめん", + "たいやき", + "たいよう", + "たいら", + "たいりょく", + "たいる", + "たいわん", + "たうえ", + "たえる", + "たおす", + "たおる", + "たおれる", + "たかい", + "たかね", + "たきび", + "たくさん", + "たこく", + "たこやき", + "たさい", + "たしざん", + "だじゃれ", + "たすける", + "たずさわる", + "たそがれ", + "たたかう", + "たたく", + "ただしい", + "たたみ", + "たちばな", + "だっかい", + "だっきゃく", + "だっこ", + "だっしゅつ", + "だったい", + "たてる", + "たとえる", + "たなばた", + "たにん", + "たぬき", + "たのしみ", + "たはつ", + "たぶん", + "たべる", + "たぼう", + "たまご", + "たまる", + "だむる", + "ためいき", + "ためす", + "ためる", + "たもつ", + "たやすい", + "たよる", + "たらす", + "たりきほんがん", + "たりょう", + "たりる", + "たると", + "たれる", + "たれんと", + "たろっと", + "たわむれる", + "だんあつ", + "たんい", + "たんおん", + "たんか", + "たんき", + "たんけん", + "たんご", + "たんさん", + "たんじょうび", + "だんせい", + "たんそく", + "たんたい", + "だんち", + "たんてい", + "たんとう", + "だんな", + "たんにん", + "だんねつ", + "たんのう", + "たんぴん", + "だんぼう", + "たんまつ", + "たんめい", + "だんれつ", + "だんろ", + "だんわ", + "ちあい", + "ちあん", + "ちいき", + "ちいさい", + "ちえん", + "ちかい", + "ちから", + "ちきゅう", + "ちきん", + "ちけいず", + "ちけん", + "ちこく", + "ちさい", + "ちしき", + "ちしりょう", + "ちせい", + "ちそう", + "ちたい", + "ちたん", + "ちちおや", + "ちつじょ", + "ちてき", + "ちてん", + "ちぬき", + "ちぬり", + "ちのう", + "ちひょう", + "ちへいせん", + "ちほう", + "ちまた", + "ちみつ", + "ちみどろ", + "ちめいど", + "ちゃんこなべ", + "ちゅうい", + "ちゆりょく", + "ちょうし", + "ちょさくけん", + "ちらし", + "ちらみ", + "ちりがみ", + "ちりょう", + "ちるど", + "ちわわ", + "ちんたい", + "ちんもく", + "ついか", + "ついたち", + "つうか", + "つうじょう", + "つうはん", + "つうわ", + "つかう", + "つかれる", + "つくね", + "つくる", + "つけね", + "つける", + "つごう", + "つたえる", + "つづく", + "つつじ", + "つつむ", + "つとめる", + "つながる", + "つなみ", + "つねづね", + "つのる", + "つぶす", + "つまらない", + "つまる", + "つみき", + "つめたい", + "つもり", + "つもる", + "つよい", + "つるぼ", + "つるみく", + "つわもの", + "つわり", + "てあし", + "てあて", + "てあみ", + "ていおん", + "ていか", + "ていき", + "ていけい", + "ていこく", + "ていさつ", + "ていし", + "ていせい", + "ていたい", + "ていど", + "ていねい", + "ていひょう", + "ていへん", + "ていぼう", + "てうち", + "ておくれ", + "てきとう", + "てくび", + "でこぼこ", + "てさぎょう", + "てさげ", + "てすり", + "てそう", + "てちがい", + "てちょう", + "てつがく", + "てつづき", + "でっぱ", + "てつぼう", + "てつや", + "でぬかえ", + "てぬき", + "てぬぐい", + "てのひら", + "てはい", + "てぶくろ", + "てふだ", + "てほどき", + "てほん", + "てまえ", + "てまきずし", + "てみじか", + "てみやげ", + "てらす", + "てれび", + "てわけ", + "てわたし", + "でんあつ", + "てんいん", + "てんかい", + "てんき", + "てんぐ", + "てんけん", + "てんごく", + "てんさい", + "てんし", + "てんすう", + "でんち", + "てんてき", + "てんとう", + "てんない", + "てんぷら", + "てんぼうだい", + "てんめつ", + "てんらんかい", + "でんりょく", + "でんわ", + "どあい", + "といれ", + "どうかん", + "とうきゅう", + "どうぐ", + "とうし", + "とうむぎ", + "とおい", + "とおか", + "とおく", + "とおす", + "とおる", + "とかい", + "とかす", + "ときおり", + "ときどき", + "とくい", + "とくしゅう", + "とくてん", + "とくに", + "とくべつ", + "とけい", + "とける", + "とこや", + "とさか", + "としょかん", + "とそう", + "とたん", + "とちゅう", + "とっきゅう", + "とっくん", + "とつぜん", + "とつにゅう", + "とどける", + "ととのえる", + "とない", + "となえる", + "となり", + "とのさま", + "とばす", + "どぶがわ", + "とほう", + "とまる", + "とめる", + "ともだち", + "ともる", + "どようび", + "とらえる", + "とんかつ", + "どんぶり", + "ないかく", + "ないこう", + "ないしょ", + "ないす", + "ないせん", + "ないそう", + "なおす", + "ながい", + "なくす", + "なげる", + "なこうど", + "なさけ", + "なたでここ", + "なっとう", + "なつやすみ", + "ななおし", + "なにごと", + "なにもの", + "なにわ", + "なのか", + "なふだ", + "なまいき", + "なまえ", + "なまみ", + "なみだ", + "なめらか", + "なめる", + "なやむ", + "ならう", + "ならび", + "ならぶ", + "なれる", + "なわとび", + "なわばり", + "にあう", + "にいがた", + "にうけ", + "におい", + "にかい", + "にがて", + "にきび", + "にくしみ", + "にくまん", + "にげる", + "にさんかたんそ", + "にしき", + "にせもの", + "にちじょう", + "にちようび", + "にっか", + "にっき", + "にっけい", + "にっこう", + "にっさん", + "にっしょく", + "にっすう", + "にっせき", + "にってい", + "になう", + "にほん", + "にまめ", + "にもつ", + "にやり", + "にゅういん", + "にりんしゃ", + "にわとり", + "にんい", + "にんか", + "にんき", + "にんげん", + "にんしき", + "にんずう", + "にんそう", + "にんたい", + "にんち", + "にんてい", + "にんにく", + "にんぷ", + "にんまり", + "にんむ", + "にんめい", + "にんよう", + "ぬいくぎ", + "ぬかす", + "ぬぐいとる", + "ぬぐう", + "ぬくもり", + "ぬすむ", + "ぬまえび", + "ぬめり", + "ぬらす", + "ぬんちゃく", + "ねあげ", + "ねいき", + "ねいる", + "ねいろ", + "ねぐせ", + "ねくたい", + "ねくら", + "ねこぜ", + "ねこむ", + "ねさげ", + "ねすごす", + "ねそべる", + "ねだん", + "ねつい", + "ねっしん", + "ねつぞう", + "ねったいぎょ", + "ねぶそく", + "ねふだ", + "ねぼう", + "ねほりはほり", + "ねまき", + "ねまわし", + "ねみみ", + "ねむい", + "ねむたい", + "ねもと", + "ねらう", + "ねわざ", + "ねんいり", + "ねんおし", + "ねんかん", + "ねんきん", + "ねんぐ", + "ねんざ", + "ねんし", + "ねんちゃく", + "ねんど", + "ねんぴ", + "ねんぶつ", + "ねんまつ", + "ねんりょう", + "ねんれい", + "のいず", + "のおづま", + "のがす", + "のきなみ", + "のこぎり", + "のこす", + "のこる", + "のせる", + "のぞく", + "のぞむ", + "のたまう", + "のちほど", + "のっく", + "のばす", + "のはら", + "のべる", + "のぼる", + "のみもの", + "のやま", + "のらいぬ", + "のらねこ", + "のりもの", + "のりゆき", + "のれん", + "のんき", + "ばあい", + "はあく", + "ばあさん", + "ばいか", + "ばいく", + "はいけん", + "はいご", + "はいしん", + "はいすい", + "はいせん", + "はいそう", + "はいち", + "ばいばい", + "はいれつ", + "はえる", + "はおる", + "はかい", + "ばかり", + "はかる", + "はくしゅ", + "はけん", + "はこぶ", + "はさみ", + "はさん", + "はしご", + "ばしょ", + "はしる", + "はせる", + "ぱそこん", + "はそん", + "はたん", + "はちみつ", + "はつおん", + "はっかく", + "はづき", + "はっきり", + "はっくつ", + "はっけん", + "はっこう", + "はっさん", + "はっしん", + "はったつ", + "はっちゅう", + "はってん", + "はっぴょう", + "はっぽう", + "はなす", + "はなび", + "はにかむ", + "はぶらし", + "はみがき", + "はむかう", + "はめつ", + "はやい", + "はやし", + "はらう", + "はろうぃん", + "はわい", + "はんい", + "はんえい", + "はんおん", + "はんかく", + "はんきょう", + "ばんぐみ", + "はんこ", + "はんしゃ", + "はんすう", + "はんだん", + "ぱんち", + "ぱんつ", + "はんてい", + "はんとし", + "はんのう", + "はんぱ", + "はんぶん", + "はんぺん", + "はんぼうき", + "はんめい", + "はんらん", + "はんろん", + "ひいき", + "ひうん", + "ひえる", + "ひかく", + "ひかり", + "ひかる", + "ひかん", + "ひくい", + "ひけつ", + "ひこうき", + "ひこく", + "ひさい", + "ひさしぶり", + "ひさん", + "びじゅつかん", + "ひしょ", + "ひそか", + "ひそむ", + "ひたむき", + "ひだり", + "ひたる", + "ひつぎ", + "ひっこし", + "ひっし", + "ひつじゅひん", + "ひっす", + "ひつぜん", + "ぴったり", + "ぴっちり", + "ひつよう", + "ひてい", + "ひとごみ", + "ひなまつり", + "ひなん", + "ひねる", + "ひはん", + "ひびく", + "ひひょう", + "ひほう", + "ひまわり", + "ひまん", + "ひみつ", + "ひめい", + "ひめじし", + "ひやけ", + "ひやす", + "ひよう", + "びょうき", + "ひらがな", + "ひらく", + "ひりつ", + "ひりょう", + "ひるま", + "ひるやすみ", + "ひれい", + "ひろい", + "ひろう", + "ひろき", + "ひろゆき", + "ひんかく", + "ひんけつ", + "ひんこん", + "ひんしゅ", + "ひんそう", + "ぴんち", + "ひんぱん", + "びんぼう", + "ふあん", + "ふいうち", + "ふうけい", + "ふうせん", + "ぷうたろう", + "ふうとう", + "ふうふ", + "ふえる", + "ふおん", + "ふかい", + "ふきん", + "ふくざつ", + "ふくぶくろ", + "ふこう", + "ふさい", + "ふしぎ", + "ふじみ", + "ふすま", + "ふせい", + "ふせぐ", + "ふそく", + "ぶたにく", + "ふたん", + "ふちょう", + "ふつう", + "ふつか", + "ふっかつ", + "ふっき", + "ふっこく", + "ぶどう", + "ふとる", + "ふとん", + "ふのう", + "ふはい", + "ふひょう", + "ふへん", + "ふまん", + "ふみん", + "ふめつ", + "ふめん", + "ふよう", + "ふりこ", + "ふりる", + "ふるい", + "ふんいき", + "ぶんがく", + "ぶんぐ", + "ふんしつ", + "ぶんせき", + "ふんそう", + "ぶんぽう", + "へいあん", + "へいおん", + "へいがい", + "へいき", + "へいげん", + "へいこう", + "へいさ", + "へいしゃ", + "へいせつ", + "へいそ", + "へいたく", + "へいてん", + "へいねつ", + "へいわ", + "へきが", + "へこむ", + "べにいろ", + "べにしょうが", + "へらす", + "へんかん", + "べんきょう", + "べんごし", + "へんさい", + "へんたい", + "べんり", + "ほあん", + "ほいく", + "ぼうぎょ", + "ほうこく", + "ほうそう", + "ほうほう", + "ほうもん", + "ほうりつ", + "ほえる", + "ほおん", + "ほかん", + "ほきょう", + "ぼきん", + "ほくろ", + "ほけつ", + "ほけん", + "ほこう", + "ほこる", + "ほしい", + "ほしつ", + "ほしゅ", + "ほしょう", + "ほせい", + "ほそい", + "ほそく", + "ほたて", + "ほたる", + "ぽちぶくろ", + "ほっきょく", + "ほっさ", + "ほったん", + "ほとんど", + "ほめる", + "ほんい", + "ほんき", + "ほんけ", + "ほんしつ", + "ほんやく", + "まいにち", + "まかい", + "まかせる", + "まがる", + "まける", + "まこと", + "まさつ", + "まじめ", + "ますく", + "まぜる", + "まつり", + "まとめ", + "まなぶ", + "まぬけ", + "まねく", + "まほう", + "まもる", + "まゆげ", + "まよう", + "まろやか", + "まわす", + "まわり", + "まわる", + "まんが", + "まんきつ", + "まんぞく", + "まんなか", + "みいら", + "みうち", + "みえる", + "みがく", + "みかた", + "みかん", + "みけん", + "みこん", + "みじかい", + "みすい", + "みすえる", + "みせる", + "みっか", + "みつかる", + "みつける", + "みてい", + "みとめる", + "みなと", + "みなみかさい", + "みねらる", + "みのう", + "みのがす", + "みほん", + "みもと", + "みやげ", + "みらい", + "みりょく", + "みわく", + "みんか", + "みんぞく", + "むいか", + "むえき", + "むえん", + "むかい", + "むかう", + "むかえ", + "むかし", + "むぎちゃ", + "むける", + "むげん", + "むさぼる", + "むしあつい", + "むしば", + "むじゅん", + "むしろ", + "むすう", + "むすこ", + "むすぶ", + "むすめ", + "むせる", + "むせん", + "むちゅう", + "むなしい", + "むのう", + "むやみ", + "むよう", + "むらさき", + "むりょう", + "むろん", + "めいあん", + "めいうん", + "めいえん", + "めいかく", + "めいきょく", + "めいさい", + "めいし", + "めいそう", + "めいぶつ", + "めいれい", + "めいわく", + "めぐまれる", + "めざす", + "めした", + "めずらしい", + "めだつ", + "めまい", + "めやす", + "めんきょ", + "めんせき", + "めんどう", + "もうしあげる", + "もうどうけん", + "もえる", + "もくし", + "もくてき", + "もくようび", + "もちろん", + "もどる", + "もらう", + "もんく", + "もんだい", + "やおや", + "やける", + "やさい", + "やさしい", + "やすい", + "やすたろう", + "やすみ", + "やせる", + "やそう", + "やたい", + "やちん", + "やっと", + "やっぱり", + "やぶる", + "やめる", + "ややこしい", + "やよい", + "やわらかい", + "ゆうき", + "ゆうびんきょく", + "ゆうべ", + "ゆうめい", + "ゆけつ", + "ゆしゅつ", + "ゆせん", + "ゆそう", + "ゆたか", + "ゆちゃく", + "ゆでる", + "ゆにゅう", + "ゆびわ", + "ゆらい", + "ゆれる", + "ようい", + "ようか", + "ようきゅう", + "ようじ", + "ようす", + "ようちえん", + "よかぜ", + "よかん", + "よきん", + "よくせい", + "よくぼう", + "よけい", + "よごれる", + "よさん", + "よしゅう", + "よそう", + "よそく", + "よっか", + "よてい", + "よどがわく", + "よねつ", + "よやく", + "よゆう", + "よろこぶ", + "よろしい", + "らいう", + "らくがき", + "らくご", + "らくさつ", + "らくだ", + "らしんばん", + "らせん", + "らぞく", + "らたい", + "らっか", + "られつ", + "りえき", + "りかい", + "りきさく", + "りきせつ", + "りくぐん", + "りくつ", + "りけん", + "りこう", + "りせい", + "りそう", + "りそく", + "りてん", + "りねん", + "りゆう", + "りゅうがく", + "りよう", + "りょうり", + "りょかん", + "りょくちゃ", + "りょこう", + "りりく", + "りれき", + "りろん", + "りんご", + "るいけい", + "るいさい", + "るいじ", + "るいせき", + "るすばん", + "るりがわら", + "れいかん", + "れいぎ", + "れいせい", + "れいぞうこ", + "れいとう", + "れいぼう", + "れきし", + "れきだい", + "れんあい", + "れんけい", + "れんこん", + "れんさい", + "れんしゅう", + "れんぞく", + "れんらく", + "ろうか", + "ろうご", + "ろうじん", + "ろうそく", + "ろくが", + "ろこつ", + "ろじうら", + "ろしゅつ", + "ろせん", + "ろてん", + "ろめん", + "ろれつ", + "ろんぎ", + "ろんぱ", + "ろんぶん", + "ろんり", + "わかす", + "わかめ", + "わかやま", + "わかれる", + "わしつ", + "わじまし", + "わすれもの", + "わらう", + "われる" + } + }; + + const dictionary it = + { + { + "abaco", + "abbaglio", + "abbinato", + "abete", + "abisso", + "abolire", + "abrasivo", + "abrogato", + "accadere", + "accenno", + "accusato", + "acetone", + "achille", + "acido", + "acqua", + "acre", + "acrilico", + "acrobata", + "acuto", + "adagio", + "addebito", + "addome", + "adeguato", + "aderire", + "adipe", + "adottare", + "adulare", + "affabile", + "affetto", + "affisso", + "affranto", + "aforisma", + "afoso", + "africano", + "agave", + "agente", + "agevole", + "aggancio", + "agire", + "agitare", + "agonismo", + "agricolo", + "agrumeto", + "aguzzo", + "alabarda", + "alato", + "albatro", + "alberato", + "albo", + "albume", + "alce", + "alcolico", + "alettone", + "alfa", + "algebra", + "aliante", + "alibi", + "alimento", + "allagato", + "allegro", + "allievo", + "allodola", + "allusivo", + "almeno", + "alogeno", + "alpaca", + "alpestre", + "altalena", + "alterno", + "alticcio", + "altrove", + "alunno", + "alveolo", + "alzare", + "amalgama", + "amanita", + "amarena", + "ambito", + "ambrato", + "ameba", + "america", + "ametista", + "amico", + "ammasso", + "ammenda", + "ammirare", + "ammonito", + "amore", + "ampio", + "ampliare", + "amuleto", + "anacardo", + "anagrafe", + "analista", + "anarchia", + "anatra", + "anca", + "ancella", + "ancora", + "andare", + "andrea", + "anello", + "angelo", + "angolare", + "angusto", + "anima", + "annegare", + "annidato", + "anno", + "annuncio", + "anonimo", + "anticipo", + "anzi", + "apatico", + "apertura", + "apode", + "apparire", + "appetito", + "appoggio", + "approdo", + "appunto", + "aprile", + "arabica", + "arachide", + "aragosta", + "araldica", + "arancio", + "aratura", + "arazzo", + "arbitro", + "archivio", + "ardito", + "arenile", + "argento", + "argine", + "arguto", + "aria", + "armonia", + "arnese", + "arredato", + "arringa", + "arrosto", + "arsenico", + "arso", + "artefice", + "arzillo", + "asciutto", + "ascolto", + "asepsi", + "asettico", + "asfalto", + "asino", + "asola", + "aspirato", + "aspro", + "assaggio", + "asse", + "assoluto", + "assurdo", + "asta", + "astenuto", + "astice", + "astratto", + "atavico", + "ateismo", + "atomico", + "atono", + "attesa", + "attivare", + "attorno", + "attrito", + "attuale", + "ausilio", + "austria", + "autista", + "autonomo", + "autunno", + "avanzato", + "avere", + "avvenire", + "avviso", + "avvolgere", + "azione", + "azoto", + "azzimo", + "azzurro", + "babele", + "baccano", + "bacino", + "baco", + "badessa", + "badilata", + "bagnato", + "baita", + "balcone", + "baldo", + "balena", + "ballata", + "balzano", + "bambino", + "bandire", + "baraonda", + "barbaro", + "barca", + "baritono", + "barlume", + "barocco", + "basilico", + "basso", + "batosta", + "battuto", + "baule", + "bava", + "bavosa", + "becco", + "beffa", + "belgio", + "belva", + "benda", + "benevole", + "benigno", + "benzina", + "bere", + "berlina", + "beta", + "bibita", + "bici", + "bidone", + "bifido", + "biga", + "bilancia", + "bimbo", + "binocolo", + "biologo", + "bipede", + "bipolare", + "birbante", + "birra", + "biscotto", + "bisesto", + "bisnonno", + "bisonte", + "bisturi", + "bizzarro", + "blando", + "blatta", + "bollito", + "bonifico", + "bordo", + "bosco", + "botanico", + "bottino", + "bozzolo", + "braccio", + "bradipo", + "brama", + "branca", + "bravura", + "bretella", + "brevetto", + "brezza", + "briglia", + "brillante", + "brindare", + "broccolo", + "brodo", + "bronzina", + "brullo", + "bruno", + "bubbone", + "buca", + "budino", + "buffone", + "buio", + "bulbo", + "buono", + "burlone", + "burrasca", + "bussola", + "busta", + "cadetto", + "caduco", + "calamaro", + "calcolo", + "calesse", + "calibro", + "calmo", + "caloria", + "cambusa", + "camerata", + "camicia", + "cammino", + "camola", + "campale", + "canapa", + "candela", + "cane", + "canino", + "canotto", + "cantina", + "capace", + "capello", + "capitolo", + "capogiro", + "cappero", + "capra", + "capsula", + "carapace", + "carcassa", + "cardo", + "carisma", + "carovana", + "carretto", + "cartolina", + "casaccio", + "cascata", + "caserma", + "caso", + "cassone", + "castello", + "casuale", + "catasta", + "catena", + "catrame", + "cauto", + "cavillo", + "cedibile", + "cedrata", + "cefalo", + "celebre", + "cellulare", + "cena", + "cenone", + "centesimo", + "ceramica", + "cercare", + "certo", + "cerume", + "cervello", + "cesoia", + "cespo", + "ceto", + "chela", + "chiaro", + "chicca", + "chiedere", + "chimera", + "china", + "chirurgo", + "chitarra", + "ciao", + "ciclismo", + "cifrare", + "cigno", + "cilindro", + "ciottolo", + "circa", + "cirrosi", + "citrico", + "cittadino", + "ciuffo", + "civetta", + "civile", + "classico", + "clinica", + "cloro", + "cocco", + "codardo", + "codice", + "coerente", + "cognome", + "collare", + "colmato", + "colore", + "colposo", + "coltivato", + "colza", + "coma", + "cometa", + "commando", + "comodo", + "computer", + "comune", + "conciso", + "condurre", + "conferma", + "congelare", + "coniuge", + "connesso", + "conoscere", + "consumo", + "continuo", + "convegno", + "coperto", + "copione", + "coppia", + "copricapo", + "corazza", + "cordata", + "coricato", + "cornice", + "corolla", + "corpo", + "corredo", + "corsia", + "cortese", + "cosmico", + "costante", + "cottura", + "covato", + "cratere", + "cravatta", + "creato", + "credere", + "cremoso", + "crescita", + "creta", + "criceto", + "crinale", + "crisi", + "critico", + "croce", + "cronaca", + "crostata", + "cruciale", + "crusca", + "cucire", + "cuculo", + "cugino", + "cullato", + "cupola", + "curatore", + "cursore", + "curvo", + "cuscino", + "custode", + "dado", + "daino", + "dalmata", + "damerino", + "daniela", + "dannoso", + "danzare", + "datato", + "davanti", + "davvero", + "debutto", + "decennio", + "deciso", + "declino", + "decollo", + "decreto", + "dedicato", + "definito", + "deforme", + "degno", + "delegare", + "delfino", + "delirio", + "delta", + "demenza", + "denotato", + "dentro", + "deposito", + "derapata", + "derivare", + "deroga", + "descritto", + "deserto", + "desiderio", + "desumere", + "detersivo", + "devoto", + "diametro", + "dicembre", + "diedro", + "difeso", + "diffuso", + "digerire", + "digitale", + "diluvio", + "dinamico", + "dinnanzi", + "dipinto", + "diploma", + "dipolo", + "diradare", + "dire", + "dirotto", + "dirupo", + "disagio", + "discreto", + "disfare", + "disgelo", + "disposto", + "distanza", + "disumano", + "dito", + "divano", + "divelto", + "dividere", + "divorato", + "doblone", + "docente", + "doganale", + "dogma", + "dolce", + "domato", + "domenica", + "dominare", + "dondolo", + "dono", + "dormire", + "dote", + "dottore", + "dovuto", + "dozzina", + "drago", + "druido", + "dubbio", + "dubitare", + "ducale", + "duna", + "duomo", + "duplice", + "duraturo", + "ebano", + "eccesso", + "ecco", + "eclissi", + "economia", + "edera", + "edicola", + "edile", + "editoria", + "educare", + "egemonia", + "egli", + "egoismo", + "egregio", + "elaborato", + "elargire", + "elegante", + "elencato", + "eletto", + "elevare", + "elfico", + "elica", + "elmo", + "elsa", + "eluso", + "emanato", + "emblema", + "emesso", + "emiro", + "emotivo", + "emozione", + "empirico", + "emulo", + "endemico", + "enduro", + "energia", + "enfasi", + "enoteca", + "entrare", + "enzima", + "epatite", + "epilogo", + "episodio", + "epocale", + "eppure", + "equatore", + "erario", + "erba", + "erboso", + "erede", + "eremita", + "erigere", + "ermetico", + "eroe", + "erosivo", + "errante", + "esagono", + "esame", + "esanime", + "esaudire", + "esca", + "esempio", + "esercito", + "esibito", + "esigente", + "esistere", + "esito", + "esofago", + "esortato", + "esoso", + "espanso", + "espresso", + "essenza", + "esso", + "esteso", + "estimare", + "estonia", + "estroso", + "esultare", + "etilico", + "etnico", + "etrusco", + "etto", + "euclideo", + "europa", + "evaso", + "evidenza", + "evitato", + "evoluto", + "evviva", + "fabbrica", + "faccenda", + "fachiro", + "falco", + "famiglia", + "fanale", + "fanfara", + "fango", + "fantasma", + "fare", + "farfalla", + "farinoso", + "farmaco", + "fascia", + "fastoso", + "fasullo", + "faticare", + "fato", + "favoloso", + "febbre", + "fecola", + "fede", + "fegato", + "felpa", + "feltro", + "femmina", + "fendere", + "fenomeno", + "fermento", + "ferro", + "fertile", + "fessura", + "festivo", + "fetta", + "feudo", + "fiaba", + "fiducia", + "fifa", + "figurato", + "filo", + "finanza", + "finestra", + "finire", + "fiore", + "fiscale", + "fisico", + "fiume", + "flacone", + "flamenco", + "flebo", + "flemma", + "florido", + "fluente", + "fluoro", + "fobico", + "focaccia", + "focoso", + "foderato", + "foglio", + "folata", + "folclore", + "folgore", + "fondente", + "fonetico", + "fonia", + "fontana", + "forbito", + "forchetta", + "foresta", + "formica", + "fornaio", + "foro", + "fortezza", + "forzare", + "fosfato", + "fosso", + "fracasso", + "frana", + "frassino", + "fratello", + "freccetta", + "frenata", + "fresco", + "frigo", + "frollino", + "fronde", + "frugale", + "frutta", + "fucilata", + "fucsia", + "fuggente", + "fulmine", + "fulvo", + "fumante", + "fumetto", + "fumoso", + "fune", + "funzione", + "fuoco", + "furbo", + "furgone", + "furore", + "fuso", + "futile", + "gabbiano", + "gaffe", + "galateo", + "gallina", + "galoppo", + "gambero", + "gamma", + "garanzia", + "garbo", + "garofano", + "garzone", + "gasdotto", + "gasolio", + "gastrico", + "gatto", + "gaudio", + "gazebo", + "gazzella", + "geco", + "gelatina", + "gelso", + "gemello", + "gemmato", + "gene", + "genitore", + "gennaio", + "genotipo", + "gergo", + "ghepardo", + "ghiaccio", + "ghisa", + "giallo", + "gilda", + "ginepro", + "giocare", + "gioiello", + "giorno", + "giove", + "girato", + "girone", + "gittata", + "giudizio", + "giurato", + "giusto", + "globulo", + "glutine", + "gnomo", + "gobba", + "golf", + "gomito", + "gommone", + "gonfio", + "gonna", + "governo", + "gracile", + "grado", + "grafico", + "grammo", + "grande", + "grattare", + "gravoso", + "grazia", + "greca", + "gregge", + "grifone", + "grigio", + "grinza", + "grotta", + "gruppo", + "guadagno", + "guaio", + "guanto", + "guardare", + "gufo", + "guidare", + "ibernato", + "icona", + "identico", + "idillio", + "idolo", + "idra", + "idrico", + "idrogeno", + "igiene", + "ignaro", + "ignorato", + "ilare", + "illeso", + "illogico", + "illudere", + "imballo", + "imbevuto", + "imbocco", + "imbuto", + "immane", + "immerso", + "immolato", + "impacco", + "impeto", + "impiego", + "importo", + "impronta", + "inalare", + "inarcare", + "inattivo", + "incanto", + "incendio", + "inchino", + "incisivo", + "incluso", + "incontro", + "incrocio", + "incubo", + "indagine", + "india", + "indole", + "inedito", + "infatti", + "infilare", + "inflitto", + "ingaggio", + "ingegno", + "inglese", + "ingordo", + "ingrosso", + "innesco", + "inodore", + "inoltrare", + "inondato", + "insano", + "insetto", + "insieme", + "insonnia", + "insulina", + "intasato", + "intero", + "intonaco", + "intuito", + "inumidire", + "invalido", + "invece", + "invito", + "iperbole", + "ipnotico", + "ipotesi", + "ippica", + "iride", + "irlanda", + "ironico", + "irrigato", + "irrorare", + "isolato", + "isotopo", + "isterico", + "istituto", + "istrice", + "italia", + "iterare", + "labbro", + "labirinto", + "lacca", + "lacerato", + "lacrima", + "lacuna", + "laddove", + "lago", + "lampo", + "lancetta", + "lanterna", + "lardoso", + "larga", + "laringe", + "lastra", + "latenza", + "latino", + "lattuga", + "lavagna", + "lavoro", + "legale", + "leggero", + "lembo", + "lentezza", + "lenza", + "leone", + "lepre", + "lesivo", + "lessato", + "lesto", + "letterale", + "leva", + "levigato", + "libero", + "lido", + "lievito", + "lilla", + "limatura", + "limitare", + "limpido", + "lineare", + "lingua", + "liquido", + "lira", + "lirica", + "lisca", + "lite", + "litigio", + "livrea", + "locanda", + "lode", + "logica", + "lombare", + "londra", + "longevo", + "loquace", + "lorenzo", + "loto", + "lotteria", + "luce", + "lucidato", + "lumaca", + "luminoso", + "lungo", + "lupo", + "luppolo", + "lusinga", + "lusso", + "lutto", + "macabro", + "macchina", + "macero", + "macinato", + "madama", + "magico", + "maglia", + "magnete", + "magro", + "maiolica", + "malafede", + "malgrado", + "malinteso", + "malsano", + "malto", + "malumore", + "mana", + "mancia", + "mandorla", + "mangiare", + "manifesto", + "mannaro", + "manovra", + "mansarda", + "mantide", + "manubrio", + "mappa", + "maratona", + "marcire", + "maretta", + "marmo", + "marsupio", + "maschera", + "massaia", + "mastino", + "materasso", + "matricola", + "mattone", + "maturo", + "mazurca", + "meandro", + "meccanico", + "mecenate", + "medesimo", + "meditare", + "mega", + "melassa", + "melis", + "melodia", + "meninge", + "meno", + "mensola", + "mercurio", + "merenda", + "merlo", + "meschino", + "mese", + "messere", + "mestolo", + "metallo", + "metodo", + "mettere", + "miagolare", + "mica", + "micelio", + "michele", + "microbo", + "midollo", + "miele", + "migliore", + "milano", + "milite", + "mimosa", + "minerale", + "mini", + "minore", + "mirino", + "mirtillo", + "miscela", + "missiva", + "misto", + "misurare", + "mitezza", + "mitigare", + "mitra", + "mittente", + "mnemonico", + "modello", + "modifica", + "modulo", + "mogano", + "mogio", + "mole", + "molosso", + "monastero", + "monco", + "mondina", + "monetario", + "monile", + "monotono", + "monsone", + "montato", + "monviso", + "mora", + "mordere", + "morsicato", + "mostro", + "motivato", + "motosega", + "motto", + "movenza", + "movimento", + "mozzo", + "mucca", + "mucosa", + "muffa", + "mughetto", + "mugnaio", + "mulatto", + "mulinello", + "multiplo", + "mummia", + "munto", + "muovere", + "murale", + "musa", + "muscolo", + "musica", + "mutevole", + "muto", + "nababbo", + "nafta", + "nanometro", + "narciso", + "narice", + "narrato", + "nascere", + "nastrare", + "naturale", + "nautica", + "naviglio", + "nebulosa", + "necrosi", + "negativo", + "negozio", + "nemmeno", + "neofita", + "neretto", + "nervo", + "nessuno", + "nettuno", + "neutrale", + "neve", + "nevrotico", + "nicchia", + "ninfa", + "nitido", + "nobile", + "nocivo", + "nodo", + "nome", + "nomina", + "nordico", + "normale", + "norvegese", + "nostrano", + "notare", + "notizia", + "notturno", + "novella", + "nucleo", + "nulla", + "numero", + "nuovo", + "nutrire", + "nuvola", + "nuziale", + "oasi", + "obbedire", + "obbligo", + "obelisco", + "oblio", + "obolo", + "obsoleto", + "occasione", + "occhio", + "occidente", + "occorrere", + "occultare", + "ocra", + "oculato", + "odierno", + "odorare", + "offerta", + "offrire", + "offuscato", + "oggetto", + "oggi", + "ognuno", + "olandese", + "olfatto", + "oliato", + "oliva", + "ologramma", + "oltre", + "omaggio", + "ombelico", + "ombra", + "omega", + "omissione", + "ondoso", + "onere", + "onice", + "onnivoro", + "onorevole", + "onta", + "operato", + "opinione", + "opposto", + "oracolo", + "orafo", + "ordine", + "orecchino", + "orefice", + "orfano", + "organico", + "origine", + "orizzonte", + "orma", + "ormeggio", + "ornativo", + "orologio", + "orrendo", + "orribile", + "ortensia", + "ortica", + "orzata", + "orzo", + "osare", + "oscurare", + "osmosi", + "ospedale", + "ospite", + "ossa", + "ossidare", + "ostacolo", + "oste", + "otite", + "otre", + "ottagono", + "ottimo", + "ottobre", + "ovale", + "ovest", + "ovino", + "oviparo", + "ovocito", + "ovunque", + "ovviare", + "ozio", + "pacchetto", + "pace", + "pacifico", + "padella", + "padrone", + "paese", + "paga", + "pagina", + "palazzina", + "palesare", + "pallido", + "palo", + "palude", + "pandoro", + "pannello", + "paolo", + "paonazzo", + "paprica", + "parabola", + "parcella", + "parere", + "pargolo", + "pari", + "parlato", + "parola", + "partire", + "parvenza", + "parziale", + "passivo", + "pasticca", + "patacca", + "patologia", + "pattume", + "pavone", + "peccato", + "pedalare", + "pedonale", + "peggio", + "peloso", + "penare", + "pendice", + "penisola", + "pennuto", + "penombra", + "pensare", + "pentola", + "pepe", + "pepita", + "perbene", + "percorso", + "perdonato", + "perforare", + "pergamena", + "periodo", + "permesso", + "perno", + "perplesso", + "persuaso", + "pertugio", + "pervaso", + "pesatore", + "pesista", + "peso", + "pestifero", + "petalo", + "pettine", + "petulante", + "pezzo", + "piacere", + "pianta", + "piattino", + "piccino", + "picozza", + "piega", + "pietra", + "piffero", + "pigiama", + "pigolio", + "pigro", + "pila", + "pilifero", + "pillola", + "pilota", + "pimpante", + "pineta", + "pinna", + "pinolo", + "pioggia", + "piombo", + "piramide", + "piretico", + "pirite", + "pirolisi", + "pitone", + "pizzico", + "placebo", + "planare", + "plasma", + "platano", + "plenario", + "pochezza", + "poderoso", + "podismo", + "poesia", + "poggiare", + "polenta", + "poligono", + "pollice", + "polmonite", + "polpetta", + "polso", + "poltrona", + "polvere", + "pomice", + "pomodoro", + "ponte", + "popoloso", + "porfido", + "poroso", + "porpora", + "porre", + "portata", + "posa", + "positivo", + "possesso", + "postulato", + "potassio", + "potere", + "pranzo", + "prassi", + "pratica", + "precluso", + "predica", + "prefisso", + "pregiato", + "prelievo", + "premere", + "prenotare", + "preparato", + "presenza", + "pretesto", + "prevalso", + "prima", + "principe", + "privato", + "problema", + "procura", + "produrre", + "profumo", + "progetto", + "prolunga", + "promessa", + "pronome", + "proposta", + "proroga", + "proteso", + "prova", + "prudente", + "prugna", + "prurito", + "psiche", + "pubblico", + "pudica", + "pugilato", + "pugno", + "pulce", + "pulito", + "pulsante", + "puntare", + "pupazzo", + "pupilla", + "puro", + "quadro", + "qualcosa", + "quasi", + "querela", + "quota", + "raccolto", + "raddoppio", + "radicale", + "radunato", + "raffica", + "ragazzo", + "ragione", + "ragno", + "ramarro", + "ramingo", + "ramo", + "randagio", + "rantolare", + "rapato", + "rapina", + "rappreso", + "rasatura", + "raschiato", + "rasente", + "rassegna", + "rastrello", + "rata", + "ravveduto", + "reale", + "recepire", + "recinto", + "recluta", + "recondito", + "recupero", + "reddito", + "redimere", + "regalato", + "registro", + "regola", + "regresso", + "relazione", + "remare", + "remoto", + "renna", + "replica", + "reprimere", + "reputare", + "resa", + "residente", + "responso", + "restauro", + "rete", + "retina", + "retorica", + "rettifica", + "revocato", + "riassunto", + "ribadire", + "ribelle", + "ribrezzo", + "ricarica", + "ricco", + "ricevere", + "riciclato", + "ricordo", + "ricreduto", + "ridicolo", + "ridurre", + "rifasare", + "riflesso", + "riforma", + "rifugio", + "rigare", + "rigettato", + "righello", + "rilassato", + "rilevato", + "rimanere", + "rimbalzo", + "rimedio", + "rimorchio", + "rinascita", + "rincaro", + "rinforzo", + "rinnovo", + "rinomato", + "rinsavito", + "rintocco", + "rinuncia", + "rinvenire", + "riparato", + "ripetuto", + "ripieno", + "riportare", + "ripresa", + "ripulire", + "risata", + "rischio", + "riserva", + "risibile", + "riso", + "rispetto", + "ristoro", + "risultato", + "risvolto", + "ritardo", + "ritegno", + "ritmico", + "ritrovo", + "riunione", + "riva", + "riverso", + "rivincita", + "rivolto", + "rizoma", + "roba", + "robotico", + "robusto", + "roccia", + "roco", + "rodaggio", + "rodere", + "roditore", + "rogito", + "rollio", + "romantico", + "rompere", + "ronzio", + "rosolare", + "rospo", + "rotante", + "rotondo", + "rotula", + "rovescio", + "rubizzo", + "rubrica", + "ruga", + "rullino", + "rumine", + "rumoroso", + "ruolo", + "rupe", + "russare", + "rustico", + "sabato", + "sabbiare", + "sabotato", + "sagoma", + "salasso", + "saldatura", + "salgemma", + "salivare", + "salmone", + "salone", + "saltare", + "saluto", + "salvo", + "sapere", + "sapido", + "saporito", + "saraceno", + "sarcasmo", + "sarto", + "sassoso", + "satellite", + "satira", + "satollo", + "saturno", + "savana", + "savio", + "saziato", + "sbadiglio", + "sbalzo", + "sbancato", + "sbarra", + "sbattere", + "sbavare", + "sbendare", + "sbirciare", + "sbloccato", + "sbocciato", + "sbrinare", + "sbruffone", + "sbuffare", + "scabroso", + "scadenza", + "scala", + "scambiare", + "scandalo", + "scapola", + "scarso", + "scatenare", + "scavato", + "scelto", + "scenico", + "scettro", + "scheda", + "schiena", + "sciarpa", + "scienza", + "scindere", + "scippo", + "sciroppo", + "scivolo", + "sclerare", + "scodella", + "scolpito", + "scomparto", + "sconforto", + "scoprire", + "scorta", + "scossone", + "scozzese", + "scriba", + "scrollare", + "scrutinio", + "scuderia", + "scultore", + "scuola", + "scuro", + "scusare", + "sdebitare", + "sdoganare", + "seccatura", + "secondo", + "sedano", + "seggiola", + "segnalato", + "segregato", + "seguito", + "selciato", + "selettivo", + "sella", + "selvaggio", + "semaforo", + "sembrare", + "seme", + "seminato", + "sempre", + "senso", + "sentire", + "sepolto", + "sequenza", + "serata", + "serbato", + "sereno", + "serio", + "serpente", + "serraglio", + "servire", + "sestina", + "setola", + "settimana", + "sfacelo", + "sfaldare", + "sfamato", + "sfarzoso", + "sfaticato", + "sfera", + "sfida", + "sfilato", + "sfinge", + "sfocato", + "sfoderare", + "sfogo", + "sfoltire", + "sforzato", + "sfratto", + "sfruttato", + "sfuggito", + "sfumare", + "sfuso", + "sgabello", + "sgarbato", + "sgonfiare", + "sgorbio", + "sgrassato", + "sguardo", + "sibilo", + "siccome", + "sierra", + "sigla", + "signore", + "silenzio", + "sillaba", + "simbolo", + "simpatico", + "simulato", + "sinfonia", + "singolo", + "sinistro", + "sino", + "sintesi", + "sinusoide", + "sipario", + "sisma", + "sistole", + "situato", + "slitta", + "slogatura", + "sloveno", + "smarrito", + "smemorato", + "smentito", + "smeraldo", + "smilzo", + "smontare", + "smottato", + "smussato", + "snellire", + "snervato", + "snodo", + "sobbalzo", + "sobrio", + "soccorso", + "sociale", + "sodale", + "soffitto", + "sogno", + "soldato", + "solenne", + "solido", + "sollazzo", + "solo", + "solubile", + "solvente", + "somatico", + "somma", + "sonda", + "sonetto", + "sonnifero", + "sopire", + "soppeso", + "sopra", + "sorgere", + "sorpasso", + "sorriso", + "sorso", + "sorteggio", + "sorvolato", + "sospiro", + "sosta", + "sottile", + "spada", + "spalla", + "spargere", + "spatola", + "spavento", + "spazzola", + "specie", + "spedire", + "spegnere", + "spelatura", + "speranza", + "spessore", + "spettrale", + "spezzato", + "spia", + "spigoloso", + "spillato", + "spinoso", + "spirale", + "splendido", + "sportivo", + "sposo", + "spranga", + "sprecare", + "spronato", + "spruzzo", + "spuntino", + "squillo", + "sradicare", + "srotolato", + "stabile", + "stacco", + "staffa", + "stagnare", + "stampato", + "stantio", + "starnuto", + "stasera", + "statuto", + "stelo", + "steppa", + "sterzo", + "stiletto", + "stima", + "stirpe", + "stivale", + "stizzoso", + "stonato", + "storico", + "strappo", + "stregato", + "stridulo", + "strozzare", + "strutto", + "stuccare", + "stufo", + "stupendo", + "subentro", + "succoso", + "sudore", + "suggerito", + "sugo", + "sultano", + "suonare", + "superbo", + "supporto", + "surgelato", + "surrogato", + "sussurro", + "sutura", + "svagare", + "svedese", + "sveglio", + "svelare", + "svenuto", + "svezia", + "sviluppo", + "svista", + "svizzera", + "svolta", + "svuotare", + "tabacco", + "tabulato", + "tacciare", + "taciturno", + "tale", + "talismano", + "tampone", + "tannino", + "tara", + "tardivo", + "targato", + "tariffa", + "tarpare", + "tartaruga", + "tasto", + "tattico", + "taverna", + "tavolata", + "tazza", + "teca", + "tecnico", + "telefono", + "temerario", + "tempo", + "temuto", + "tendone", + "tenero", + "tensione", + "tentacolo", + "teorema", + "terme", + "terrazzo", + "terzetto", + "tesi", + "tesserato", + "testato", + "tetro", + "tettoia", + "tifare", + "tigella", + "timbro", + "tinto", + "tipico", + "tipografo", + "tiraggio", + "tiro", + "titanio", + "titolo", + "titubante", + "tizio", + "tizzone", + "toccare", + "tollerare", + "tolto", + "tombola", + "tomo", + "tonfo", + "tonsilla", + "topazio", + "topologia", + "toppa", + "torba", + "tornare", + "torrone", + "tortora", + "toscano", + "tossire", + "tostatura", + "totano", + "trabocco", + "trachea", + "trafila", + "tragedia", + "tralcio", + "tramonto", + "transito", + "trapano", + "trarre", + "trasloco", + "trattato", + "trave", + "treccia", + "tremolio", + "trespolo", + "tributo", + "tricheco", + "trifoglio", + "trillo", + "trincea", + "trio", + "tristezza", + "triturato", + "trivella", + "tromba", + "trono", + "troppo", + "trottola", + "trovare", + "truccato", + "tubatura", + "tuffato", + "tulipano", + "tumulto", + "tunisia", + "turbare", + "turchino", + "tuta", + "tutela", + "ubicato", + "uccello", + "uccisore", + "udire", + "uditivo", + "uffa", + "ufficio", + "uguale", + "ulisse", + "ultimato", + "umano", + "umile", + "umorismo", + "uncinetto", + "ungere", + "ungherese", + "unicorno", + "unificato", + "unisono", + "unitario", + "unte", + "uovo", + "upupa", + "uragano", + "urgenza", + "urlo", + "usanza", + "usato", + "uscito", + "usignolo", + "usuraio", + "utensile", + "utilizzo", + "utopia", + "vacante", + "vaccinato", + "vagabondo", + "vagliato", + "valanga", + "valgo", + "valico", + "valletta", + "valoroso", + "valutare", + "valvola", + "vampata", + "vangare", + "vanitoso", + "vano", + "vantaggio", + "vanvera", + "vapore", + "varano", + "varcato", + "variante", + "vasca", + "vedetta", + "vedova", + "veduto", + "vegetale", + "veicolo", + "velcro", + "velina", + "velluto", + "veloce", + "venato", + "vendemmia", + "vento", + "verace", + "verbale", + "vergogna", + "verifica", + "vero", + "verruca", + "verticale", + "vescica", + "vessillo", + "vestale", + "veterano", + "vetrina", + "vetusto", + "viandante", + "vibrante", + "vicenda", + "vichingo", + "vicinanza", + "vidimare", + "vigilia", + "vigneto", + "vigore", + "vile", + "villano", + "vimini", + "vincitore", + "viola", + "vipera", + "virgola", + "virologo", + "virulento", + "viscoso", + "visione", + "vispo", + "vissuto", + "visura", + "vita", + "vitello", + "vittima", + "vivanda", + "vivido", + "viziare", + "voce", + "voga", + "volatile", + "volere", + "volpe", + "voragine", + "vulcano", + "zampogna", + "zanna", + "zappato", + "zattera", + "zavorra", + "zefiro", + "zelante", + "zelo", + "zenzero", + "zerbino", + "zibetto", + "zinco", + "zircone", + "zitto", + "zolla", + "zotico", + "zucchero", + "zufolo", + "zulu", + "zuppa" + } + }; + + const dictionary fr = + { + { + "abaisser", + "abandon", + "abdiquer", + "abeille", + "abolir", + "aborder", + "aboutir", + "aboyer", + "abrasif", + "abreuver", + "abriter", + "abroger", + "abrupt", + "absence", + "absolu", + "absurde", + "abusif", + "abyssal", + "académie", + "acajou", + "acarien", + "accabler", + "accepter", + "acclamer", + "accolade", + "accroche", + "accuser", + "acerbe", + "achat", + "acheter", + "aciduler", + "acier", + "acompte", + "acquérir", + "acronyme", + "acteur", + "actif", + "actuel", + "adepte", + "adéquat", + "adhésif", + "adjectif", + "adjuger", + "admettre", + "admirer", + "adopter", + "adorer", + "adoucir", + "adresse", + "adroit", + "adulte", + "adverbe", + "aérer", + "aéronef", + "affaire", + "affecter", + "affiche", + "affreux", + "affubler", + "agacer", + "agencer", + "agile", + "agiter", + "agrafer", + "agréable", + "agrume", + "aider", + "aiguille", + "ailier", + "aimable", + "aisance", + "ajouter", + "ajuster", + "alarmer", + "alchimie", + "alerte", + "algèbre", + "algue", + "aliéner", + "aliment", + "alléger", + "alliage", + "allouer", + "allumer", + "alourdir", + "alpaga", + "altesse", + "alvéole", + "amateur", + "ambigu", + "ambre", + "aménager", + "amertume", + "amidon", + "amiral", + "amorcer", + "amour", + "amovible", + "amphibie", + "ampleur", + "amusant", + "analyse", + "anaphore", + "anarchie", + "anatomie", + "ancien", + "anéantir", + "angle", + "angoisse", + "anguleux", + "animal", + "annexer", + "annonce", + "annuel", + "anodin", + "anomalie", + "anonyme", + "anormal", + "antenne", + "antidote", + "anxieux", + "apaiser", + "apéritif", + "aplanir", + "apologie", + "appareil", + "appeler", + "apporter", + "appuyer", + "aquarium", + "aqueduc", + "arbitre", + "arbuste", + "ardeur", + "ardoise", + "argent", + "arlequin", + "armature", + "armement", + "armoire", + "armure", + "arpenter", + "arracher", + "arriver", + "arroser", + "arsenic", + "artériel", + "article", + "aspect", + "asphalte", + "aspirer", + "assaut", + "asservir", + "assiette", + "associer", + "assurer", + "asticot", + "astre", + "astuce", + "atelier", + "atome", + "atrium", + "atroce", + "attaque", + "attentif", + "attirer", + "attraper", + "aubaine", + "auberge", + "audace", + "audible", + "augurer", + "aurore", + "automne", + "autruche", + "avaler", + "avancer", + "avarice", + "avenir", + "averse", + "aveugle", + "aviateur", + "avide", + "avion", + "aviser", + "avoine", + "avouer", + "avril", + "axial", + "axiome", + "badge", + "bafouer", + "bagage", + "baguette", + "baignade", + "balancer", + "balcon", + "baleine", + "balisage", + "bambin", + "bancaire", + "bandage", + "banlieue", + "bannière", + "banquier", + "barbier", + "baril", + "baron", + "barque", + "barrage", + "bassin", + "bastion", + "bataille", + "bateau", + "batterie", + "baudrier", + "bavarder", + "belette", + "bélier", + "belote", + "bénéfice", + "berceau", + "berger", + "berline", + "bermuda", + "besace", + "besogne", + "bétail", + "beurre", + "biberon", + "bicycle", + "bidule", + "bijou", + "bilan", + "bilingue", + "billard", + "binaire", + "biologie", + "biopsie", + "biotype", + "biscuit", + "bison", + "bistouri", + "bitume", + "bizarre", + "blafard", + "blague", + "blanchir", + "blessant", + "blinder", + "blond", + "bloquer", + "blouson", + "bobard", + "bobine", + "boire", + "boiser", + "bolide", + "bonbon", + "bondir", + "bonheur", + "bonifier", + "bonus", + "bordure", + "borne", + "botte", + "boucle", + "boueux", + "bougie", + "boulon", + "bouquin", + "bourse", + "boussole", + "boutique", + "boxeur", + "branche", + "brasier", + "brave", + "brebis", + "brèche", + "breuvage", + "bricoler", + "brigade", + "brillant", + "brioche", + "brique", + "brochure", + "broder", + "bronzer", + "brousse", + "broyeur", + "brume", + "brusque", + "brutal", + "bruyant", + "buffle", + "buisson", + "bulletin", + "bureau", + "burin", + "bustier", + "butiner", + "butoir", + "buvable", + "buvette", + "cabanon", + "cabine", + "cachette", + "cadeau", + "cadre", + "caféine", + "caillou", + "caisson", + "calculer", + "calepin", + "calibre", + "calmer", + "calomnie", + "calvaire", + "camarade", + "caméra", + "camion", + "campagne", + "canal", + "caneton", + "canon", + "cantine", + "canular", + "capable", + "caporal", + "caprice", + "capsule", + "capter", + "capuche", + "carabine", + "carbone", + "caresser", + "caribou", + "carnage", + "carotte", + "carreau", + "carton", + "cascade", + "casier", + "casque", + "cassure", + "causer", + "caution", + "cavalier", + "caverne", + "caviar", + "cédille", + "ceinture", + "céleste", + "cellule", + "cendrier", + "censurer", + "central", + "cercle", + "cérébral", + "cerise", + "cerner", + "cerveau", + "cesser", + "chagrin", + "chaise", + "chaleur", + "chambre", + "chance", + "chapitre", + "charbon", + "chasseur", + "chaton", + "chausson", + "chavirer", + "chemise", + "chenille", + "chéquier", + "chercher", + "cheval", + "chien", + "chiffre", + "chignon", + "chimère", + "chiot", + "chlorure", + "chocolat", + "choisir", + "chose", + "chouette", + "chrome", + "chute", + "cigare", + "cigogne", + "cimenter", + "cinéma", + "cintrer", + "circuler", + "cirer", + "cirque", + "citerne", + "citoyen", + "citron", + "civil", + "clairon", + "clameur", + "claquer", + "classe", + "clavier", + "client", + "cligner", + "climat", + "clivage", + "cloche", + "clonage", + "cloporte", + "cobalt", + "cobra", + "cocasse", + "cocotier", + "coder", + "codifier", + "coffre", + "cogner", + "cohésion", + "coiffer", + "coincer", + "colère", + "colibri", + "colline", + "colmater", + "colonel", + "combat", + "comédie", + "commande", + "compact", + "concert", + "conduire", + "confier", + "congeler", + "connoter", + "consonne", + "contact", + "convexe", + "copain", + "copie", + "corail", + "corbeau", + "cordage", + "corniche", + "corpus", + "correct", + "cortège", + "cosmique", + "costume", + "coton", + "coude", + "coupure", + "courage", + "couteau", + "couvrir", + "coyote", + "crabe", + "crainte", + "cravate", + "crayon", + "créature", + "créditer", + "crémeux", + "creuser", + "crevette", + "cribler", + "crier", + "cristal", + "critère", + "croire", + "croquer", + "crotale", + "crucial", + "cruel", + "crypter", + "cubique", + "cueillir", + "cuillère", + "cuisine", + "cuivre", + "culminer", + "cultiver", + "cumuler", + "cupide", + "curatif", + "curseur", + "cyanure", + "cycle", + "cylindre", + "cynique", + "daigner", + "damier", + "danger", + "danseur", + "dauphin", + "débattre", + "débiter", + "déborder", + "débrider", + "débutant", + "décaler", + "décembre", + "déchirer", + "décider", + "déclarer", + "décorer", + "décrire", + "décupler", + "dédale", + "déductif", + "déesse", + "défensif", + "défiler", + "défrayer", + "dégager", + "dégivrer", + "déglutir", + "dégrafer", + "déjeuner", + "délice", + "déloger", + "demander", + "demeurer", + "démolir", + "dénicher", + "dénouer", + "dentelle", + "dénuder", + "départ", + "dépenser", + "déphaser", + "déplacer", + "déposer", + "déranger", + "dérober", + "désastre", + "descente", + "désert", + "désigner", + "désobéir", + "dessiner", + "destrier", + "détacher", + "détester", + "détourer", + "détresse", + "devancer", + "devenir", + "deviner", + "devoir", + "diable", + "dialogue", + "diamant", + "dicter", + "différer", + "digérer", + "digital", + "digne", + "diluer", + "dimanche", + "diminuer", + "dioxyde", + "directif", + "diriger", + "discuter", + "disposer", + "dissiper", + "distance", + "divertir", + "diviser", + "docile", + "docteur", + "dogme", + "doigt", + "domaine", + "domicile", + "dompter", + "donateur", + "donjon", + "donner", + "dopamine", + "dortoir", + "dorure", + "dosage", + "doseur", + "dossier", + "dotation", + "douanier", + "double", + "douceur", + "douter", + "doyen", + "dragon", + "draper", + "dresser", + "dribbler", + "droiture", + "duperie", + "duplexe", + "durable", + "durcir", + "dynastie", + "éblouir", + "écarter", + "écharpe", + "échelle", + "éclairer", + "éclipse", + "éclore", + "écluse", + "école", + "économie", + "écorce", + "écouter", + "écraser", + "écrémer", + "écrivain", + "écrou", + "écume", + "écureuil", + "édifier", + "éduquer", + "effacer", + "effectif", + "effigie", + "effort", + "effrayer", + "effusion", + "égaliser", + "égarer", + "éjecter", + "élaborer", + "élargir", + "électron", + "élégant", + "éléphant", + "élève", + "éligible", + "élitisme", + "éloge", + "élucider", + "éluder", + "emballer", + "embellir", + "embryon", + "émeraude", + "émission", + "emmener", + "émotion", + "émouvoir", + "empereur", + "employer", + "emporter", + "emprise", + "émulsion", + "encadrer", + "enchère", + "enclave", + "encoche", + "endiguer", + "endosser", + "endroit", + "enduire", + "énergie", + "enfance", + "enfermer", + "enfouir", + "engager", + "engin", + "englober", + "énigme", + "enjamber", + "enjeu", + "enlever", + "ennemi", + "ennuyeux", + "enrichir", + "enrobage", + "enseigne", + "entasser", + "entendre", + "entier", + "entourer", + "entraver", + "énumérer", + "envahir", + "enviable", + "envoyer", + "enzyme", + "éolien", + "épaissir", + "épargne", + "épatant", + "épaule", + "épicerie", + "épidémie", + "épier", + "épilogue", + "épine", + "épisode", + "épitaphe", + "époque", + "épreuve", + "éprouver", + "épuisant", + "équerre", + "équipe", + "ériger", + "érosion", + "erreur", + "éruption", + "escalier", + "espadon", + "espèce", + "espiègle", + "espoir", + "esprit", + "esquiver", + "essayer", + "essence", + "essieu", + "essorer", + "estime", + "estomac", + "estrade", + "étagère", + "étaler", + "étanche", + "étatique", + "éteindre", + "étendoir", + "éternel", + "éthanol", + "éthique", + "ethnie", + "étirer", + "étoffer", + "étoile", + "étonnant", + "étourdir", + "étrange", + "étroit", + "étude", + "euphorie", + "évaluer", + "évasion", + "éventail", + "évidence", + "éviter", + "évolutif", + "évoquer", + "exact", + "exagérer", + "exaucer", + "exceller", + "excitant", + "exclusif", + "excuse", + "exécuter", + "exemple", + "exercer", + "exhaler", + "exhorter", + "exigence", + "exiler", + "exister", + "exotique", + "expédier", + "explorer", + "exposer", + "exprimer", + "exquis", + "extensif", + "extraire", + "exulter", + "fable", + "fabuleux", + "facette", + "facile", + "facture", + "faiblir", + "falaise", + "fameux", + "famille", + "farceur", + "farfelu", + "farine", + "farouche", + "fasciner", + "fatal", + "fatigue", + "faucon", + "fautif", + "faveur", + "favori", + "fébrile", + "féconder", + "fédérer", + "félin", + "femme", + "fémur", + "fendoir", + "féodal", + "fermer", + "féroce", + "ferveur", + "festival", + "feuille", + "feutre", + "février", + "fiasco", + "ficeler", + "fictif", + "fidèle", + "figure", + "filature", + "filetage", + "filière", + "filleul", + "filmer", + "filou", + "filtrer", + "financer", + "finir", + "fiole", + "firme", + "fissure", + "fixer", + "flairer", + "flamme", + "flasque", + "flatteur", + "fléau", + "flèche", + "fleur", + "flexion", + "flocon", + "flore", + "fluctuer", + "fluide", + "fluvial", + "folie", + "fonderie", + "fongible", + "fontaine", + "forcer", + "forgeron", + "formuler", + "fortune", + "fossile", + "foudre", + "fougère", + "fouiller", + "foulure", + "fourmi", + "fragile", + "fraise", + "franchir", + "frapper", + "frayeur", + "frégate", + "freiner", + "frelon", + "frémir", + "frénésie", + "frère", + "friable", + "friction", + "frisson", + "frivole", + "froid", + "fromage", + "frontal", + "frotter", + "fruit", + "fugitif", + "fuite", + "fureur", + "furieux", + "furtif", + "fusion", + "futur", + "gagner", + "galaxie", + "galerie", + "gambader", + "garantir", + "gardien", + "garnir", + "garrigue", + "gazelle", + "gazon", + "géant", + "gélatine", + "gélule", + "gendarme", + "général", + "génie", + "genou", + "gentil", + "géologie", + "géomètre", + "géranium", + "germe", + "gestuel", + "geyser", + "gibier", + "gicler", + "girafe", + "givre", + "glace", + "glaive", + "glisser", + "globe", + "gloire", + "glorieux", + "golfeur", + "gomme", + "gonfler", + "gorge", + "gorille", + "goudron", + "gouffre", + "goulot", + "goupille", + "gourmand", + "goutte", + "graduel", + "graffiti", + "graine", + "grand", + "grappin", + "gratuit", + "gravir", + "grenat", + "griffure", + "griller", + "grimper", + "grogner", + "gronder", + "grotte", + "groupe", + "gruger", + "grutier", + "gruyère", + "guépard", + "guerrier", + "guide", + "guimauve", + "guitare", + "gustatif", + "gymnaste", + "gyrostat", + "habitude", + "hachoir", + "halte", + "hameau", + "hangar", + "hanneton", + "haricot", + "harmonie", + "harpon", + "hasard", + "hélium", + "hématome", + "herbe", + "hérisson", + "hermine", + "héron", + "hésiter", + "heureux", + "hiberner", + "hibou", + "hilarant", + "histoire", + "hiver", + "homard", + "hommage", + "homogène", + "honneur", + "honorer", + "honteux", + "horde", + "horizon", + "horloge", + "hormone", + "horrible", + "houleux", + "housse", + "hublot", + "huileux", + "humain", + "humble", + "humide", + "humour", + "hurler", + "hydromel", + "hygiène", + "hymne", + "hypnose", + "idylle", + "ignorer", + "iguane", + "illicite", + "illusion", + "image", + "imbiber", + "imiter", + "immense", + "immobile", + "immuable", + "impact", + "impérial", + "implorer", + "imposer", + "imprimer", + "imputer", + "incarner", + "incendie", + "incident", + "incliner", + "incolore", + "indexer", + "indice", + "inductif", + "inédit", + "ineptie", + "inexact", + "infini", + "infliger", + "informer", + "infusion", + "ingérer", + "inhaler", + "inhiber", + "injecter", + "injure", + "innocent", + "inoculer", + "inonder", + "inscrire", + "insecte", + "insigne", + "insolite", + "inspirer", + "instinct", + "insulter", + "intact", + "intense", + "intime", + "intrigue", + "intuitif", + "inutile", + "invasion", + "inventer", + "inviter", + "invoquer", + "ironique", + "irradier", + "irréel", + "irriter", + "isoler", + "ivoire", + "ivresse", + "jaguar", + "jaillir", + "jambe", + "janvier", + "jardin", + "jauger", + "jaune", + "javelot", + "jetable", + "jeton", + "jeudi", + "jeunesse", + "joindre", + "joncher", + "jongler", + "joueur", + "jouissif", + "journal", + "jovial", + "joyau", + "joyeux", + "jubiler", + "jugement", + "junior", + "jupon", + "juriste", + "justice", + "juteux", + "juvénile", + "kayak", + "kimono", + "kiosque", + "label", + "labial", + "labourer", + "lacérer", + "lactose", + "lagune", + "laine", + "laisser", + "laitier", + "lambeau", + "lamelle", + "lampe", + "lanceur", + "langage", + "lanterne", + "lapin", + "largeur", + "larme", + "laurier", + "lavabo", + "lavoir", + "lecture", + "légal", + "léger", + "légume", + "lessive", + "lettre", + "levier", + "lexique", + "lézard", + "liasse", + "libérer", + "libre", + "licence", + "licorne", + "liège", + "lièvre", + "ligature", + "ligoter", + "ligue", + "limer", + "limite", + "limonade", + "limpide", + "linéaire", + "lingot", + "lionceau", + "liquide", + "lisière", + "lister", + "lithium", + "litige", + "littoral", + "livreur", + "logique", + "lointain", + "loisir", + "lombric", + "loterie", + "louer", + "lourd", + "loutre", + "louve", + "loyal", + "lubie", + "lucide", + "lucratif", + "lueur", + "lugubre", + "luisant", + "lumière", + "lunaire", + "lundi", + "luron", + "lutter", + "luxueux", + "machine", + "magasin", + "magenta", + "magique", + "maigre", + "maillon", + "maintien", + "mairie", + "maison", + "majorer", + "malaxer", + "maléfice", + "malheur", + "malice", + "mallette", + "mammouth", + "mandater", + "maniable", + "manquant", + "manteau", + "manuel", + "marathon", + "marbre", + "marchand", + "mardi", + "maritime", + "marqueur", + "marron", + "marteler", + "mascotte", + "massif", + "matériel", + "matière", + "matraque", + "maudire", + "maussade", + "mauve", + "maximal", + "méchant", + "méconnu", + "médaille", + "médecin", + "méditer", + "méduse", + "meilleur", + "mélange", + "mélodie", + "membre", + "mémoire", + "menacer", + "mener", + "menhir", + "mensonge", + "mentor", + "mercredi", + "mérite", + "merle", + "messager", + "mesure", + "métal", + "météore", + "méthode", + "métier", + "meuble", + "miauler", + "microbe", + "miette", + "mignon", + "migrer", + "milieu", + "million", + "mimique", + "mince", + "minéral", + "minimal", + "minorer", + "minute", + "miracle", + "miroiter", + "missile", + "mixte", + "mobile", + "moderne", + "moelleux", + "mondial", + "moniteur", + "monnaie", + "monotone", + "monstre", + "montagne", + "monument", + "moqueur", + "morceau", + "morsure", + "mortier", + "moteur", + "motif", + "mouche", + "moufle", + "moulin", + "mousson", + "mouton", + "mouvant", + "multiple", + "munition", + "muraille", + "murène", + "murmure", + "muscle", + "muséum", + "musicien", + "mutation", + "muter", + "mutuel", + "myriade", + "myrtille", + "mystère", + "mythique", + "nageur", + "nappe", + "narquois", + "narrer", + "natation", + "nation", + "nature", + "naufrage", + "nautique", + "navire", + "nébuleux", + "nectar", + "néfaste", + "négation", + "négliger", + "négocier", + "neige", + "nerveux", + "nettoyer", + "neurone", + "neutron", + "neveu", + "niche", + "nickel", + "nitrate", + "niveau", + "noble", + "nocif", + "nocturne", + "noirceur", + "noisette", + "nomade", + "nombreux", + "nommer", + "normatif", + "notable", + "notifier", + "notoire", + "nourrir", + "nouveau", + "novateur", + "novembre", + "novice", + "nuage", + "nuancer", + "nuire", + "nuisible", + "numéro", + "nuptial", + "nuque", + "nutritif", + "obéir", + "objectif", + "obliger", + "obscur", + "observer", + "obstacle", + "obtenir", + "obturer", + "occasion", + "occuper", + "océan", + "octobre", + "octroyer", + "octupler", + "oculaire", + "odeur", + "odorant", + "offenser", + "officier", + "offrir", + "ogive", + "oiseau", + "oisillon", + "olfactif", + "olivier", + "ombrage", + "omettre", + "onctueux", + "onduler", + "onéreux", + "onirique", + "opale", + "opaque", + "opérer", + "opinion", + "opportun", + "opprimer", + "opter", + "optique", + "orageux", + "orange", + "orbite", + "ordonner", + "oreille", + "organe", + "orgueil", + "orifice", + "ornement", + "orque", + "ortie", + "osciller", + "osmose", + "ossature", + "otarie", + "ouragan", + "ourson", + "outil", + "outrager", + "ouvrage", + "ovation", + "oxyde", + "oxygène", + "ozone", + "paisible", + "palace", + "palmarès", + "palourde", + "palper", + "panache", + "panda", + "pangolin", + "paniquer", + "panneau", + "panorama", + "pantalon", + "papaye", + "papier", + "papoter", + "papyrus", + "paradoxe", + "parcelle", + "paresse", + "parfumer", + "parler", + "parole", + "parrain", + "parsemer", + "partager", + "parure", + "parvenir", + "passion", + "pastèque", + "paternel", + "patience", + "patron", + "pavillon", + "pavoiser", + "payer", + "paysage", + "peigne", + "peintre", + "pelage", + "pélican", + "pelle", + "pelouse", + "peluche", + "pendule", + "pénétrer", + "pénible", + "pensif", + "pénurie", + "pépite", + "péplum", + "perdrix", + "perforer", + "période", + "permuter", + "perplexe", + "persil", + "perte", + "peser", + "pétale", + "petit", + "pétrir", + "peuple", + "pharaon", + "phobie", + "phoque", + "photon", + "phrase", + "physique", + "piano", + "pictural", + "pièce", + "pierre", + "pieuvre", + "pilote", + "pinceau", + "pipette", + "piquer", + "pirogue", + "piscine", + "piston", + "pivoter", + "pixel", + "pizza", + "placard", + "plafond", + "plaisir", + "planer", + "plaque", + "plastron", + "plateau", + "pleurer", + "plexus", + "pliage", + "plomb", + "plonger", + "pluie", + "plumage", + "pochette", + "poésie", + "poète", + "pointe", + "poirier", + "poisson", + "poivre", + "polaire", + "policier", + "pollen", + "polygone", + "pommade", + "pompier", + "ponctuel", + "pondérer", + "poney", + "portique", + "position", + "posséder", + "posture", + "potager", + "poteau", + "potion", + "pouce", + "poulain", + "poumon", + "pourpre", + "poussin", + "pouvoir", + "prairie", + "pratique", + "précieux", + "prédire", + "préfixe", + "prélude", + "prénom", + "présence", + "prétexte", + "prévoir", + "primitif", + "prince", + "prison", + "priver", + "problème", + "procéder", + "prodige", + "profond", + "progrès", + "proie", + "projeter", + "prologue", + "promener", + "propre", + "prospère", + "protéger", + "prouesse", + "proverbe", + "prudence", + "pruneau", + "psychose", + "public", + "puceron", + "puiser", + "pulpe", + "pulsar", + "punaise", + "punitif", + "pupitre", + "purifier", + "puzzle", + "pyramide", + "quasar", + "querelle", + "question", + "quiétude", + "quitter", + "quotient", + "racine", + "raconter", + "radieux", + "ragondin", + "raideur", + "raisin", + "ralentir", + "rallonge", + "ramasser", + "rapide", + "rasage", + "ratisser", + "ravager", + "ravin", + "rayonner", + "réactif", + "réagir", + "réaliser", + "réanimer", + "recevoir", + "réciter", + "réclamer", + "récolter", + "recruter", + "reculer", + "recycler", + "rédiger", + "redouter", + "refaire", + "réflexe", + "réformer", + "refrain", + "refuge", + "régalien", + "région", + "réglage", + "régulier", + "réitérer", + "rejeter", + "rejouer", + "relatif", + "relever", + "relief", + "remarque", + "remède", + "remise", + "remonter", + "remplir", + "remuer", + "renard", + "renfort", + "renifler", + "renoncer", + "rentrer", + "renvoi", + "replier", + "reporter", + "reprise", + "reptile", + "requin", + "réserve", + "résineux", + "résoudre", + "respect", + "rester", + "résultat", + "rétablir", + "retenir", + "réticule", + "retomber", + "retracer", + "réunion", + "réussir", + "revanche", + "revivre", + "révolte", + "révulsif", + "richesse", + "rideau", + "rieur", + "rigide", + "rigoler", + "rincer", + "riposter", + "risible", + "risque", + "rituel", + "rival", + "rivière", + "rocheux", + "romance", + "rompre", + "ronce", + "rondin", + "roseau", + "rosier", + "rotatif", + "rotor", + "rotule", + "rouge", + "rouille", + "rouleau", + "routine", + "royaume", + "ruban", + "rubis", + "ruche", + "ruelle", + "rugueux", + "ruiner", + "ruisseau", + "ruser", + "rustique", + "rythme", + "sabler", + "saboter", + "sabre", + "sacoche", + "safari", + "sagesse", + "saisir", + "salade", + "salive", + "salon", + "saluer", + "samedi", + "sanction", + "sanglier", + "sarcasme", + "sardine", + "saturer", + "saugrenu", + "saumon", + "sauter", + "sauvage", + "savant", + "savonner", + "scalpel", + "scandale", + "scélérat", + "scénario", + "sceptre", + "schéma", + "science", + "scinder", + "score", + "scrutin", + "sculpter", + "séance", + "sécable", + "sécher", + "secouer", + "sécréter", + "sédatif", + "séduire", + "seigneur", + "séjour", + "sélectif", + "semaine", + "sembler", + "semence", + "séminal", + "sénateur", + "sensible", + "sentence", + "séparer", + "séquence", + "serein", + "sergent", + "sérieux", + "serrure", + "sérum", + "service", + "sésame", + "sévir", + "sevrage", + "sextuple", + "sidéral", + "siècle", + "siéger", + "siffler", + "sigle", + "signal", + "silence", + "silicium", + "simple", + "sincère", + "sinistre", + "siphon", + "sirop", + "sismique", + "situer", + "skier", + "social", + "socle", + "sodium", + "soigneux", + "soldat", + "soleil", + "solitude", + "soluble", + "sombre", + "sommeil", + "somnoler", + "sonde", + "songeur", + "sonnette", + "sonore", + "sorcier", + "sortir", + "sosie", + "sottise", + "soucieux", + "soudure", + "souffle", + "soulever", + "soupape", + "source", + "soutirer", + "souvenir", + "spacieux", + "spatial", + "spécial", + "sphère", + "spiral", + "stable", + "station", + "sternum", + "stimulus", + "stipuler", + "strict", + "studieux", + "stupeur", + "styliste", + "sublime", + "substrat", + "subtil", + "subvenir", + "succès", + "sucre", + "suffixe", + "suggérer", + "suiveur", + "sulfate", + "superbe", + "supplier", + "surface", + "suricate", + "surmener", + "surprise", + "sursaut", + "survie", + "suspect", + "syllabe", + "symbole", + "symétrie", + "synapse", + "syntaxe", + "système", + "tabac", + "tablier", + "tactile", + "tailler", + "talent", + "talisman", + "talonner", + "tambour", + "tamiser", + "tangible", + "tapis", + "taquiner", + "tarder", + "tarif", + "tartine", + "tasse", + "tatami", + "tatouage", + "taupe", + "taureau", + "taxer", + "témoin", + "temporel", + "tenaille", + "tendre", + "teneur", + "tenir", + "tension", + "terminer", + "terne", + "terrible", + "tétine", + "texte", + "thème", + "théorie", + "thérapie", + "thorax", + "tibia", + "tiède", + "timide", + "tirelire", + "tiroir", + "tissu", + "titane", + "titre", + "tituber", + "toboggan", + "tolérant", + "tomate", + "tonique", + "tonneau", + "toponyme", + "torche", + "tordre", + "tornade", + "torpille", + "torrent", + "torse", + "tortue", + "totem", + "toucher", + "tournage", + "tousser", + "toxine", + "traction", + "trafic", + "tragique", + "trahir", + "train", + "trancher", + "travail", + "trèfle", + "tremper", + "trésor", + "treuil", + "triage", + "tribunal", + "tricoter", + "trilogie", + "triomphe", + "tripler", + "triturer", + "trivial", + "trombone", + "tronc", + "tropical", + "troupeau", + "tuile", + "tulipe", + "tumulte", + "tunnel", + "turbine", + "tuteur", + "tutoyer", + "tuyau", + "tympan", + "typhon", + "typique", + "tyran", + "ubuesque", + "ultime", + "ultrason", + "unanime", + "unifier", + "union", + "unique", + "unitaire", + "univers", + "uranium", + "urbain", + "urticant", + "usage", + "usine", + "usuel", + "usure", + "utile", + "utopie", + "vacarme", + "vaccin", + "vagabond", + "vague", + "vaillant", + "vaincre", + "vaisseau", + "valable", + "valise", + "vallon", + "valve", + "vampire", + "vanille", + "vapeur", + "varier", + "vaseux", + "vassal", + "vaste", + "vecteur", + "vedette", + "végétal", + "véhicule", + "veinard", + "véloce", + "vendredi", + "vénérer", + "venger", + "venimeux", + "ventouse", + "verdure", + "vérin", + "vernir", + "verrou", + "verser", + "vertu", + "veston", + "vétéran", + "vétuste", + "vexant", + "vexer", + "viaduc", + "viande", + "victoire", + "vidange", + "vidéo", + "vignette", + "vigueur", + "vilain", + "village", + "vinaigre", + "violon", + "vipère", + "virement", + "virtuose", + "virus", + "visage", + "viseur", + "vision", + "visqueux", + "visuel", + "vital", + "vitesse", + "viticole", + "vitrine", + "vivace", + "vivipare", + "vocation", + "voguer", + "voile", + "voisin", + "voiture", + "volaille", + "volcan", + "voltiger", + "volume", + "vorace", + "vortex", + "voter", + "vouloir", + "voyage", + "voyelle", + "wagon", + "xénon", + "yacht", + "zèbre", + "zénith", + "zeste", + "zoologie" + } + }; + + const dictionary cs = + { + { + "abdikace", + "abeceda", + "adresa", + "agrese", + "akce", + "aktovka", + "alej", + "alkohol", + "amputace", + "ananas", + "andulka", + "anekdota", + "anketa", + "antika", + "anulovat", + "archa", + "arogance", + "asfalt", + "asistent", + "aspirace", + "astma", + "astronom", + "atlas", + "atletika", + "atol", + "autobus", + "azyl", + "babka", + "bachor", + "bacil", + "baculka", + "badatel", + "bageta", + "bagr", + "bahno", + "bakterie", + "balada", + "baletka", + "balkon", + "balonek", + "balvan", + "balza", + "bambus", + "bankomat", + "barbar", + "baret", + "barman", + "baroko", + "barva", + "baterka", + "batoh", + "bavlna", + "bazalka", + "bazilika", + "bazuka", + "bedna", + "beran", + "beseda", + "bestie", + "beton", + "bezinka", + "bezmoc", + "beztak", + "bicykl", + "bidlo", + "biftek", + "bikiny", + "bilance", + "biograf", + "biolog", + "bitva", + "bizon", + "blahobyt", + "blatouch", + "blecha", + "bledule", + "blesk", + "blikat", + "blizna", + "blokovat", + "bloudit", + "blud", + "bobek", + "bobr", + "bodlina", + "bodnout", + "bohatost", + "bojkot", + "bojovat", + "bokorys", + "bolest", + "borec", + "borovice", + "bota", + "boubel", + "bouchat", + "bouda", + "boule", + "bourat", + "boxer", + "bradavka", + "brambora", + "branka", + "bratr", + "brepta", + "briketa", + "brko", + "brloh", + "bronz", + "broskev", + "brunetka", + "brusinka", + "brzda", + "brzy", + "bublina", + "bubnovat", + "buchta", + "buditel", + "budka", + "budova", + "bufet", + "bujarost", + "bukvice", + "buldok", + "bulva", + "bunda", + "bunkr", + "burza", + "butik", + "buvol", + "buzola", + "bydlet", + "bylina", + "bytovka", + "bzukot", + "capart", + "carevna", + "cedr", + "cedule", + "cejch", + "cejn", + "cela", + "celer", + "celkem", + "celnice", + "cenina", + "cennost", + "cenovka", + "centrum", + "cenzor", + "cestopis", + "cetka", + "chalupa", + "chapadlo", + "charita", + "chata", + "chechtat", + "chemie", + "chichot", + "chirurg", + "chlad", + "chleba", + "chlubit", + "chmel", + "chmura", + "chobot", + "chochol", + "chodba", + "cholera", + "chomout", + "chopit", + "choroba", + "chov", + "chrapot", + "chrlit", + "chrt", + "chrup", + "chtivost", + "chudina", + "chutnat", + "chvat", + "chvilka", + "chvost", + "chyba", + "chystat", + "chytit", + "cibule", + "cigareta", + "cihelna", + "cihla", + "cinkot", + "cirkus", + "cisterna", + "citace", + "citrus", + "cizinec", + "cizost", + "clona", + "cokoliv", + "couvat", + "ctitel", + "ctnost", + "cudnost", + "cuketa", + "cukr", + "cupot", + "cvaknout", + "cval", + "cvik", + "cvrkot", + "cyklista", + "daleko", + "dareba", + "datel", + "datum", + "dcera", + "debata", + "dechovka", + "decibel", + "deficit", + "deflace", + "dekl", + "dekret", + "demokrat", + "deprese", + "derby", + "deska", + "detektiv", + "dikobraz", + "diktovat", + "dioda", + "diplom", + "disk", + "displej", + "divadlo", + "divoch", + "dlaha", + "dlouho", + "dluhopis", + "dnes", + "dobro", + "dobytek", + "docent", + "dochutit", + "dodnes", + "dohled", + "dohoda", + "dohra", + "dojem", + "dojnice", + "doklad", + "dokola", + "doktor", + "dokument", + "dolar", + "doleva", + "dolina", + "doma", + "dominant", + "domluvit", + "domov", + "donutit", + "dopad", + "dopis", + "doplnit", + "doposud", + "doprovod", + "dopustit", + "dorazit", + "dorost", + "dort", + "dosah", + "doslov", + "dostatek", + "dosud", + "dosyta", + "dotaz", + "dotek", + "dotknout", + "doufat", + "doutnat", + "dovozce", + "dozadu", + "doznat", + "dozorce", + "drahota", + "drak", + "dramatik", + "dravec", + "draze", + "drdol", + "drobnost", + "drogerie", + "drozd", + "drsnost", + "drtit", + "drzost", + "duben", + "duchovno", + "dudek", + "duha", + "duhovka", + "dusit", + "dusno", + "dutost", + "dvojice", + "dvorec", + "dynamit", + "ekolog", + "ekonomie", + "elektron", + "elipsa", + "email", + "emise", + "emoce", + "empatie", + "epizoda", + "epocha", + "epopej", + "epos", + "esej", + "esence", + "eskorta", + "eskymo", + "etiketa", + "euforie", + "evoluce", + "exekuce", + "exkurze", + "expedice", + "exploze", + "export", + "extrakt", + "facka", + "fajfka", + "fakulta", + "fanatik", + "fantazie", + "farmacie", + "favorit", + "fazole", + "federace", + "fejeton", + "fenka", + "fialka", + "figurant", + "filozof", + "filtr", + "finance", + "finta", + "fixace", + "fjord", + "flanel", + "flirt", + "flotila", + "fond", + "fosfor", + "fotbal", + "fotka", + "foton", + "frakce", + "freska", + "fronta", + "fukar", + "funkce", + "fyzika", + "galeje", + "garant", + "genetika", + "geolog", + "gilotina", + "glazura", + "glejt", + "golem", + "golfista", + "gotika", + "graf", + "gramofon", + "granule", + "grep", + "gril", + "grog", + "groteska", + "guma", + "hadice", + "hadr", + "hala", + "halenka", + "hanba", + "hanopis", + "harfa", + "harpuna", + "havran", + "hebkost", + "hejkal", + "hejno", + "hejtman", + "hektar", + "helma", + "hematom", + "herec", + "herna", + "heslo", + "hezky", + "historik", + "hladovka", + "hlasivky", + "hlava", + "hledat", + "hlen", + "hlodavec", + "hloh", + "hloupost", + "hltat", + "hlubina", + "hluchota", + "hmat", + "hmota", + "hmyz", + "hnis", + "hnojivo", + "hnout", + "hoblina", + "hoboj", + "hoch", + "hodiny", + "hodlat", + "hodnota", + "hodovat", + "hojnost", + "hokej", + "holinka", + "holka", + "holub", + "homole", + "honitba", + "honorace", + "horal", + "horda", + "horizont", + "horko", + "horlivec", + "hormon", + "hornina", + "horoskop", + "horstvo", + "hospoda", + "hostina", + "hotovost", + "houba", + "houf", + "houpat", + "houska", + "hovor", + "hradba", + "hranice", + "hravost", + "hrazda", + "hrbolek", + "hrdina", + "hrdlo", + "hrdost", + "hrnek", + "hrobka", + "hromada", + "hrot", + "hrouda", + "hrozen", + "hrstka", + "hrubost", + "hryzat", + "hubenost", + "hubnout", + "hudba", + "hukot", + "humr", + "husita", + "hustota", + "hvozd", + "hybnost", + "hydrant", + "hygiena", + "hymna", + "hysterik", + "idylka", + "ihned", + "ikona", + "iluze", + "imunita", + "infekce", + "inflace", + "inkaso", + "inovace", + "inspekce", + "internet", + "invalida", + "investor", + "inzerce", + "ironie", + "jablko", + "jachta", + "jahoda", + "jakmile", + "jakost", + "jalovec", + "jantar", + "jarmark", + "jaro", + "jasan", + "jasno", + "jatka", + "javor", + "jazyk", + "jedinec", + "jedle", + "jednatel", + "jehlan", + "jekot", + "jelen", + "jelito", + "jemnost", + "jenom", + "jepice", + "jeseter", + "jevit", + "jezdec", + "jezero", + "jinak", + "jindy", + "jinoch", + "jiskra", + "jistota", + "jitrnice", + "jizva", + "jmenovat", + "jogurt", + "jurta", + "kabaret", + "kabel", + "kabinet", + "kachna", + "kadet", + "kadidlo", + "kahan", + "kajak", + "kajuta", + "kakao", + "kaktus", + "kalamita", + "kalhoty", + "kalibr", + "kalnost", + "kamera", + "kamkoliv", + "kamna", + "kanibal", + "kanoe", + "kantor", + "kapalina", + "kapela", + "kapitola", + "kapka", + "kaple", + "kapota", + "kapr", + "kapusta", + "kapybara", + "karamel", + "karotka", + "karton", + "kasa", + "katalog", + "katedra", + "kauce", + "kauza", + "kavalec", + "kazajka", + "kazeta", + "kazivost", + "kdekoliv", + "kdesi", + "kedluben", + "kemp", + "keramika", + "kino", + "klacek", + "kladivo", + "klam", + "klapot", + "klasika", + "klaun", + "klec", + "klenba", + "klepat", + "klesnout", + "klid", + "klima", + "klisna", + "klobouk", + "klokan", + "klopa", + "kloub", + "klubovna", + "klusat", + "kluzkost", + "kmen", + "kmitat", + "kmotr", + "kniha", + "knot", + "koalice", + "koberec", + "kobka", + "kobliha", + "kobyla", + "kocour", + "kohout", + "kojenec", + "kokos", + "koktejl", + "kolaps", + "koleda", + "kolize", + "kolo", + "komando", + "kometa", + "komik", + "komnata", + "komora", + "kompas", + "komunita", + "konat", + "koncept", + "kondice", + "konec", + "konfese", + "kongres", + "konina", + "konkurs", + "kontakt", + "konzerva", + "kopanec", + "kopie", + "kopnout", + "koprovka", + "korbel", + "korektor", + "kormidlo", + "koroptev", + "korpus", + "koruna", + "koryto", + "korzet", + "kosatec", + "kostka", + "kotel", + "kotleta", + "kotoul", + "koukat", + "koupelna", + "kousek", + "kouzlo", + "kovboj", + "koza", + "kozoroh", + "krabice", + "krach", + "krajina", + "kralovat", + "krasopis", + "kravata", + "kredit", + "krejcar", + "kresba", + "kreveta", + "kriket", + "kritik", + "krize", + "krkavec", + "krmelec", + "krmivo", + "krocan", + "krok", + "kronika", + "kropit", + "kroupa", + "krovka", + "krtek", + "kruhadlo", + "krupice", + "krutost", + "krvinka", + "krychle", + "krypta", + "krystal", + "kryt", + "kudlanka", + "kufr", + "kujnost", + "kukla", + "kulajda", + "kulich", + "kulka", + "kulomet", + "kultura", + "kuna", + "kupodivu", + "kurt", + "kurzor", + "kutil", + "kvalita", + "kvasinka", + "kvestor", + "kynolog", + "kyselina", + "kytara", + "kytice", + "kytka", + "kytovec", + "kyvadlo", + "labrador", + "lachtan", + "ladnost", + "laik", + "lakomec", + "lamela", + "lampa", + "lanovka", + "lasice", + "laso", + "lastura", + "latinka", + "lavina", + "lebka", + "leckdy", + "leden", + "lednice", + "ledovka", + "ledvina", + "legenda", + "legie", + "legrace", + "lehce", + "lehkost", + "lehnout", + "lektvar", + "lenochod", + "lentilka", + "lepenka", + "lepidlo", + "letadlo", + "letec", + "letmo", + "letokruh", + "levhart", + "levitace", + "levobok", + "libra", + "lichotka", + "lidojed", + "lidskost", + "lihovina", + "lijavec", + "lilek", + "limetka", + "linie", + "linka", + "linoleum", + "listopad", + "litina", + "litovat", + "lobista", + "lodivod", + "logika", + "logoped", + "lokalita", + "loket", + "lomcovat", + "lopata", + "lopuch", + "lord", + "losos", + "lotr", + "loudal", + "louh", + "louka", + "louskat", + "lovec", + "lstivost", + "lucerna", + "lucifer", + "lump", + "lusk", + "lustrace", + "lvice", + "lyra", + "lyrika", + "lysina", + "madam", + "madlo", + "magistr", + "mahagon", + "majetek", + "majitel", + "majorita", + "makak", + "makovice", + "makrela", + "malba", + "malina", + "malovat", + "malvice", + "maminka", + "mandle", + "manko", + "marnost", + "masakr", + "maskot", + "masopust", + "matice", + "matrika", + "maturita", + "mazanec", + "mazivo", + "mazlit", + "mazurka", + "mdloba", + "mechanik", + "meditace", + "medovina", + "melasa", + "meloun", + "mentolka", + "metla", + "metoda", + "metr", + "mezera", + "migrace", + "mihnout", + "mihule", + "mikina", + "mikrofon", + "milenec", + "milimetr", + "milost", + "mimika", + "mincovna", + "minibar", + "minomet", + "minulost", + "miska", + "mistr", + "mixovat", + "mladost", + "mlha", + "mlhovina", + "mlok", + "mlsat", + "mluvit", + "mnich", + "mnohem", + "mobil", + "mocnost", + "modelka", + "modlitba", + "mohyla", + "mokro", + "molekula", + "momentka", + "monarcha", + "monokl", + "monstrum", + "montovat", + "monzun", + "mosaz", + "moskyt", + "most", + "motivace", + "motorka", + "motyka", + "moucha", + "moudrost", + "mozaika", + "mozek", + "mozol", + "mramor", + "mravenec", + "mrkev", + "mrtvola", + "mrzet", + "mrzutost", + "mstitel", + "mudrc", + "muflon", + "mulat", + "mumie", + "munice", + "muset", + "mutace", + "muzeum", + "muzikant", + "myslivec", + "mzda", + "nabourat", + "nachytat", + "nadace", + "nadbytek", + "nadhoz", + "nadobro", + "nadpis", + "nahlas", + "nahnat", + "nahodile", + "nahradit", + "naivita", + "najednou", + "najisto", + "najmout", + "naklonit", + "nakonec", + "nakrmit", + "nalevo", + "namazat", + "namluvit", + "nanometr", + "naoko", + "naopak", + "naostro", + "napadat", + "napevno", + "naplnit", + "napnout", + "naposled", + "naprosto", + "narodit", + "naruby", + "narychlo", + "nasadit", + "nasekat", + "naslepo", + "nastat", + "natolik", + "navenek", + "navrch", + "navzdory", + "nazvat", + "nebe", + "nechat", + "necky", + "nedaleko", + "nedbat", + "neduh", + "negace", + "nehet", + "nehoda", + "nejen", + "nejprve", + "neklid", + "nelibost", + "nemilost", + "nemoc", + "neochota", + "neonka", + "nepokoj", + "nerost", + "nerv", + "nesmysl", + "nesoulad", + "netvor", + "neuron", + "nevina", + "nezvykle", + "nicota", + "nijak", + "nikam", + "nikdy", + "nikl", + "nikterak", + "nitro", + "nocleh", + "nohavice", + "nominace", + "nora", + "norek", + "nositel", + "nosnost", + "nouze", + "noviny", + "novota", + "nozdra", + "nuda", + "nudle", + "nuget", + "nutit", + "nutnost", + "nutrie", + "nymfa", + "obal", + "obarvit", + "obava", + "obdiv", + "obec", + "obehnat", + "obejmout", + "obezita", + "obhajoba", + "obilnice", + "objasnit", + "objekt", + "obklopit", + "oblast", + "oblek", + "obliba", + "obloha", + "obluda", + "obnos", + "obohatit", + "obojek", + "obout", + "obrazec", + "obrna", + "obruba", + "obrys", + "obsah", + "obsluha", + "obstarat", + "obuv", + "obvaz", + "obvinit", + "obvod", + "obvykle", + "obyvatel", + "obzor", + "ocas", + "ocel", + "ocenit", + "ochladit", + "ochota", + "ochrana", + "ocitnout", + "odboj", + "odbyt", + "odchod", + "odcizit", + "odebrat", + "odeslat", + "odevzdat", + "odezva", + "odhadce", + "odhodit", + "odjet", + "odjinud", + "odkaz", + "odkoupit", + "odliv", + "odluka", + "odmlka", + "odolnost", + "odpad", + "odpis", + "odplout", + "odpor", + "odpustit", + "odpykat", + "odrazka", + "odsoudit", + "odstup", + "odsun", + "odtok", + "odtud", + "odvaha", + "odveta", + "odvolat", + "odvracet", + "odznak", + "ofina", + "ofsajd", + "ohlas", + "ohnisko", + "ohrada", + "ohrozit", + "ohryzek", + "okap", + "okenice", + "oklika", + "okno", + "okouzlit", + "okovy", + "okrasa", + "okres", + "okrsek", + "okruh", + "okupant", + "okurka", + "okusit", + "olejnina", + "olizovat", + "omak", + "omeleta", + "omezit", + "omladina", + "omlouvat", + "omluva", + "omyl", + "onehdy", + "opakovat", + "opasek", + "operace", + "opice", + "opilost", + "opisovat", + "opora", + "opozice", + "opravdu", + "oproti", + "orbital", + "orchestr", + "orgie", + "orlice", + "orloj", + "ortel", + "osada", + "oschnout", + "osika", + "osivo", + "oslava", + "oslepit", + "oslnit", + "oslovit", + "osnova", + "osoba", + "osolit", + "ospalec", + "osten", + "ostraha", + "ostuda", + "ostych", + "osvojit", + "oteplit", + "otisk", + "otop", + "otrhat", + "otrlost", + "otrok", + "otruby", + "otvor", + "ovanout", + "ovar", + "oves", + "ovlivnit", + "ovoce", + "oxid", + "ozdoba", + "pachatel", + "pacient", + "padouch", + "pahorek", + "pakt", + "palanda", + "palec", + "palivo", + "paluba", + "pamflet", + "pamlsek", + "panenka", + "panika", + "panna", + "panovat", + "panstvo", + "pantofle", + "paprika", + "parketa", + "parodie", + "parta", + "paruka", + "paryba", + "paseka", + "pasivita", + "pastelka", + "patent", + "patrona", + "pavouk", + "pazneht", + "pazourek", + "pecka", + "pedagog", + "pejsek", + "peklo", + "peloton", + "penalta", + "pendrek", + "penze", + "periskop", + "pero", + "pestrost", + "petarda", + "petice", + "petrolej", + "pevnina", + "pexeso", + "pianista", + "piha", + "pijavice", + "pikle", + "piknik", + "pilina", + "pilnost", + "pilulka", + "pinzeta", + "pipeta", + "pisatel", + "pistole", + "pitevna", + "pivnice", + "pivovar", + "placenta", + "plakat", + "plamen", + "planeta", + "plastika", + "platit", + "plavidlo", + "plaz", + "plech", + "plemeno", + "plenta", + "ples", + "pletivo", + "plevel", + "plivat", + "plnit", + "plno", + "plocha", + "plodina", + "plomba", + "plout", + "pluk", + "plyn", + "pobavit", + "pobyt", + "pochod", + "pocit", + "poctivec", + "podat", + "podcenit", + "podepsat", + "podhled", + "podivit", + "podklad", + "podmanit", + "podnik", + "podoba", + "podpora", + "podraz", + "podstata", + "podvod", + "podzim", + "poezie", + "pohanka", + "pohnutka", + "pohovor", + "pohroma", + "pohyb", + "pointa", + "pojistka", + "pojmout", + "pokazit", + "pokles", + "pokoj", + "pokrok", + "pokuta", + "pokyn", + "poledne", + "polibek", + "polknout", + "poloha", + "polynom", + "pomalu", + "pominout", + "pomlka", + "pomoc", + "pomsta", + "pomyslet", + "ponechat", + "ponorka", + "ponurost", + "popadat", + "popel", + "popisek", + "poplach", + "poprosit", + "popsat", + "popud", + "poradce", + "porce", + "porod", + "porucha", + "poryv", + "posadit", + "posed", + "posila", + "poskok", + "poslanec", + "posoudit", + "pospolu", + "postava", + "posudek", + "posyp", + "potah", + "potkan", + "potlesk", + "potomek", + "potrava", + "potupa", + "potvora", + "poukaz", + "pouto", + "pouzdro", + "povaha", + "povidla", + "povlak", + "povoz", + "povrch", + "povstat", + "povyk", + "povzdech", + "pozdrav", + "pozemek", + "poznatek", + "pozor", + "pozvat", + "pracovat", + "prahory", + "praktika", + "prales", + "praotec", + "praporek", + "prase", + "pravda", + "princip", + "prkno", + "probudit", + "procento", + "prodej", + "profese", + "prohra", + "projekt", + "prolomit", + "promile", + "pronikat", + "propad", + "prorok", + "prosba", + "proton", + "proutek", + "provaz", + "prskavka", + "prsten", + "prudkost", + "prut", + "prvek", + "prvohory", + "psanec", + "psovod", + "pstruh", + "ptactvo", + "puberta", + "puch", + "pudl", + "pukavec", + "puklina", + "pukrle", + "pult", + "pumpa", + "punc", + "pupen", + "pusa", + "pusinka", + "pustina", + "putovat", + "putyka", + "pyramida", + "pysk", + "pytel", + "racek", + "rachot", + "radiace", + "radnice", + "radon", + "raft", + "ragby", + "raketa", + "rakovina", + "rameno", + "rampouch", + "rande", + "rarach", + "rarita", + "rasovna", + "rastr", + "ratolest", + "razance", + "razidlo", + "reagovat", + "reakce", + "recept", + "redaktor", + "referent", + "reflex", + "rejnok", + "reklama", + "rekord", + "rekrut", + "rektor", + "reputace", + "revize", + "revma", + "revolver", + "rezerva", + "riskovat", + "riziko", + "robotika", + "rodokmen", + "rohovka", + "rokle", + "rokoko", + "romaneto", + "ropovod", + "ropucha", + "rorejs", + "rosol", + "rostlina", + "rotmistr", + "rotoped", + "rotunda", + "roubenka", + "roucho", + "roup", + "roura", + "rovina", + "rovnice", + "rozbor", + "rozchod", + "rozdat", + "rozeznat", + "rozhodce", + "rozinka", + "rozjezd", + "rozkaz", + "rozloha", + "rozmar", + "rozpad", + "rozruch", + "rozsah", + "roztok", + "rozum", + "rozvod", + "rubrika", + "ruchadlo", + "rukavice", + "rukopis", + "ryba", + "rybolov", + "rychlost", + "rydlo", + "rypadlo", + "rytina", + "ryzost", + "sadista", + "sahat", + "sako", + "samec", + "samizdat", + "samota", + "sanitka", + "sardinka", + "sasanka", + "satelit", + "sazba", + "sazenice", + "sbor", + "schovat", + "sebranka", + "secese", + "sedadlo", + "sediment", + "sedlo", + "sehnat", + "sejmout", + "sekera", + "sekta", + "sekunda", + "sekvoje", + "semeno", + "seno", + "servis", + "sesadit", + "seshora", + "seskok", + "seslat", + "sestra", + "sesuv", + "sesypat", + "setba", + "setina", + "setkat", + "setnout", + "setrvat", + "sever", + "seznam", + "shoda", + "shrnout", + "sifon", + "silnice", + "sirka", + "sirotek", + "sirup", + "situace", + "skafandr", + "skalisko", + "skanzen", + "skaut", + "skeptik", + "skica", + "skladba", + "sklenice", + "sklo", + "skluz", + "skoba", + "skokan", + "skoro", + "skripta", + "skrz", + "skupina", + "skvost", + "skvrna", + "slabika", + "sladidlo", + "slanina", + "slast", + "slavnost", + "sledovat", + "slepec", + "sleva", + "slezina", + "slib", + "slina", + "sliznice", + "slon", + "sloupek", + "slovo", + "sluch", + "sluha", + "slunce", + "slupka", + "slza", + "smaragd", + "smetana", + "smilstvo", + "smlouva", + "smog", + "smrad", + "smrk", + "smrtka", + "smutek", + "smysl", + "snad", + "snaha", + "snob", + "sobota", + "socha", + "sodovka", + "sokol", + "sopka", + "sotva", + "souboj", + "soucit", + "soudce", + "souhlas", + "soulad", + "soumrak", + "souprava", + "soused", + "soutok", + "souviset", + "spalovna", + "spasitel", + "spis", + "splav", + "spodek", + "spojenec", + "spolu", + "sponzor", + "spornost", + "spousta", + "sprcha", + "spustit", + "sranda", + "sraz", + "srdce", + "srna", + "srnec", + "srovnat", + "srpen", + "srst", + "srub", + "stanice", + "starosta", + "statika", + "stavba", + "stehno", + "stezka", + "stodola", + "stolek", + "stopa", + "storno", + "stoupat", + "strach", + "stres", + "strhnout", + "strom", + "struna", + "studna", + "stupnice", + "stvol", + "styk", + "subjekt", + "subtropy", + "suchar", + "sudost", + "sukno", + "sundat", + "sunout", + "surikata", + "surovina", + "svah", + "svalstvo", + "svetr", + "svatba", + "svazek", + "svisle", + "svitek", + "svoboda", + "svodidlo", + "svorka", + "svrab", + "sykavka", + "sykot", + "synek", + "synovec", + "sypat", + "sypkost", + "syrovost", + "sysel", + "sytost", + "tabletka", + "tabule", + "tahoun", + "tajemno", + "tajfun", + "tajga", + "tajit", + "tajnost", + "taktika", + "tamhle", + "tampon", + "tancovat", + "tanec", + "tanker", + "tapeta", + "tavenina", + "tazatel", + "technika", + "tehdy", + "tekutina", + "telefon", + "temnota", + "tendence", + "tenista", + "tenor", + "teplota", + "tepna", + "teprve", + "terapie", + "termoska", + "textil", + "ticho", + "tiskopis", + "titulek", + "tkadlec", + "tkanina", + "tlapka", + "tleskat", + "tlukot", + "tlupa", + "tmel", + "toaleta", + "topinka", + "topol", + "torzo", + "touha", + "toulec", + "tradice", + "traktor", + "tramp", + "trasa", + "traverza", + "trefit", + "trest", + "trezor", + "trhavina", + "trhlina", + "trochu", + "trojice", + "troska", + "trouba", + "trpce", + "trpitel", + "trpkost", + "trubec", + "truchlit", + "truhlice", + "trus", + "trvat", + "tudy", + "tuhnout", + "tuhost", + "tundra", + "turista", + "turnaj", + "tuzemsko", + "tvaroh", + "tvorba", + "tvrdost", + "tvrz", + "tygr", + "tykev", + "ubohost", + "uboze", + "ubrat", + "ubrousek", + "ubrus", + "ubytovna", + "ucho", + "uctivost", + "udivit", + "uhradit", + "ujednat", + "ujistit", + "ujmout", + "ukazatel", + "uklidnit", + "uklonit", + "ukotvit", + "ukrojit", + "ulice", + "ulita", + "ulovit", + "umyvadlo", + "unavit", + "uniforma", + "uniknout", + "upadnout", + "uplatnit", + "uplynout", + "upoutat", + "upravit", + "uran", + "urazit", + "usednout", + "usilovat", + "usmrtit", + "usnadnit", + "usnout", + "usoudit", + "ustlat", + "ustrnout", + "utahovat", + "utkat", + "utlumit", + "utonout", + "utopenec", + "utrousit", + "uvalit", + "uvolnit", + "uvozovka", + "uzdravit", + "uzel", + "uzenina", + "uzlina", + "uznat", + "vagon", + "valcha", + "valoun", + "vana", + "vandal", + "vanilka", + "varan", + "varhany", + "varovat", + "vcelku", + "vchod", + "vdova", + "vedro", + "vegetace", + "vejce", + "velbloud", + "veletrh", + "velitel", + "velmoc", + "velryba", + "venkov", + "veranda", + "verze", + "veselka", + "veskrze", + "vesnice", + "vespodu", + "vesta", + "veterina", + "veverka", + "vibrace", + "vichr", + "videohra", + "vidina", + "vidle", + "vila", + "vinice", + "viset", + "vitalita", + "vize", + "vizitka", + "vjezd", + "vklad", + "vkus", + "vlajka", + "vlak", + "vlasec", + "vlevo", + "vlhkost", + "vliv", + "vlnovka", + "vloupat", + "vnucovat", + "vnuk", + "voda", + "vodivost", + "vodoznak", + "vodstvo", + "vojensky", + "vojna", + "vojsko", + "volant", + "volba", + "volit", + "volno", + "voskovka", + "vozidlo", + "vozovna", + "vpravo", + "vrabec", + "vracet", + "vrah", + "vrata", + "vrba", + "vrcholek", + "vrhat", + "vrstva", + "vrtule", + "vsadit", + "vstoupit", + "vstup", + "vtip", + "vybavit", + "vybrat", + "vychovat", + "vydat", + "vydra", + "vyfotit", + "vyhledat", + "vyhnout", + "vyhodit", + "vyhradit", + "vyhubit", + "vyjasnit", + "vyjet", + "vyjmout", + "vyklopit", + "vykonat", + "vylekat", + "vymazat", + "vymezit", + "vymizet", + "vymyslet", + "vynechat", + "vynikat", + "vynutit", + "vypadat", + "vyplatit", + "vypravit", + "vypustit", + "vyrazit", + "vyrovnat", + "vyrvat", + "vyslovit", + "vysoko", + "vystavit", + "vysunout", + "vysypat", + "vytasit", + "vytesat", + "vytratit", + "vyvinout", + "vyvolat", + "vyvrhel", + "vyzdobit", + "vyznat", + "vzadu", + "vzbudit", + "vzchopit", + "vzdor", + "vzduch", + "vzdychat", + "vzestup", + "vzhledem", + "vzkaz", + "vzlykat", + "vznik", + "vzorek", + "vzpoura", + "vztah", + "vztek", + "xylofon", + "zabrat", + "zabydlet", + "zachovat", + "zadarmo", + "zadusit", + "zafoukat", + "zahltit", + "zahodit", + "zahrada", + "zahynout", + "zajatec", + "zajet", + "zajistit", + "zaklepat", + "zakoupit", + "zalepit", + "zamezit", + "zamotat", + "zamyslet", + "zanechat", + "zanikat", + "zaplatit", + "zapojit", + "zapsat", + "zarazit", + "zastavit", + "zasunout", + "zatajit", + "zatemnit", + "zatknout", + "zaujmout", + "zavalit", + "zavelet", + "zavinit", + "zavolat", + "zavrtat", + "zazvonit", + "zbavit", + "zbrusu", + "zbudovat", + "zbytek", + "zdaleka", + "zdarma", + "zdatnost", + "zdivo", + "zdobit", + "zdroj", + "zdvih", + "zdymadlo", + "zelenina", + "zeman", + "zemina", + "zeptat", + "zezadu", + "zezdola", + "zhatit", + "zhltnout", + "zhluboka", + "zhotovit", + "zhruba", + "zima", + "zimnice", + "zjemnit", + "zklamat", + "zkoumat", + "zkratka", + "zkumavka", + "zlato", + "zlehka", + "zloba", + "zlom", + "zlost", + "zlozvyk", + "zmapovat", + "zmar", + "zmatek", + "zmije", + "zmizet", + "zmocnit", + "zmodrat", + "zmrzlina", + "zmutovat", + "znak", + "znalost", + "znamenat", + "znovu", + "zobrazit", + "zotavit", + "zoubek", + "zoufale", + "zplodit", + "zpomalit", + "zprava", + "zprostit", + "zprudka", + "zprvu", + "zrada", + "zranit", + "zrcadlo", + "zrnitost", + "zrno", + "zrovna", + "zrychlit", + "zrzavost", + "zticha", + "ztratit", + "zubovina", + "zubr", + "zvednout", + "zvenku", + "zvesela", + "zvon", + "zvrat", + "zvukovod", + "zvyk" + } + }; + + const dictionary ru = + { + { + "абажур", + "абзац", + "абонент", + "абордаж", + "абрикос", + "абсолют", + "абсурд", + "авангард", + "август", + "авиация", + "авизо", + "аврал", + "автор", + "агат", + "агент", + "агрегат", + "адажио", + "адвокат", + "адепт", + "адмирал", + "адрес", + "ажиотаж", + "азарт", + "азбука", + "азимут", + "азот", + "айва", + "айсберг", + "академия", + "аквариум", + "акведук", + "аккорд", + "акробат", + "аксиома", + "актер", + "актриса", + "акула", + "акцент", + "акция", + "алгебра", + "алгоритм", + "алиби", + "аллея", + "алмаз", + "алоэ", + "алтарь", + "алфавит", + "алхимик", + "алый", + "альбом", + "алюминий", + "амбар", + "амбиция", + "аметист", + "амнезия", + "ампир", + "амулет", + "амфора", + "анализ", + "ангар", + "анекдот", + "анимация", + "анкета", + "аноним", + "ансамбль", + "антиквар", + "анфилада", + "анчоус", + "апатия", + "апельсин", + "апогей", + "апофеоз", + "апрель", + "аптека", + "арахис", + "арбуз", + "аргумент", + "аренда", + "ария", + "арка", + "арлекин", + "армада", + "аромат", + "арсенал", + "артист", + "арфа", + "архив", + "аршин", + "асбест", + "аскет", + "аспирант", + "астроном", + "асфальт", + "атака", + "ателье", + "атлас", + "атом", + "атрибут", + "аудитор", + "аукцион", + "аура", + "афиша", + "афоризм", + "ацетон", + "аэропорт", + "бабочка", + "багаж", + "бадья", + "байка", + "бакалея", + "баланс", + "балет", + "балкон", + "баллада", + "бамбук", + "бампер", + "банджо", + "банк", + "баобаб", + "барабан", + "бард", + "барс", + "бархат", + "барьер", + "басня", + "бассейн", + "бастион", + "батарея", + "батон", + "батут", + "баул", + "бахрома", + "башмак", + "баян", + "бегемот", + "бегония", + "бегство", + "бездна", + "бейсбол", + "бекон", + "белок", + "белый", + "белье", + "бензин", + "бергамот", + "берег", + "берлога", + "беседа", + "биатлон", + "бигуди", + "бидон", + "бизнес", + "бикини", + "бильярд", + "бинокль", + "бинт", + "биология", + "биржа", + "бисер", + "бицепс", + "благо", + "блеск", + "блеф", + "блин", + "блокнот", + "блондин", + "блюдо", + "бляха", + "бобер", + "бобина", + "богатырь", + "бодрый", + "боевик", + "боец", + "бойлер", + "бокал", + "болид", + "бордюр", + "борода", + "борщ", + "борьба", + "босой", + "ботва", + "ботинок", + "боцман", + "бочка", + "боярин", + "брак", + "брат", + "бревно", + "бригада", + "брикет", + "бровь", + "брод", + "брокер", + "бросок", + "брюки", + "брюнет", + "бубен", + "бублик", + "бугор", + "будка", + "будущее", + "бузина", + "буйвол", + "буква", + "букет", + "буксир", + "булат", + "бульвар", + "бумага", + "бумеранг", + "бунгало", + "бунт", + "бурьян", + "буря", + "бусы", + "бутон", + "бутылка", + "буфет", + "бухта", + "быстрота", + "бюджет", + "бюро", + "бюст", + "вагон", + "важный", + "вазелин", + "вакса", + "вакуум", + "вакцина", + "валенок", + "валюта", + "вандал", + "ваниль", + "ванна", + "варенье", + "вариант", + "варьете", + "ватага", + "ватман", + "ваучер", + "вафля", + "вахта", + "ведро", + "ведьма", + "везение", + "веко", + "вексель", + "велеть", + "величие", + "велодром", + "венец", + "вентиль", + "веранда", + "верблюд", + "веревка", + "версия", + "вершина", + "веселье", + "весло", + "весна", + "весть", + "ветвь", + "ветер", + "ветчина", + "веха", + "вещь", + "веяние", + "взбучка", + "взвод", + "взгляд", + "вздох", + "взмах", + "взнос", + "взор", + "взрыв", + "вибрация", + "видение", + "визг", + "визит", + "вилка", + "вирус", + "висеть", + "висок", + "витрина", + "вихрь", + "вкус", + "влага", + "владелец", + "власть", + "влияние", + "внимание", + "внук", + "вобла", + "вода", + "водород", + "вожак", + "возглас", + "воздух", + "возить", + "возраст", + "воин", + "вокзал", + "волк", + "волна", + "волокно", + "воля", + "вопрос", + "ворота", + "восторг", + "вотум", + "вояж", + "врач", + "время", + "всадник", + "всплеск", + "вспышка", + "встреча", + "вторник", + "втулка", + "вулкан", + "вход", + "выбор", + "вывод", + "выгиб", + "выдра", + "выемка", + "вызов", + "выигрыш", + "выкуп", + "вымысел", + "выпечка", + "выпуск", + "вырез", + "выскочка", + "высота", + "выставка", + "вытяжка", + "вычет", + "вышка", + "вьюга", + "вязанка", + "вялый", + "гавань", + "гадать", + "газета", + "газон", + "галерея", + "галоп", + "галстук", + "галун", + "гамак", + "гамбит", + "гандбол", + "гантель", + "гараж", + "гардина", + "гарем", + "гармония", + "гарнир", + "гарпун", + "гвардия", + "гвоздь", + "гегемон", + "гейзер", + "гектар", + "генерал", + "гений", + "геолог", + "гепард", + "гербарий", + "герой", + "герцог", + "гжель", + "гигант", + "гильза", + "гимн", + "гипноз", + "гипотеза", + "гиря", + "гитара", + "глава", + "глагол", + "глаз", + "глина", + "глобус", + "глубина", + "глухой", + "глыба", + "глюкоза", + "глянец", + "гнев", + "гнездо", + "гном", + "гобелен", + "голова", + "голый", + "гомон", + "гондола", + "гонка", + "гора", + "горло", + "город", + "горшок", + "госпожа", + "гость", + "градус", + "грамота", + "грань", + "графа", + "гребень", + "грек", + "гречиха", + "гриб", + "гривна", + "гром", + "грохот", + "грубый", + "грудь", + "груз", + "группа", + "груша", + "грязь", + "губа", + "гудеть", + "гулять", + "гурман", + "гусли", + "густой", + "гусь", + "гуща", + "давать", + "давление", + "давний", + "дамба", + "данные", + "дарить", + "дата", + "датчик", + "дверь", + "движение", + "двойня", + "дворец", + "дебют", + "девочка", + "девушка", + "действие", + "декабрь", + "декорум", + "делить", + "дело", + "дельфин", + "демагог", + "демократ", + "день", + "депеша", + "депутат", + "дерево", + "держава", + "десерт", + "десяток", + "деталь", + "детство", + "дефицит", + "деятель", + "джаз", + "джигит", + "джинсы", + "джунгли", + "диагноз", + "диалог", + "диапазон", + "диафильм", + "диван", + "дивизия", + "диета", + "дизайн", + "дизель", + "дикий", + "дикобраз", + "диктант", + "дилижанс", + "динамика", + "диплом", + "директор", + "диск", + "дисплей", + "дитя", + "дифирамб", + "дичь", + "дневник", + "добавка", + "добро", + "добыча", + "доверие", + "догмат", + "договор", + "дождь", + "доклад", + "доктор", + "документ", + "долг", + "доллар", + "домысел", + "дорога", + "досада", + "доска", + "досье", + "дотация", + "доход", + "доцент", + "доярка", + "драгун", + "драка", + "дремота", + "дрова", + "дрожь", + "друг", + "дружба", + "дубликат", + "дукат", + "дума", + "дупло", + "духовка", + "душа", + "дуэт", + "дыня", + "дыра", + "дыхание", + "дышать", + "дюжина", + "дюйм", + "дюна", + "дядя", + "дятел", + "европа", + "егерь", + "егоза", + "единица", + "едкий", + "ежевика", + "езда", + "ельник", + "емкость", + "енот", + "ералаш", + "ермолка", + "ерунда", + "есаул", + "ехать", + "жабо", + "жажда", + "жалкий", + "жалоба", + "жалюзи", + "жандарм", + "жанр", + "жара", + "жаргон", + "жаровня", + "жатва", + "жбан", + "жгут", + "желание", + "железо", + "желтый", + "жемчуг", + "жених", + "женщина", + "жердь", + "жеребец", + "жерло", + "жест", + "живот", + "жизнь", + "жилет", + "жилье", + "жираф", + "житель", + "жнец", + "жокей", + "жребий", + "журнал", + "жюри", + "забава", + "забег", + "забияка", + "забрало", + "забыть", + "завал", + "завеса", + "завод", + "завтрак", + "завязь", + "загадка", + "заговор", + "задача", + "задел", + "задира", + "задний", + "задор", + "задумка", + "зажим", + "зазывала", + "закат", + "заклад", + "закон", + "залежь", + "залив", + "заметка", + "замок", + "замысел", + "занос", + "занятие", + "запад", + "запись", + "заплыв", + "заповедь", + "запятая", + "зарок", + "зарубка", + "заря", + "засада", + "заслуга", + "заставка", + "затея", + "затор", + "затрата", + "затылок", + "захват", + "зацепка", + "зачаток", + "зачет", + "защита", + "заявка", + "заяц", + "звезда", + "звонок", + "звук", + "здоровье", + "зебра", + "зевака", + "зелень", + "земля", + "зенит", + "зеркало", + "зерно", + "зефир", + "зигзаг", + "зима", + "злоба", + "змея", + "знак", + "знамя", + "знание", + "значение", + "зной", + "зодчий", + "зола", + "золото", + "зоопарк", + "зоркий", + "зрачок", + "зрелище", + "зрение", + "зритель", + "зубило", + "зыбкий", + "зять", + "иволга", + "игла", + "игра", + "идеал", + "идея", + "идиллия", + "идиома", + "идол", + "идти", + "иерархия", + "иероглиф", + "изба", + "известие", + "изгиб", + "издание", + "изделие", + "изотоп", + "изыск", + "изюм", + "иллюзия", + "имбирь", + "имение", + "имидж", + "империя", + "импульс", + "инвестор", + "индекс", + "индивид", + "инерция", + "инженер", + "инжир", + "институт", + "интерес", + "интрига", + "ипподром", + "ирис", + "ирония", + "искать", + "искра", + "испуг", + "истина", + "история", + "истукан", + "исход", + "итог", + "кабаре", + "кабель", + "кабина", + "каблук", + "кавалер", + "кадка", + "кадр", + "кадык", + "казак", + "казино", + "казус", + "кайма", + "кайф", + "какао", + "кактус", + "каламбур", + "калитка", + "калория", + "кальций", + "камбала", + "камень", + "камин", + "камыш", + "канал", + "кандидат", + "канкан", + "каноэ", + "каньон", + "капитал", + "капля", + "капот", + "каприз", + "капсула", + "капуста", + "капюшон", + "карабин", + "карета", + "каркас", + "карман", + "карп", + "картон", + "карьера", + "каскад", + "касторка", + "каталог", + "катер", + "катод", + "каучук", + "кафель", + "качать", + "качество", + "каша", + "кашпо", + "каштан", + "каюта", + "квадрат", + "квант", + "кварц", + "квинтет", + "квиток", + "кворум", + "квота", + "кегли", + "кекс", + "кемпинг", + "кенгуру", + "кепка", + "керосин", + "кетчуп", + "кибитка", + "кивок", + "километр", + "килька", + "кимоно", + "кинжал", + "кино", + "киоск", + "кипеть", + "кипяток", + "кирка", + "кирпич", + "кисель", + "кислота", + "кисть", + "клапан", + "кларнет", + "клевер", + "клерк", + "клетка", + "клиент", + "климат", + "клинок", + "кличка", + "клише", + "клоун", + "клуб", + "клумба", + "клык", + "клюква", + "ключ", + "клюшка", + "клякса", + "клятва", + "кляча", + "книга", + "кнопка", + "кнут", + "князь", + "ковбой", + "ковер", + "ковыль", + "когорта", + "кодекс", + "кожа", + "кожура", + "козел", + "козырь", + "койка", + "койот", + "кокос", + "коктейль", + "колбаса", + "колдун", + "колесо", + "коллаж", + "колодец", + "колпак", + "колхоз", + "кольцо", + "комар", + "комбайн", + "комедия", + "комитет", + "комната", + "компания", + "конверт", + "конгресс", + "кондитер", + "конец", + "конкурс", + "конспект", + "контакт", + "конус", + "конфуз", + "концерт", + "конь", + "копейка", + "копия", + "копна", + "копоть", + "копыто", + "копье", + "корабль", + "корень", + "корзина", + "коридор", + "кормить", + "корнет", + "король", + "корпус", + "коррида", + "корсет", + "космос", + "костюм", + "котел", + "котлета", + "коттедж", + "кофе", + "кофта", + "кочан", + "кошка", + "край", + "краска", + "кредит", + "крекер", + "кремль", + "кресло", + "кривой", + "кризис", + "крик", + "критика", + "кровать", + "кролик", + "крыло", + "крыша", + "крючок", + "кубок", + "кувшин", + "кузен", + "кузнец", + "кузов", + "кукла", + "кулак", + "кулон", + "культура", + "кумир", + "купец", + "купол", + "курица", + "курорт", + "курс", + "куртка", + "кусок", + "куст", + "кухня", + "куча", + "кювет", + "лабиринт", + "лаваш", + "лавина", + "лавка", + "лагерь", + "лагуна", + "ладонь", + "лазер", + "лайнер", + "лакей", + "лампа", + "ландшафт", + "лапоть", + "лапша", + "ларек", + "латунь", + "лауреат", + "лацкан", + "лачуга", + "лаять", + "лебедь", + "легенда", + "лежак", + "лезть", + "лекция", + "лента", + "лепесток", + "леска", + "лестница", + "лететь", + "лето", + "летчик", + "лечение", + "леший", + "лиана", + "либерал", + "ливень", + "ливрея", + "лига", + "лидер", + "лимит", + "лимон", + "линия", + "лирика", + "литр", + "лифт", + "лихой", + "лицей", + "лицо", + "ловить", + "логика", + "лодка", + "лозунг", + "локоть", + "ломать", + "лоно", + "лопата", + "лорд", + "лось", + "лошадь", + "луна", + "лучший", + "лыжа", + "льгота", + "льдина", + "любовь", + "люстра", + "лютня", + "лягушка", + "лямка", + "магазин", + "магия", + "магма", + "мадам", + "майор", + "маклер", + "максимум", + "малыш", + "мальчик", + "маляр", + "мангал", + "мандат", + "манеж", + "мантия", + "марафон", + "март", + "маршал", + "маскарад", + "масло", + "мастер", + "масштаб", + "матадор", + "материя", + "матрос", + "матч", + "мафия", + "махать", + "машина", + "маэстро", + "маяк", + "мебель", + "медаль", + "медведь", + "мелкий", + "мелодия", + "менять", + "мера", + "место", + "месяц", + "металл", + "метеор", + "метла", + "метод", + "метр", + "механизм", + "мечта", + "мешок", + "мизинец", + "микрофон", + "миксер", + "милиция", + "миллион", + "милость", + "милый", + "мимоза", + "министр", + "минута", + "митинг", + "мишень", + "мнение", + "модель", + "модуль", + "мозг", + "молва", + "молния", + "молоко", + "молчать", + "момент", + "монах", + "монета", + "монитор", + "монолог", + "мораль", + "море", + "морковь", + "мороз", + "моряк", + "мост", + "мотив", + "мотор", + "мудрый", + "мужчина", + "музей", + "музыка", + "мундир", + "муравей", + "мусор", + "мустанг", + "муфта", + "муха", + "мушкетер", + "мыло", + "мысль", + "мышь", + "мэтр", + "мюзикл", + "мягкий", + "мякиш", + "мясо", + "мятый", + "набат", + "навар", + "навык", + "наган", + "награда", + "надежда", + "надпись", + "название", + "наитие", + "наличие", + "налог", + "намек", + "напиток", + "напор", + "народ", + "наряд", + "натура", + "наука", + "нация", + "начало", + "наяда", + "небо", + "невеста", + "неделя", + "нейлон", + "нейрон", + "немой", + "неон", + "нерв", + "нести", + "нефть", + "нива", + "низкий", + "никель", + "нирвана", + "нитка", + "нить", + "ничья", + "ниша", + "новация", + "новелла", + "новость", + "нога", + "ноготь", + "ноздря", + "номер", + "норма", + "носок", + "нота", + "ночлег", + "ночь", + "ноябрь", + "нрав", + "нужда", + "нужный", + "нюанс", + "няня", + "оазис", + "обаяние", + "обвод", + "обед", + "обелиск", + "обещать", + "обзор", + "обида", + "облако", + "облик", + "обломок", + "обман", + "обморок", + "оборот", + "обочина", + "образ", + "обруч", + "обрыв", + "обувь", + "обучение", + "обхват", + "общение", + "объект", + "объятие", + "обычай", + "овес", + "овощ", + "овраг", + "овца", + "овчарка", + "огонь", + "ограда", + "огурец", + "одежда", + "одеяло", + "ожидание", + "ожог", + "озеро", + "океан", + "окно", + "окоп", + "окорок", + "окраина", + "округ", + "октава", + "октябрь", + "олень", + "олимп", + "опека", + "операция", + "описание", + "оплата", + "опора", + "оппонент", + "оправа", + "оптика", + "опыт", + "орбита", + "орган", + "орден", + "орел", + "оригинал", + "ориентир", + "оркестр", + "орнамент", + "оружие", + "осадок", + "осень", + "осина", + "осколок", + "осмотр", + "основа", + "особняк", + "осока", + "остаток", + "остров", + "отбор", + "ответ", + "отдача", + "отдел", + "отдых", + "отель", + "отец", + "отзыв", + "отказ", + "открытие", + "откуп", + "отличие", + "отпуск", + "отрасль", + "отряд", + "отсев", + "оттенок", + "отчет", + "отшиб", + "отъезд", + "офис", + "офицер", + "охапка", + "охота", + "охрана", + "оценка", + "очаг", + "очерк", + "очки", + "ошейник", + "ошибка", + "павильон", + "павлин", + "падение", + "паек", + "пакля", + "пакт", + "палата", + "палец", + "палуба", + "пальто", + "памфлет", + "память", + "панель", + "паника", + "парафин", + "парень", + "парк", + "пароход", + "партия", + "парус", + "пасека", + "паспорт", + "пастух", + "патрон", + "пауза", + "пафос", + "пахарь", + "пацан", + "пациент", + "певец", + "педагог", + "пейзаж", + "пельмень", + "пена", + "пенсия", + "пепел", + "перец", + "период", + "перо", + "персонаж", + "песня", + "песок", + "петля", + "петух", + "петь", + "пехота", + "печать", + "печень", + "пешеход", + "пешка", + "пещера", + "пианист", + "пиво", + "пиджак", + "пила", + "пилот", + "пионер", + "писатель", + "письмо", + "питание", + "пицца", + "пища", + "плагиат", + "плакат", + "план", + "платье", + "плац", + "пленка", + "плечо", + "плита", + "плод", + "площадь", + "плыть", + "плюс", + "пляж", + "победа", + "повар", + "повесть", + "повод", + "повтор", + "повязка", + "погода", + "подарок", + "подвиг", + "поднос", + "подпись", + "подруга", + "подушка", + "подход", + "подъем", + "поезд", + "позиция", + "поиск", + "покер", + "поклажа", + "покой", + "покупка", + "полдень", + "поле", + "политик", + "полный", + "полоса", + "получка", + "полынь", + "польза", + "поляна", + "пометка", + "помощь", + "помпон", + "пони", + "понятие", + "попытка", + "порог", + "портрет", + "порция", + "порыв", + "порядок", + "посадка", + "поселок", + "посох", + "постель", + "посуда", + "потеря", + "поток", + "походка", + "поцелуй", + "почва", + "поэзия", + "поэт", + "пояс", + "правда", + "праздник", + "практик", + "преграда", + "предел", + "презент", + "премия", + "препарат", + "прибор", + "привет", + "прием", + "призыв", + "приказ", + "приличие", + "пример", + "принц", + "природа", + "приступ", + "прицел", + "причина", + "приятель", + "пробка", + "провал", + "прогноз", + "продукт", + "проект", + "проза", + "прокурор", + "пропуск", + "простор", + "протеже", + "процент", + "прочерк", + "прошлое", + "пруд", + "прыжок", + "прялка", + "прямота", + "психика", + "птица", + "публика", + "пугать", + "пудра", + "пузырь", + "пульт", + "пуля", + "пункт", + "пунш", + "пурга", + "пустяк", + "путь", + "пухлый", + "пчела", + "пшеница", + "пыль", + "пышный", + "пьеса", + "пятно", + "работа", + "радар", + "раджа", + "радио", + "радость", + "радуга", + "развитие", + "разговор", + "раздел", + "разлив", + "размер", + "разница", + "разряд", + "разум", + "район", + "ракета", + "ракушка", + "рама", + "рандеву", + "рантье", + "ранчо", + "рапира", + "рапорт", + "раритет", + "раскат", + "расписка", + "рассвет", + "раствор", + "расход", + "расчет", + "ратуша", + "раунд", + "рация", + "реакция", + "реализм", + "ребенок", + "ребро", + "ребус", + "ревизор", + "регион", + "редис", + "реестр", + "режим", + "резак", + "рейтинг", + "река", + "реклама", + "ректор", + "рельс", + "ремарка", + "ремень", + "ремонт", + "реноме", + "рента", + "реплика", + "ресница", + "ресторан", + "ресурс", + "реформа", + "рецепт", + "речь", + "решение", + "ржавчина", + "рикша", + "риск", + "рисунок", + "ритм", + "рифма", + "робкий", + "родео", + "родина", + "рождение", + "роман", + "рост", + "росчерк", + "рота", + "рояль", + "рубашка", + "рубеж", + "рубль", + "рубрика", + "ругать", + "рудник", + "ружье", + "руины", + "рука", + "рулет", + "рупор", + "ручей", + "рыба", + "рыжий", + "рынок", + "рысь", + "рыцарь", + "рычаг", + "рюкзак", + "рюмка", + "рябина", + "сабля", + "сазан", + "сайгак", + "саксаул", + "сальто", + "самолет", + "самурай", + "сандвич", + "сани", + "сапог", + "сапфир", + "сарай", + "сарказм", + "сатира", + "сауна", + "сахар", + "сбруя", + "сбыт", + "свадьба", + "свежий", + "сверло", + "свеча", + "свидание", + "свист", + "свобода", + "свойство", + "связь", + "сделка", + "сеанс", + "сегмент", + "седина", + "седло", + "сезон", + "сейф", + "секрет", + "секунда", + "селение", + "семафор", + "семинар", + "семья", + "сено", + "сентябрь", + "сервис", + "сердце", + "середина", + "сержант", + "серия", + "серьга", + "сестра", + "сеть", + "сигара", + "сигнал", + "сиденье", + "сила", + "символ", + "симптом", + "синева", + "сирень", + "сирота", + "система", + "ситец", + "ситуация", + "сиять", + "сказка", + "скакун", + "скала", + "скамья", + "скачок", + "скважина", + "сквер", + "скворец", + "скелет", + "скидка", + "склад", + "скрепа", + "скрипка", + "скука", + "слабый", + "слава", + "след", + "слеза", + "слияние", + "слово", + "слон", + "служба", + "слух", + "случай", + "смена", + "смесь", + "смех", + "смола", + "смысл", + "смычок", + "смятение", + "снег", + "снимок", + "собака", + "собрание", + "событие", + "совет", + "сокол", + "солдат", + "солнце", + "соловей", + "соль", + "соната", + "соперник", + "сопка", + "сорт", + "сосед", + "сосна", + "состав", + "сосуд", + "соус", + "социолог", + "союз", + "спальня", + "спать", + "спина", + "список", + "спичка", + "спор", + "способ", + "справка", + "спутник", + "среда", + "ставка", + "стадо", + "стакан", + "сталкер", + "станция", + "старик", + "статус", + "стая", + "ствол", + "стекло", + "стена", + "степь", + "стиль", + "стихи", + "стойка", + "столица", + "стон", + "сторона", + "стоянка", + "страна", + "стрела", + "строка", + "струя", + "студия", + "стук", + "ступень", + "стыд", + "стюард", + "стяжка", + "суббота", + "субъект", + "сувенир", + "сугроб", + "судно", + "судья", + "суета", + "сумка", + "супруг", + "суть", + "сухой", + "суша", + "сфера", + "схема", + "счастье", + "счет", + "съезд", + "съемка", + "сырой", + "сырье", + "сытый", + "сыщик", + "сюжет", + "сюрприз", + "сюртук", + "табак", + "табель", + "таблица", + "табун", + "тайна", + "тайфун", + "такси", + "талант", + "талон", + "таможня", + "танец", + "танк", + "танцор", + "тарелка", + "тариф", + "творог", + "театр", + "тезис", + "текст", + "телега", + "темнота", + "темп", + "тень", + "теория", + "тепло", + "терапия", + "термин", + "терять", + "тесный", + "тетрадь", + "тетя", + "техника", + "течение", + "тигр", + "тираж", + "титул", + "тишина", + "ткань", + "товар", + "токарь", + "толк", + "толпа", + "толчок", + "тонкий", + "тонна", + "топливо", + "топор", + "торговля", + "тостер", + "точка", + "тощий", + "трава", + "традиция", + "трактор", + "трамвай", + "траншея", + "тревога", + "треск", + "трещина", + "трибуна", + "тройка", + "тропа", + "тротуар", + "труба", + "труд", + "трюк", + "тряпка", + "трясти", + "туман", + "тундра", + "тупик", + "турист", + "турнир", + "туфля", + "туча", + "тюльпан", + "тяга", + "тяжесть", + "тянуть", + "уважение", + "угол", + "удав", + "удаль", + "удар", + "удача", + "ужин", + "узел", + "узкий", + "узор", + "указ", + "уклон", + "уксус", + "улица", + "улыбка", + "умение", + "умный", + "умысел", + "унция", + "уплата", + "уран", + "урна", + "уровень", + "урок", + "усадьба", + "усердие", + "усилие", + "условие", + "услуга", + "усмешка", + "успех", + "устав", + "утка", + "утро", + "утюг", + "уход", + "участок", + "учеба", + "ученик", + "училище", + "учитель", + "ушко", + "ущерб", + "уютный", + "фабрика", + "фабула", + "фаворит", + "файл", + "факел", + "факт", + "фамилия", + "фантазия", + "фара", + "фасад", + "фаянс", + "февраль", + "феерия", + "фельетон", + "феномен", + "феодал", + "ферзь", + "фигура", + "физика", + "философ", + "фильм", + "финал", + "фишка", + "флаг", + "флейта", + "флора", + "флот", + "флюгер", + "фокус", + "фольклор", + "фонарь", + "фонд", + "фонтан", + "форма", + "фосфор", + "фото", + "фраза", + "фреска", + "фронт", + "фрукт", + "функция", + "фуражка", + "футбол", + "халат", + "хаос", + "характер", + "хата", + "хвала", + "хвост", + "хижина", + "химера", + "химия", + "хирург", + "хищник", + "хлам", + "хлеб", + "хлопок", + "хмурый", + "хобот", + "хозяин", + "хоккей", + "холм", + "холод", + "хохот", + "хребет", + "хроника", + "худоба", + "хулиган", + "хурма", + "хутор", + "цапля", + "царство", + "царь", + "цвет", + "целина", + "цемент", + "цена", + "центр", + "цепь", + "цикада", + "цикл", + "цилиндр", + "цинк", + "цирк", + "цистерна", + "цитата", + "цифра", + "цокот", + "цыпленок", + "чабан", + "чадо", + "чайник", + "чародей", + "часы", + "чашка", + "челнок", + "человек", + "чемодан", + "чепуха", + "черника", + "черта", + "чеснок", + "честь", + "четкий", + "чехол", + "чиновник", + "число", + "чистота", + "читатель", + "чтение", + "чувство", + "чудак", + "чудо", + "чулок", + "чучело", + "шаблон", + "шайба", + "шалаш", + "шалфей", + "шампунь", + "шанс", + "шапка", + "шатер", + "шахта", + "шашлык", + "шедевр", + "шепот", + "шерсть", + "шинель", + "шить", + "шкаф", + "школа", + "шкура", + "шланг", + "шлем", + "шлюпка", + "шляпа", + "шнур", + "шоколад", + "шорох", + "шофер", + "шпага", + "шпион", + "шрифт", + "штаб", + "штат", + "штора", + "штраф", + "штурман", + "штык", + "шуба", + "эволюция", + "эгоизм", + "экзамен", + "экипаж", + "экология", + "экран", + "эксперт", + "элемент", + "элита", + "эмблема", + "эмоция", + "энергия", + "эпатаж", + "эпизод", + "эпоха", + "эрудит", + "эскиз", + "эстрада", + "этаж", + "этика", + "этюд", + "эфир", + "эффект", + "эшелон", + "юбилей", + "юбка", + "юмор", + "юнга", + "юность", + "юноша", + "юрист", + "юрта", + "яблоко", + "явление", + "ягода", + "ягуар", + "ядро", + "язык", + "яйцо", + "якорь", + "январь", + "яркий", + "ярмарка", + "ярость", + "ярус", + "ясный", + "ястреб", + "яхта", + "ячейка", + "ячмень", + "ящерица", + "ящик" + } + }; + + const dictionary uk = + { + { + "абетка", + "або", + "абонент", + "абрикос", + "аванс", + "аварія", + "автор", + "авіація", + "агент", + "аграрій", + "агрегат", + "агітатор", + "адаптер", + "адвокат", + "адже", + "адмірал", + "адреса", + "азарт", + "азбест", + "азбука", + "азот", + "акація", + "акорд", + "акрил", + "акробат", + "аксіома", + "акт", + "актив", + "актор", + "актриса", + "акула", + "акцент", + "акція", + "алгебра", + "алгоритм", + "але", + "алергія", + "алея", + "алича", + "алмаз", + "альбом", + "альфа", + "альянс", + "амеба", + "ампер", + "аналіз", + "ананас", + "анархія", + "ангел", + "антена", + "антонім", + "апельсин", + "аптека", + "арбітр", + "арена", + "арка", + "аркуш", + "армія", + "аромат", + "арсенал", + "архів", + "асистент", + "аспект", + "астма", + "асфальт", + "атака", + "атестат", + "атлас", + "атом", + "атрибут", + "аудит", + "аудіо", + "аукціон", + "афіша", + "аіст", + "баба", + "бабуся", + "бавовна", + "багаж", + "бажання", + "базар", + "базіка", + "байка", + "бал", + "балада", + "балет", + "бали", + "балон", + "бампер", + "банан", + "банда", + "банер", + "банк", + "барабан", + "барва", + "барон", + "басейн", + "батарея", + "батько", + "батіг", + "бачення", + "баян", + "бджола", + "без", + "безлад", + "безпека", + "бекон", + "бензин", + "берег", + "бесіда", + "бетон", + "бик", + "бинт", + "благо", + "ближче", + "близнюк", + "блиск", + "блогер", + "блок", + "блондин", + "блукати", + "блюдо", + "блюз", + "блідий", + "бобер", + "боби", + "бовдур", + "богатир", + "бокс", + "болт", + "бомба", + "бондар", + "бонус", + "борг", + "борода", + "борщ", + "боулінг", + "боєць", + "брага", + "браслет", + "брат", + "бренд", + "брехня", + "бринза", + "брови", + "брокер", + "броня", + "брошура", + "брудно", + "брід", + "бугор", + "буде", + "будинок", + "будка", + "будні", + "будова", + "будівля", + "бузина", + "бузок", + "буйвіл", + "букет", + "булава", + "було", + "бульба", + "бункер", + "бунт", + "бунчук", + "бур", + "буряк", + "буріння", + "бути", + "бутон", + "буфет", + "бухта", + "бюджет", + "бюро", + "біблія", + "бігун", + "бізнес", + "бій", + "бік", + "бікіні", + "білий", + "білка", + "більше", + "бінго", + "біологія", + "бісер", + "вага", + "вагон", + "важко", + "важливо", + "вакуум", + "вакцина", + "валовий", + "валун", + "валюта", + "ванна", + "вантаж", + "ваніль", + "вапно", + "варан", + "варення", + "варта", + "варіант", + "ватра", + "вважати", + "вгору", + "вдова", + "вдячний", + "ведмідь", + "вежа", + "великий", + "верба", + "верес", + "версія", + "верхній", + "вершник", + "веселий", + "весна", + "весілля", + "ветеран", + "вечеря", + "вечір", + "вживати", + "взуття", + "взяти", + "вибачте", + "вибори", + "вибрати", + "вибух", + "вибір", + "вигадка", + "вигляд", + "вигода", + "виграш", + "вид", + "видання", + "видимий", + "визнати", + "виклик", + "викуп", + "вилазка", + "вилка", + "вимога", + "винахід", + "винний", + "вино", + "виняток", + "випадок", + "виплата", + "випічка", + "вираз", + "вирок", + "виручка", + "виріс", + "висновок", + "висота", + "витвір", + "витрата", + "витік", + "вихід", + "вишня", + "вище", + "вищий", + "виїзд", + "вказати", + "вкладка", + "включно", + "влада", + "власник", + "влучати", + "вмикач", + "вміння", + "вміщати", + "внесок", + "вниз", + "вночі", + "вовк", + "вовна", + "вогнище", + "вогонь", + "вода", + "водень", + "водний", + "водій", + "вокал", + "волога", + "вольт", + "воля", + "ворог", + "воїн", + "вперше", + "вплив", + "враження", + "врода", + "врожай", + "все", + "всесвіт", + "вставка", + "всюди", + "втеча", + "втома", + "втрата", + "вугляр", + "вуж", + "вузол", + "вузький", + "вулиця", + "вухо", + "вхід", + "вчений", + "вчинок", + "вчитель", + "вчора", + "вщент", + "вівця", + "відбір", + "відвага", + "відгук", + "відділ", + "відео", + "відмова", + "відомий", + "відсоток", + "відчути", + "відьма", + "віз", + "візит", + "візок", + "військо", + "вікно", + "вікінг", + "вініл", + "вірус", + "вірш", + "вісник", + "вісті", + "вісь", + "вісім", + "вітання", + "вітер", + "вітрило", + "вічний", + "вішати", + "гавань", + "гадати", + "гаджет", + "гадюка", + "газета", + "газон", + "галера", + "галузь", + "гальма", + "гамак", + "ганьба", + "гараж", + "гарбуз", + "гармата", + "гарний", + "гарячо", + "гасло", + "гвардія", + "гвинт", + "гель", + "генерал", + "гени", + "геном", + "генсека", + "геній", + "гепард", + "герой", + "герцог", + "гетьман", + "гладкий", + "глибина", + "глина", + "глузд", + "глухий", + "глюкоза", + "глядач", + "гном", + "гнів", + "гніздо", + "година", + "голий", + "голка", + "голос", + "гончар", + "гопак", + "гора", + "гордий", + "горила", + "горло", + "гормон", + "горобець", + "горщик", + "горіх", + "гострий", + "готель", + "готовий", + "гравець", + "грамота", + "грант", + "грати", + "граф", + "гребля", + "гриб", + "гриль", + "громада", + "гроші", + "грубо", + "груди", + "груша", + "гріх", + "губа", + "гукати", + "гурман", + "гурт", + "гуру", + "гібрид", + "гігант", + "гігієна", + "гілка", + "гірко", + "гість", + "гітара", + "дайвінг", + "далеко", + "далі", + "даремно", + "дарма", + "датчик", + "дах", + "дбати", + "два", + "двері", + "двигун", + "двір", + "двічі", + "дебати", + "дебют", + "декан", + "дельта", + "день", + "депо", + "дерево", + "держава", + "десять", + "дефект", + "дефолт", + "дефіцит", + "децибел", + "дещо", + "джаз", + "джем", + "джерело", + "джинси", + "джип", + "джоуль", + "джунглі", + "дзвін", + "дзеркало", + "диван", + "дивний", + "диво", + "дивізія", + "дизайн", + "дизель", + "дикий", + "дикун", + "дим", + "димар", + "динамік", + "диня", + "диплом", + "диск", + "дисплей", + "дитина", + "дитя", + "дно", + "доба", + "добро", + "довго", + "довжина", + "довше", + "довіра", + "договір", + "додаток", + "дозвіл", + "доказ", + "доктор", + "документ", + "долар", + "долина", + "домашня", + "домен", + "домкрат", + "донор", + "донька", + "дорога", + "доріжка", + "досада", + "досвід", + "досить", + "доступ", + "досягти", + "дотик", + "доходи", + "дохід", + "дошка", + "дощ", + "драбина", + "дракон", + "драма", + "друг", + "дружба", + "друк", + "дріт", + "дуб", + "дуель", + "дуже", + "думати", + "думка", + "дурний", + "душа", + "дюжина", + "дюйм", + "дядько", + "дякувати", + "дятел", + "діабет", + "діагноз", + "діалог", + "діамант", + "діва", + "дівка", + "дівчина", + "дід", + "дідусь", + "дійсно", + "ділянка", + "діти", + "дієвий", + "дієта", + "екватор", + "екзамен", + "екзотика", + "екологія", + "екран", + "екскурс", + "експерт", + "екстра", + "екіпаж", + "електрон", + "елемент", + "ельф", + "еліксир", + "еліпс", + "еліта", + "емаль", + "емоція", + "емперія", + "емульсія", + "емісія", + "енергія", + "епос", + "епоха", + "епіграф", + "епізод", + "епілог", + "епітет", + "епічний", + "ера", + "ерозія", + "ерудит", + "ескорт", + "ескімо", + "естет", + "етап", + "етика", + "етичний", + "етнос", + "етюд", + "ефект", + "ефір", + "ешелон", + "жаба", + "жага", + "жакет", + "жало", + "жаль", + "жанр", + "жар", + "жарт", + "жати", + "жах", + "жебрак", + "желе", + "жереб", + "жертва", + "жива", + "живий", + "живо", + "живіт", + "жила", + "жим", + "жир", + "житель", + "жити", + "житло", + "жито", + "життя", + "жмут", + "жовтий", + "жовч", + "жолоб", + "жуйка", + "журба", + "журнал", + "журі", + "жінка", + "забава", + "забутий", + "завада", + "завжди", + "завод", + "завтра", + "загар", + "загроза", + "задача", + "задній", + "зазнати", + "зазор", + "зайнято", + "заклик", + "закон", + "зал", + "залишок", + "залізо", + "замок", + "заміна", + "запаси", + "запис", + "заповіт", + "запуск", + "зараз", + "зарядка", + "заслуга", + "заспів", + "застава", + "засіб", + "затока", + "захист", + "захід", + "заявник", + "заєць", + "збирати", + "збиток", + "збори", + "зброя", + "збір", + "звалище", + "званий", + "звичка", + "звук", + "звід", + "згадка", + "згинати", + "згодом", + "зграя", + "згідно", + "здавати", + "здатний", + "здобути", + "зелений", + "земля", + "зерно", + "зима", + "зимно", + "злам", + "злива", + "злий", + "зло", + "злодій", + "злочин", + "змагання", + "зміна", + "зміст", + "змія", + "знайти", + "знання", + "значно", + "знижка", + "знову", + "знімок", + "зозуля", + "зокрема", + "золото", + "зоопарк", + "зоря", + "зошит", + "зрада", + "зразок", + "зручний", + "зрілий", + "зсув", + "зупинка", + "зустріч", + "зібрання", + "зір", + "зірка", + "йогурт", + "йод", + "йти", + "кабель", + "каблук", + "кабіна", + "кава", + "кавун", + "кадр", + "кажан", + "казати", + "казино", + "казка", + "калина", + "калорія", + "кальцій", + "камера", + "кампус", + "камінь", + "канат", + "канон", + "канцлер", + "каньйон", + "капелюх", + "каплиця", + "капот", + "капсула", + "капуста", + "капці", + "капітан", + "карабін", + "карп", + "карта", + "касета", + "катання", + "катер", + "католик", + "кафе", + "квадрат", + "квант", + "квартира", + "квасоля", + "квиток", + "квітка", + "кедр", + "келих", + "кемпінг", + "кермо", + "кетяг", + "кефір", + "кидати", + "кийок", + "килим", + "кисень", + "кислота", + "кицька", + "клавіша", + "клапан", + "клас", + "клен", + "клуб", + "ключ", + "клімат", + "клініка", + "кліп", + "кліринг", + "клітина", + "клієнт", + "книга", + "кнопка", + "князь", + "кобза", + "коваль", + "ковбой", + "ковдра", + "код", + "кодекс", + "кожен", + "кожух", + "козак", + "козел", + "колесо", + "колиска", + "коло", + "кольчуга", + "колядка", + "колір", + "комар", + "комедія", + "комфорт", + "комікс", + "конгрес", + "конкурс", + "консул", + "контакт", + "концерт", + "конюх", + "копати", + "копія", + "корабель", + "кордон", + "коридор", + "корова", + "корпус", + "корінь", + "коса", + "костюм", + "котедж", + "котрий", + "кохання", + "кошеня", + "кошик", + "кошти", + "краватка", + "крадій", + "край", + "крамниця", + "крапля", + "краса", + "кратер", + "краще", + "країна", + "кредит", + "крем", + "крига", + "крило", + "кришка", + "крок", + "кролик", + "круглий", + "крізь", + "кулак", + "культ", + "куля", + "купець", + "купол", + "купівля", + "курага", + "курка", + "курорт", + "курс", + "кут", + "кухар", + "кухня", + "кущ", + "кільце", + "кімната", + "кінець", + "кінь", + "кістка", + "кіт", + "кітель", + "кішка", + "лава", + "лавина", + "лагуна", + "лагідно", + "лад", + "лазер", + "лазур", + "лазівка", + "лайка", + "лама", + "лампа", + "ланка", + "лантух", + "ланцюг", + "лань", + "лапки", + "ласка", + "ласо", + "ласти", + "лати", + "латка", + "латунь", + "лебідь", + "лев", + "легенда", + "легко", + "легіон", + "ледачий", + "ледве", + "леді", + "лезо", + "лексика", + "лектор", + "лекція", + "лелека", + "лема", + "лепеха", + "лижа", + "лижня", + "лимон", + "липа", + "липень", + "липкий", + "лис", + "лисий", + "лист", + "лихо", + "лицар", + "лице", + "лишок", + "ловець", + "логотип", + "логіка", + "лоза", + "лозина", + "локатор", + "лом", + "лопата", + "лопух", + "лосось", + "лось", + "лотерея", + "лото", + "лоша", + "лощина", + "луна", + "лунка", + "лупа", + "любов", + "люди", + "людно", + "людство", + "люк", + "люкс", + "люлька", + "люстра", + "лютий", + "ляда", + "лякати", + "лялька", + "ляпас", + "ліана", + "лівий", + "лівша", + "ліга", + "лідер", + "ліжко", + "лізти", + "лійка", + "лікар", + "лікер", + "ліки", + "лікоть", + "ліліпут", + "лімфа", + "ліміт", + "лінгвіст", + "лінза", + "лінощі", + "лінія", + "ліпше", + "ліра", + "лірика", + "лірник", + "ліс", + "лісовик", + "літак", + "літера", + "літній", + "літо", + "ліфт", + "ліхтар", + "ліцей", + "лічба", + "мабуть", + "магазин", + "магніт", + "магія", + "мазь", + "майно", + "мак", + "макіяж", + "малеча", + "малюнок", + "маляр", + "мама", + "мамонт", + "мандри", + "манера", + "манікюр", + "марафон", + "маркер", + "мармур", + "марш", + "масив", + "маска", + "масло", + "материк", + "мати", + "матовий", + "матрос", + "матуся", + "машина", + "меблі", + "мед", + "медаль", + "медик", + "медіана", + "межа", + "мелодія", + "мельник", + "менше", + "меню", + "мережа", + "мета", + "метелик", + "метод", + "метро", + "меч", + "мийка", + "милий", + "мило", + "милість", + "минуле", + "мирно", + "митний", + "миттєво", + "мить", + "млин", + "мова", + "модем", + "можливо", + "мозок", + "мокро", + "молитва", + "молоко", + "момент", + "монах", + "монета", + "моно", + "монтаж", + "монумент", + "монітор", + "морква", + "мороз", + "мотузка", + "мох", + "мрія", + "мудрий", + "мужність", + "музей", + "музика", + "мураха", + "мури", + "мустанг", + "муха", + "мідь", + "мікроб", + "міксер", + "мільйон", + "мінерал", + "мінус", + "міністр", + "міра", + "міст", + "місяць", + "місія", + "міф", + "міхур", + "міцний", + "мішень", + "мішок", + "набрати", + "набути", + "навички", + "навколо", + "навпаки", + "навряд", + "навіть", + "нагляд", + "нагота", + "надія", + "назад", + "назва", + "накидка", + "належно", + "намет", + "намисто", + "намір", + "напевно", + "напрям", + "напій", + "наразi", + "народ", + "насос", + "наступ", + "насіння", + "натовп", + "натрій", + "натяк", + "наука", + "нафта", + "нахаба", + "нахил", + "начерк", + "небо", + "негайно", + "неділя", + "нежить", + "нейлон", + "немовля", + "неон", + "нерв", + "нести", + "нижче", + "низький", + "нині", + "нитка", + "новий", + "нога", + "ножиці", + "номер", + "норма", + "носій", + "нотатки", + "ноти", + "ньютон", + "нюх", + "нянька", + "ніж", + "ніжний", + "нікель", + "ніколи", + "німий", + "нічна", + "нічого", + "оазис", + "обачно", + "оберт", + "область", + "облік", + "обмін", + "оборот", + "образ", + "обрив", + "обробка", + "обсяг", + "обух", + "обід", + "овації", + "овес", + "овоч", + "огляд", + "огірок", + "один", + "однак", + "одяг", + "ожина", + "озеро", + "ознака", + "озноб", + "озон", + "оказія", + "океан", + "око", + "окремо", + "оксамит", + "окуляри", + "окунь", + "олень", + "олівець", + "олія", + "омана", + "омар", + "омела", + "опади", + "опера", + "опис", + "оплата", + "оптика", + "оптом", + "опікун", + "опір", + "орбіта", + "орган", + "орден", + "орел", + "оренда", + "оркестр", + "освіта", + "оселя", + "основа", + "особа", + "острів", + "осідати", + "осінь", + "отаман", + "отара", + "отвір", + "отже", + "отрута", + "офіс", + "офіцер", + "охорона", + "охоче", + "оцінка", + "очерет", + "очі", + "павук", + "пагорб", + "пазли", + "пакет", + "палац", + "палець", + "паливо", + "палуба", + "пальто", + "паляниця", + "палітра", + "пан", + "панчоха", + "папаха", + "папір", + "парад", + "парк", + "паром", + "партія", + "пасажир", + "пасивна", + "паспорт", + "паста", + "пасіка", + "патруль", + "пацюк", + "пацієнт", + "певно", + "пейзаж", + "пекар", + "пензель", + "перець", + "перо", + "персона", + "перукар", + "перший", + "період", + "пес", + "петля", + "печера", + "печиво", + "печінка", + "пильний", + "пиріг", + "писар", + "питань", + "плавати", + "плазма", + "плакат", + "план", + "пластик", + "плече", + "плита", + "площа", + "плюс", + "пляж", + "пляма", + "поблизу", + "повага", + "поверхня", + "повинен", + "повний", + "поворот", + "повінь", + "погано", + "погляд", + "погода", + "подача", + "подвиг", + "подорож", + "подруга", + "подушка", + "подяка", + "подія", + "поезія", + "поема", + "позика", + "покупка", + "поле", + "полотно", + "полуниця", + "полюс", + "політ", + "помідор", + "понад", + "поняття", + "поні", + "попит", + "попіл", + "порада", + "порив", + "порох", + "портал", + "поруч", + "порція", + "порядно", + "посадка", + "посилка", + "послуга", + "посмішка", + "посол", + "постіль", + "посуд", + "посібник", + "потреба", + "потужно", + "потяг", + "потік", + "почати", + "почуття", + "пошта", + "пошук", + "поява", + "пояс", + "право", + "прагне", + "пральня", + "прапор", + "праска", + "праця", + "предмет", + "премія", + "преса", + "прибій", + "привид", + "пригода", + "приз", + "прийом", + "прилад", + "принц", + "природа", + "присмак", + "приток", + "причеп", + "пробка", + "провал", + "прогрес", + "продаж", + "проект", + "прокат", + "проліт", + "промінь", + "пророк", + "просто", + "проти", + "профі", + "прохід", + "процес", + "проїзд", + "пряжа", + "прямий", + "прірва", + "птах", + "птиця", + "пузо", + "пульс", + "пункт", + "пустеля", + "путь", + "пшениця", + "пшоно", + "піаніно", + "південь", + "півень", + "північ", + "пігулка", + "підвал", + "підйом", + "підлога", + "підошва", + "підпис", + "підхід", + "пізно", + "пікнік", + "пілот", + "пільги", + "піна", + "пінгвін", + "піонер", + "пірат", + "пісня ", + "пітон", + "піч", + "пішки", + "равлик", + "радар", + "радий", + "радник", + "радіо", + "разом", + "рай", + "ракета", + "рамка", + "ранг", + "ранок", + "ранчо", + "раніше", + "раптом", + "рахунок", + "реалізм", + "ребро", + "регіон", + "редакція", + "режим", + "резерв", + "резюме", + "рейс", + "рельс", + "ремонт", + "ремінь", + "ресурс", + "рецепт", + "речі", + "решта", + "риба", + "ризик", + "рис", + "ритм", + "родичі", + "розвал", + "розгін", + "розділ", + "розкол", + "розмір", + "розпад", + "розрив", + "розум", + "ролик", + "роль", + "рости", + "рот", + "рояль", + "рубін", + "рулон", + "руно", + "рута", + "рутина", + "рух", + "ручний", + "рушник", + "рюкзак", + "ряд", + "рядок", + "рятувати", + "рідина", + "рідко", + "рідне", + "ріжок", + "різати", + "різдво", + "різке", + "рік", + "ріпа", + "річка", + "садок", + "сажа", + "сазан", + "салат", + "сало", + "сапсан", + "сапфір", + "сарай", + "сатин", + "сафарі", + "свиня", + "свобода", + "свято", + "свідок", + "свіжий", + "світ", + "свічка", + "седан", + "сезон", + "секрет", + "сектор", + "секунда", + "селище", + "сенат", + "сенс", + "сервер", + "сержант", + "серп", + "серце", + "серія", + "сестра", + "сигнал", + "сидіти", + "сила", + "сильно", + "символ", + "синиця", + "синтез", + "синій", + "сир", + "система", + "сито", + "сканер", + "скарб", + "сквер", + "склад", + "скло", + "скриня", + "скіфи", + "слава", + "слайд", + "слива", + "слово", + "слон", + "слух", + "сльоза", + "слід", + "сліпий", + "смак", + "смачно", + "смерека", + "смуга", + "сміх", + "сніг", + "собака", + "собор", + "сова", + "сокира", + "сокіл", + "солдат", + "сон", + "сонце", + "соняшник", + "сопілка", + "сором", + "сорт", + "сосна", + "сотня", + "соус", + "союз", + "спадщина", + "спалах", + "спам", + "спека", + "список", + "сплав", + "спогад", + "спокій", + "спорт", + "справа", + "спрей", + "сприяти", + "спроба", + "спуск", + "спів", + "спільно", + "срібло", + "ставок", + "стажист", + "стан", + "старт", + "стать", + "стебло", + "стежка", + "стеля", + "стенд", + "стерео", + "стиль", + "стимул", + "сто", + "стовп", + "сторож", + "стояти", + "страх", + "стрес", + "стрибок", + "строго", + "стрічка", + "студія", + "ступа", + "стяг", + "стіл", + "стіна", + "субота", + "суд", + "суддя", + "судно", + "сукня", + "сума", + "сумнів", + "суміш", + "супер", + "сусід", + "сухий", + "сфера", + "схема", + "схил", + "сходи", + "сцена", + "сьомий", + "сюжет", + "сяйво", + "сідло", + "сік", + "сіль", + "сім", + "сіно", + "сірий", + "січень", + "табель", + "табло", + "табун", + "табір", + "таймер", + "таким", + "також", + "таксі", + "такт", + "талант", + "талія", + "там", + "танго", + "танець", + "танк", + "танок", + "таран", + "тарган", + "тариф", + "тато", + "тату", + "тварина", + "твердо", + "творець", + "твій", + "театр", + "тебе", + "текст", + "телефон", + "теля", + "тема", + "тембр", + "темп", + "темрява", + "темінь", + "тендер", + "теніс", + "теорія", + "тепло", + "тераса", + "термін", + "терор", + "тест", + "технік", + "теча", + "теща", + "тигр", + "тиждень", + "тип", + "типово", + "тираж", + "тире", + "тиск", + "тисяча", + "титан", + "титул", + "тихий", + "тиша", + "тобто", + "товар", + "товкач", + "товща", + "той", + "токар", + "токсин", + "толк", + "томат", + "тому", + "тонкий", + "тонна", + "тонус", + "топка", + "тополя", + "торба", + "торги", + "торф", + "тост", + "точка", + "точно", + "трава", + "тракт", + "трамвай", + "транс", + "трап", + "тренер", + "третій", + "три", + "тримати", + "триста", + "троль", + "трос", + "тротуар", + "трохи", + "троянда", + "труба", + "трюк", + "трійка", + "тріумф", + "туалет", + "тулуб", + "туман", + "тундра", + "тунель", + "турбіна", + "турист", + "турнір", + "тюльпан", + "тютюн", + "тягар", + "тягне", + "тіло", + "тільки", + "тінь", + "тісно", + "тісто", + "тітка", + "убивця", + "увага", + "удав", + "удар", + "удача", + "ужиток", + "узвар", + "узвіз", + "узлісок", + "узор", + "указ", + "уклад", + "укол", + "укус", + "улов", + "ультра", + "умова", + "унікум", + "унісон", + "унітаз", + "унія", + "упор", + "управа", + "ура", + "ураган", + "уран", + "урвище", + "уривок", + "урок", + "уряд", + "усміх", + "успіх", + "устрій", + "утопія", + "утрата", + "утіха", + "ухвала", + "ухил", + "участь", + "учень", + "уява", + "уявний", + "фаза", + "файл", + "факт", + "фальш", + "фанат", + "фантом", + "фарба", + "фартух", + "фарфор", + "фасад", + "фах", + "ферма", + "фея", + "фланг", + "флейта", + "флешка", + "флора", + "флот", + "фляга", + "флірт", + "фокус", + "фонд", + "фонтан", + "фора", + "форель", + "фортеця", + "форум", + "фото", + "фраза", + "фрегат", + "фреска", + "фронт", + "фрукт", + "фтор", + "фургон", + "фіалка", + "фіаско", + "фігура", + "фізика", + "фіксатор", + "фікція", + "філе", + "фільм", + "філія", + "фінал", + "фінік", + "фіолет", + "фіранка", + "фірма", + "фішка", + "хабар", + "халепа", + "халтура", + "хан", + "хаос", + "хапати", + "харч", + "хата", + "хатина", + "хвала", + "хватка", + "хвиля", + "хворий", + "хвоя", + "хвіртка", + "хвіст", + "хиба", + "хибно", + "хист", + "хлопець", + "хлор", + "хліб", + "хлів", + "хмара", + "хмуро", + "хміль", + "хобот", + "хомут", + "хор", + "хорда", + "хостел", + "хотіти", + "храм", + "храп", + "хребет", + "хрест", + "хробак", + "хром", + "хрущ", + "хрящ", + "хрін", + "хтось", + "худоба", + "хутко", + "хутро", + "хутір", + "хіба", + "хімія", + "хірург", + "цар", + "цариця", + "цвях", + "цегла", + "цемент", + "цензура", + "центр", + "церква", + "цех", + "цибуля", + "цикл", + "цикорій", + "цирк", + "цитата", + "цитрус", + "цифра", + "цукор", + "цунамі", + "цятка", + "цікаво", + "ціле", + "цілком", + "ціна", + "цінний", + "чавун", + "чагар", + "чадо", + "чай", + "чаклун", + "чапля", + "чари", + "чарка", + "чартер", + "чарівно", + "час", + "часник", + "часто", + "чахлий", + "чаша", + "чверть", + "чебрець", + "чемно", + "чемодан", + "чемпіон", + "червень", + "черга", + "через", + "чесний", + "честь", + "четвер", + "чиж", + "чимало", + "чинник", + "число", + "чистий", + "читач", + "чоботи", + "чобіт", + "човен", + "човник", + "чоловік", + "чорне", + "чотири", + "чохол", + "чуб", + "чудо", + "чужак", + "чужий", + "чути", + "чутка", + "чутно", + "чхати", + "чіпати", + "чіпси", + "чітко", + "шабля", + "шайба", + "шампунь", + "шанс", + "шар", + "шафа", + "шахи", + "шахта", + "швець", + "швидко", + "шериф", + "шерсть", + "шибка", + "шина", + "широко", + "ширше", + "шифр", + "шия", + "школа", + "шкіра", + "шлунок", + "шлях", + "шовк", + "шолом", + "шорти", + "шостий", + "шрам", + "штани", + "штик", + "шторм", + "штраф", + "штука", + "шукач", + "шум", + "щастя", + "щедрий", + "щирий", + "щоденник", + "щодня", + "щодо", + "щойно", + "щука", + "щур", + "щітка", + "ювелір", + "ювілей", + "юнак", + "юнга", + "юність", + "юрист", + "юстиція", + "юшка", + "яблуко", + "явище", + "явний", + "явно", + "явір", + "ягня", + "ягода", + "ягуар", + "ядро", + "язик", + "яйце", + "який", + "якщо", + "якір", + "якість", + "ялинка", + "яма", + "янтар", + "ярлик", + "ярус", + "ясла", + "ясно", + "яструб", + "яхта", + "ящик", + "ящір", + "яєчня", + "євнух", + "єврей", + "єдиний", + "їжа", + "їсти", + "ідея", + "імбир", + "імпорт", + "індекс", + "індик", + "індус", + "інжир", + "іноді", + "інститут", + "інший", + "інші", + "іржа", + "ірис", + "іспит", + "істина", + "істота" + } + }; + + const dictionary zh_Hans = + { + { + "的", + "一", + "是", + "在", + "不", + "了", + "有", + "和", + "人", + "这", + "中", + "大", + "为", + "上", + "个", + "国", + "我", + "以", + "要", + "他", + "时", + "来", + "用", + "们", + "生", + "到", + "作", + "地", + "于", + "出", + "就", + "分", + "对", + "成", + "会", + "可", + "主", + "发", + "年", + "动", + "同", + "工", + "也", + "能", + "下", + "过", + "子", + "说", + "产", + "种", + "面", + "而", + "方", + "后", + "多", + "定", + "行", + "学", + "法", + "所", + "民", + "得", + "经", + "十", + "三", + "之", + "进", + "着", + "等", + "部", + "度", + "家", + "电", + "力", + "里", + "如", + "水", + "化", + "高", + "自", + "二", + "理", + "起", + "小", + "物", + "现", + "实", + "加", + "量", + "都", + "两", + "体", + "制", + "机", + "当", + "使", + "点", + "从", + "业", + "本", + "去", + "把", + "性", + "好", + "应", + "开", + "它", + "合", + "还", + "因", + "由", + "其", + "些", + "然", + "前", + "外", + "天", + "政", + "四", + "日", + "那", + "社", + "义", + "事", + "平", + "形", + "相", + "全", + "表", + "间", + "样", + "与", + "关", + "各", + "重", + "新", + "线", + "内", + "数", + "正", + "心", + "反", + "你", + "明", + "看", + "原", + "又", + "么", + "利", + "比", + "或", + "但", + "质", + "气", + "第", + "向", + "道", + "命", + "此", + "变", + "条", + "只", + "没", + "结", + "解", + "问", + "意", + "建", + "月", + "公", + "无", + "系", + "军", + "很", + "情", + "者", + "最", + "立", + "代", + "想", + "已", + "通", + "并", + "提", + "直", + "题", + "党", + "程", + "展", + "五", + "果", + "料", + "象", + "员", + "革", + "位", + "入", + "常", + "文", + "总", + "次", + "品", + "式", + "活", + "设", + "及", + "管", + "特", + "件", + "长", + "求", + "老", + "头", + "基", + "资", + "边", + "流", + "路", + "级", + "少", + "图", + "山", + "统", + "接", + "知", + "较", + "将", + "组", + "见", + "计", + "别", + "她", + "手", + "角", + "期", + "根", + "论", + "运", + "农", + "指", + "几", + "九", + "区", + "强", + "放", + "决", + "西", + "被", + "干", + "做", + "必", + "战", + "先", + "回", + "则", + "任", + "取", + "据", + "处", + "队", + "南", + "给", + "色", + "光", + "门", + "即", + "保", + "治", + "北", + "造", + "百", + "规", + "热", + "领", + "七", + "海", + "口", + "东", + "导", + "器", + "压", + "志", + "世", + "金", + "增", + "争", + "济", + "阶", + "油", + "思", + "术", + "极", + "交", + "受", + "联", + "什", + "认", + "六", + "共", + "权", + "收", + "证", + "改", + "清", + "美", + "再", + "采", + "转", + "更", + "单", + "风", + "切", + "打", + "白", + "教", + "速", + "花", + "带", + "安", + "场", + "身", + "车", + "例", + "真", + "务", + "具", + "万", + "每", + "目", + "至", + "达", + "走", + "积", + "示", + "议", + "声", + "报", + "斗", + "完", + "类", + "八", + "离", + "华", + "名", + "确", + "才", + "科", + "张", + "信", + "马", + "节", + "话", + "米", + "整", + "空", + "元", + "况", + "今", + "集", + "温", + "传", + "土", + "许", + "步", + "群", + "广", + "石", + "记", + "需", + "段", + "研", + "界", + "拉", + "林", + "律", + "叫", + "且", + "究", + "观", + "越", + "织", + "装", + "影", + "算", + "低", + "持", + "音", + "众", + "书", + "布", + "复", + "容", + "儿", + "须", + "际", + "商", + "非", + "验", + "连", + "断", + "深", + "难", + "近", + "矿", + "千", + "周", + "委", + "素", + "技", + "备", + "半", + "办", + "青", + "省", + "列", + "习", + "响", + "约", + "支", + "般", + "史", + "感", + "劳", + "便", + "团", + "往", + "酸", + "历", + "市", + "克", + "何", + "除", + "消", + "构", + "府", + "称", + "太", + "准", + "精", + "值", + "号", + "率", + "族", + "维", + "划", + "选", + "标", + "写", + "存", + "候", + "毛", + "亲", + "快", + "效", + "斯", + "院", + "查", + "江", + "型", + "眼", + "王", + "按", + "格", + "养", + "易", + "置", + "派", + "层", + "片", + "始", + "却", + "专", + "状", + "育", + "厂", + "京", + "识", + "适", + "属", + "圆", + "包", + "火", + "住", + "调", + "满", + "县", + "局", + "照", + "参", + "红", + "细", + "引", + "听", + "该", + "铁", + "价", + "严", + "首", + "底", + "液", + "官", + "德", + "随", + "病", + "苏", + "失", + "尔", + "死", + "讲", + "配", + "女", + "黄", + "推", + "显", + "谈", + "罪", + "神", + "艺", + "呢", + "席", + "含", + "企", + "望", + "密", + "批", + "营", + "项", + "防", + "举", + "球", + "英", + "氧", + "势", + "告", + "李", + "台", + "落", + "木", + "帮", + "轮", + "破", + "亚", + "师", + "围", + "注", + "远", + "字", + "材", + "排", + "供", + "河", + "态", + "封", + "另", + "施", + "减", + "树", + "溶", + "怎", + "止", + "案", + "言", + "士", + "均", + "武", + "固", + "叶", + "鱼", + "波", + "视", + "仅", + "费", + "紧", + "爱", + "左", + "章", + "早", + "朝", + "害", + "续", + "轻", + "服", + "试", + "食", + "充", + "兵", + "源", + "判", + "护", + "司", + "足", + "某", + "练", + "差", + "致", + "板", + "田", + "降", + "黑", + "犯", + "负", + "击", + "范", + "继", + "兴", + "似", + "余", + "坚", + "曲", + "输", + "修", + "故", + "城", + "夫", + "够", + "送", + "笔", + "船", + "占", + "右", + "财", + "吃", + "富", + "春", + "职", + "觉", + "汉", + "画", + "功", + "巴", + "跟", + "虽", + "杂", + "飞", + "检", + "吸", + "助", + "升", + "阳", + "互", + "初", + "创", + "抗", + "考", + "投", + "坏", + "策", + "古", + "径", + "换", + "未", + "跑", + "留", + "钢", + "曾", + "端", + "责", + "站", + "简", + "述", + "钱", + "副", + "尽", + "帝", + "射", + "草", + "冲", + "承", + "独", + "令", + "限", + "阿", + "宣", + "环", + "双", + "请", + "超", + "微", + "让", + "控", + "州", + "良", + "轴", + "找", + "否", + "纪", + "益", + "依", + "优", + "顶", + "础", + "载", + "倒", + "房", + "突", + "坐", + "粉", + "敌", + "略", + "客", + "袁", + "冷", + "胜", + "绝", + "析", + "块", + "剂", + "测", + "丝", + "协", + "诉", + "念", + "陈", + "仍", + "罗", + "盐", + "友", + "洋", + "错", + "苦", + "夜", + "刑", + "移", + "频", + "逐", + "靠", + "混", + "母", + "短", + "皮", + "终", + "聚", + "汽", + "村", + "云", + "哪", + "既", + "距", + "卫", + "停", + "烈", + "央", + "察", + "烧", + "迅", + "境", + "若", + "印", + "洲", + "刻", + "括", + "激", + "孔", + "搞", + "甚", + "室", + "待", + "核", + "校", + "散", + "侵", + "吧", + "甲", + "游", + "久", + "菜", + "味", + "旧", + "模", + "湖", + "货", + "损", + "预", + "阻", + "毫", + "普", + "稳", + "乙", + "妈", + "植", + "息", + "扩", + "银", + "语", + "挥", + "酒", + "守", + "拿", + "序", + "纸", + "医", + "缺", + "雨", + "吗", + "针", + "刘", + "啊", + "急", + "唱", + "误", + "训", + "愿", + "审", + "附", + "获", + "茶", + "鲜", + "粮", + "斤", + "孩", + "脱", + "硫", + "肥", + "善", + "龙", + "演", + "父", + "渐", + "血", + "欢", + "械", + "掌", + "歌", + "沙", + "刚", + "攻", + "谓", + "盾", + "讨", + "晚", + "粒", + "乱", + "燃", + "矛", + "乎", + "杀", + "药", + "宁", + "鲁", + "贵", + "钟", + "煤", + "读", + "班", + "伯", + "香", + "介", + "迫", + "句", + "丰", + "培", + "握", + "兰", + "担", + "弦", + "蛋", + "沉", + "假", + "穿", + "执", + "答", + "乐", + "谁", + "顺", + "烟", + "缩", + "征", + "脸", + "喜", + "松", + "脚", + "困", + "异", + "免", + "背", + "星", + "福", + "买", + "染", + "井", + "概", + "慢", + "怕", + "磁", + "倍", + "祖", + "皇", + "促", + "静", + "补", + "评", + "翻", + "肉", + "践", + "尼", + "衣", + "宽", + "扬", + "棉", + "希", + "伤", + "操", + "垂", + "秋", + "宜", + "氢", + "套", + "督", + "振", + "架", + "亮", + "末", + "宪", + "庆", + "编", + "牛", + "触", + "映", + "雷", + "销", + "诗", + "座", + "居", + "抓", + "裂", + "胞", + "呼", + "娘", + "景", + "威", + "绿", + "晶", + "厚", + "盟", + "衡", + "鸡", + "孙", + "延", + "危", + "胶", + "屋", + "乡", + "临", + "陆", + "顾", + "掉", + "呀", + "灯", + "岁", + "措", + "束", + "耐", + "剧", + "玉", + "赵", + "跳", + "哥", + "季", + "课", + "凯", + "胡", + "额", + "款", + "绍", + "卷", + "齐", + "伟", + "蒸", + "殖", + "永", + "宗", + "苗", + "川", + "炉", + "岩", + "弱", + "零", + "杨", + "奏", + "沿", + "露", + "杆", + "探", + "滑", + "镇", + "饭", + "浓", + "航", + "怀", + "赶", + "库", + "夺", + "伊", + "灵", + "税", + "途", + "灭", + "赛", + "归", + "召", + "鼓", + "播", + "盘", + "裁", + "险", + "康", + "唯", + "录", + "菌", + "纯", + "借", + "糖", + "盖", + "横", + "符", + "私", + "努", + "堂", + "域", + "枪", + "润", + "幅", + "哈", + "竟", + "熟", + "虫", + "泽", + "脑", + "壤", + "碳", + "欧", + "遍", + "侧", + "寨", + "敢", + "彻", + "虑", + "斜", + "薄", + "庭", + "纳", + "弹", + "饲", + "伸", + "折", + "麦", + "湿", + "暗", + "荷", + "瓦", + "塞", + "床", + "筑", + "恶", + "户", + "访", + "塔", + "奇", + "透", + "梁", + "刀", + "旋", + "迹", + "卡", + "氯", + "遇", + "份", + "毒", + "泥", + "退", + "洗", + "摆", + "灰", + "彩", + "卖", + "耗", + "夏", + "择", + "忙", + "铜", + "献", + "硬", + "予", + "繁", + "圈", + "雪", + "函", + "亦", + "抽", + "篇", + "阵", + "阴", + "丁", + "尺", + "追", + "堆", + "雄", + "迎", + "泛", + "爸", + "楼", + "避", + "谋", + "吨", + "野", + "猪", + "旗", + "累", + "偏", + "典", + "馆", + "索", + "秦", + "脂", + "潮", + "爷", + "豆", + "忽", + "托", + "惊", + "塑", + "遗", + "愈", + "朱", + "替", + "纤", + "粗", + "倾", + "尚", + "痛", + "楚", + "谢", + "奋", + "购", + "磨", + "君", + "池", + "旁", + "碎", + "骨", + "监", + "捕", + "弟", + "暴", + "割", + "贯", + "殊", + "释", + "词", + "亡", + "壁", + "顿", + "宝", + "午", + "尘", + "闻", + "揭", + "炮", + "残", + "冬", + "桥", + "妇", + "警", + "综", + "招", + "吴", + "付", + "浮", + "遭", + "徐", + "您", + "摇", + "谷", + "赞", + "箱", + "隔", + "订", + "男", + "吹", + "园", + "纷", + "唐", + "败", + "宋", + "玻", + "巨", + "耕", + "坦", + "荣", + "闭", + "湾", + "键", + "凡", + "驻", + "锅", + "救", + "恩", + "剥", + "凝", + "碱", + "齿", + "截", + "炼", + "麻", + "纺", + "禁", + "废", + "盛", + "版", + "缓", + "净", + "睛", + "昌", + "婚", + "涉", + "筒", + "嘴", + "插", + "岸", + "朗", + "庄", + "街", + "藏", + "姑", + "贸", + "腐", + "奴", + "啦", + "惯", + "乘", + "伙", + "恢", + "匀", + "纱", + "扎", + "辩", + "耳", + "彪", + "臣", + "亿", + "璃", + "抵", + "脉", + "秀", + "萨", + "俄", + "网", + "舞", + "店", + "喷", + "纵", + "寸", + "汗", + "挂", + "洪", + "贺", + "闪", + "柬", + "爆", + "烯", + "津", + "稻", + "墙", + "软", + "勇", + "像", + "滚", + "厘", + "蒙", + "芳", + "肯", + "坡", + "柱", + "荡", + "腿", + "仪", + "旅", + "尾", + "轧", + "冰", + "贡", + "登", + "黎", + "削", + "钻", + "勒", + "逃", + "障", + "氨", + "郭", + "峰", + "币", + "港", + "伏", + "轨", + "亩", + "毕", + "擦", + "莫", + "刺", + "浪", + "秘", + "援", + "株", + "健", + "售", + "股", + "岛", + "甘", + "泡", + "睡", + "童", + "铸", + "汤", + "阀", + "休", + "汇", + "舍", + "牧", + "绕", + "炸", + "哲", + "磷", + "绩", + "朋", + "淡", + "尖", + "启", + "陷", + "柴", + "呈", + "徒", + "颜", + "泪", + "稍", + "忘", + "泵", + "蓝", + "拖", + "洞", + "授", + "镜", + "辛", + "壮", + "锋", + "贫", + "虚", + "弯", + "摩", + "泰", + "幼", + "廷", + "尊", + "窗", + "纲", + "弄", + "隶", + "疑", + "氏", + "宫", + "姐", + "震", + "瑞", + "怪", + "尤", + "琴", + "循", + "描", + "膜", + "违", + "夹", + "腰", + "缘", + "珠", + "穷", + "森", + "枝", + "竹", + "沟", + "催", + "绳", + "忆", + "邦", + "剩", + "幸", + "浆", + "栏", + "拥", + "牙", + "贮", + "礼", + "滤", + "钠", + "纹", + "罢", + "拍", + "咱", + "喊", + "袖", + "埃", + "勤", + "罚", + "焦", + "潜", + "伍", + "墨", + "欲", + "缝", + "姓", + "刊", + "饱", + "仿", + "奖", + "铝", + "鬼", + "丽", + "跨", + "默", + "挖", + "链", + "扫", + "喝", + "袋", + "炭", + "污", + "幕", + "诸", + "弧", + "励", + "梅", + "奶", + "洁", + "灾", + "舟", + "鉴", + "苯", + "讼", + "抱", + "毁", + "懂", + "寒", + "智", + "埔", + "寄", + "届", + "跃", + "渡", + "挑", + "丹", + "艰", + "贝", + "碰", + "拔", + "爹", + "戴", + "码", + "梦", + "芽", + "熔", + "赤", + "渔", + "哭", + "敬", + "颗", + "奔", + "铅", + "仲", + "虎", + "稀", + "妹", + "乏", + "珍", + "申", + "桌", + "遵", + "允", + "隆", + "螺", + "仓", + "魏", + "锐", + "晓", + "氮", + "兼", + "隐", + "碍", + "赫", + "拨", + "忠", + "肃", + "缸", + "牵", + "抢", + "博", + "巧", + "壳", + "兄", + "杜", + "讯", + "诚", + "碧", + "祥", + "柯", + "页", + "巡", + "矩", + "悲", + "灌", + "龄", + "伦", + "票", + "寻", + "桂", + "铺", + "圣", + "恐", + "恰", + "郑", + "趣", + "抬", + "荒", + "腾", + "贴", + "柔", + "滴", + "猛", + "阔", + "辆", + "妻", + "填", + "撤", + "储", + "签", + "闹", + "扰", + "紫", + "砂", + "递", + "戏", + "吊", + "陶", + "伐", + "喂", + "疗", + "瓶", + "婆", + "抚", + "臂", + "摸", + "忍", + "虾", + "蜡", + "邻", + "胸", + "巩", + "挤", + "偶", + "弃", + "槽", + "劲", + "乳", + "邓", + "吉", + "仁", + "烂", + "砖", + "租", + "乌", + "舰", + "伴", + "瓜", + "浅", + "丙", + "暂", + "燥", + "橡", + "柳", + "迷", + "暖", + "牌", + "秧", + "胆", + "详", + "簧", + "踏", + "瓷", + "谱", + "呆", + "宾", + "糊", + "洛", + "辉", + "愤", + "竞", + "隙", + "怒", + "粘", + "乃", + "绪", + "肩", + "籍", + "敏", + "涂", + "熙", + "皆", + "侦", + "悬", + "掘", + "享", + "纠", + "醒", + "狂", + "锁", + "淀", + "恨", + "牲", + "霸", + "爬", + "赏", + "逆", + "玩", + "陵", + "祝", + "秒", + "浙", + "貌", + "役", + "彼", + "悉", + "鸭", + "趋", + "凤", + "晨", + "畜", + "辈", + "秩", + "卵", + "署", + "梯", + "炎", + "滩", + "棋", + "驱", + "筛", + "峡", + "冒", + "啥", + "寿", + "译", + "浸", + "泉", + "帽", + "迟", + "硅", + "疆", + "贷", + "漏", + "稿", + "冠", + "嫩", + "胁", + "芯", + "牢", + "叛", + "蚀", + "奥", + "鸣", + "岭", + "羊", + "凭", + "串", + "塘", + "绘", + "酵", + "融", + "盆", + "锡", + "庙", + "筹", + "冻", + "辅", + "摄", + "袭", + "筋", + "拒", + "僚", + "旱", + "钾", + "鸟", + "漆", + "沈", + "眉", + "疏", + "添", + "棒", + "穗", + "硝", + "韩", + "逼", + "扭", + "侨", + "凉", + "挺", + "碗", + "栽", + "炒", + "杯", + "患", + "馏", + "劝", + "豪", + "辽", + "勃", + "鸿", + "旦", + "吏", + "拜", + "狗", + "埋", + "辊", + "掩", + "饮", + "搬", + "骂", + "辞", + "勾", + "扣", + "估", + "蒋", + "绒", + "雾", + "丈", + "朵", + "姆", + "拟", + "宇", + "辑", + "陕", + "雕", + "偿", + "蓄", + "崇", + "剪", + "倡", + "厅", + "咬", + "驶", + "薯", + "刷", + "斥", + "番", + "赋", + "奉", + "佛", + "浇", + "漫", + "曼", + "扇", + "钙", + "桃", + "扶", + "仔", + "返", + "俗", + "亏", + "腔", + "鞋", + "棱", + "覆", + "框", + "悄", + "叔", + "撞", + "骗", + "勘", + "旺", + "沸", + "孤", + "吐", + "孟", + "渠", + "屈", + "疾", + "妙", + "惜", + "仰", + "狠", + "胀", + "谐", + "抛", + "霉", + "桑", + "岗", + "嘛", + "衰", + "盗", + "渗", + "脏", + "赖", + "涌", + "甜", + "曹", + "阅", + "肌", + "哩", + "厉", + "烃", + "纬", + "毅", + "昨", + "伪", + "症", + "煮", + "叹", + "钉", + "搭", + "茎", + "笼", + "酷", + "偷", + "弓", + "锥", + "恒", + "杰", + "坑", + "鼻", + "翼", + "纶", + "叙", + "狱", + "逮", + "罐", + "络", + "棚", + "抑", + "膨", + "蔬", + "寺", + "骤", + "穆", + "冶", + "枯", + "册", + "尸", + "凸", + "绅", + "坯", + "牺", + "焰", + "轰", + "欣", + "晋", + "瘦", + "御", + "锭", + "锦", + "丧", + "旬", + "锻", + "垄", + "搜", + "扑", + "邀", + "亭", + "酯", + "迈", + "舒", + "脆", + "酶", + "闲", + "忧", + "酚", + "顽", + "羽", + "涨", + "卸", + "仗", + "陪", + "辟", + "惩", + "杭", + "姚", + "肚", + "捉", + "飘", + "漂", + "昆", + "欺", + "吾", + "郎", + "烷", + "汁", + "呵", + "饰", + "萧", + "雅", + "邮", + "迁", + "燕", + "撒", + "姻", + "赴", + "宴", + "烦", + "债", + "帐", + "斑", + "铃", + "旨", + "醇", + "董", + "饼", + "雏", + "姿", + "拌", + "傅", + "腹", + "妥", + "揉", + "贤", + "拆", + "歪", + "葡", + "胺", + "丢", + "浩", + "徽", + "昂", + "垫", + "挡", + "览", + "贪", + "慰", + "缴", + "汪", + "慌", + "冯", + "诺", + "姜", + "谊", + "凶", + "劣", + "诬", + "耀", + "昏", + "躺", + "盈", + "骑", + "乔", + "溪", + "丛", + "卢", + "抹", + "闷", + "咨", + "刮", + "驾", + "缆", + "悟", + "摘", + "铒", + "掷", + "颇", + "幻", + "柄", + "惠", + "惨", + "佳", + "仇", + "腊", + "窝", + "涤", + "剑", + "瞧", + "堡", + "泼", + "葱", + "罩", + "霍", + "捞", + "胎", + "苍", + "滨", + "俩", + "捅", + "湘", + "砍", + "霞", + "邵", + "萄", + "疯", + "淮", + "遂", + "熊", + "粪", + "烘", + "宿", + "档", + "戈", + "驳", + "嫂", + "裕", + "徙", + "箭", + "捐", + "肠", + "撑", + "晒", + "辨", + "殿", + "莲", + "摊", + "搅", + "酱", + "屏", + "疫", + "哀", + "蔡", + "堵", + "沫", + "皱", + "畅", + "叠", + "阁", + "莱", + "敲", + "辖", + "钩", + "痕", + "坝", + "巷", + "饿", + "祸", + "丘", + "玄", + "溜", + "曰", + "逻", + "彭", + "尝", + "卿", + "妨", + "艇", + "吞", + "韦", + "怨", + "矮", + "歇" + } + }; + + const dictionary zh_Hant = + { + { + "的", + "一", + "是", + "在", + "不", + "了", + "有", + "和", + "人", + "這", + "中", + "大", + "為", + "上", + "個", + "國", + "我", + "以", + "要", + "他", + "時", + "來", + "用", + "們", + "生", + "到", + "作", + "地", + "於", + "出", + "就", + "分", + "對", + "成", + "會", + "可", + "主", + "發", + "年", + "動", + "同", + "工", + "也", + "能", + "下", + "過", + "子", + "說", + "產", + "種", + "面", + "而", + "方", + "後", + "多", + "定", + "行", + "學", + "法", + "所", + "民", + "得", + "經", + "十", + "三", + "之", + "進", + "著", + "等", + "部", + "度", + "家", + "電", + "力", + "裡", + "如", + "水", + "化", + "高", + "自", + "二", + "理", + "起", + "小", + "物", + "現", + "實", + "加", + "量", + "都", + "兩", + "體", + "制", + "機", + "當", + "使", + "點", + "從", + "業", + "本", + "去", + "把", + "性", + "好", + "應", + "開", + "它", + "合", + "還", + "因", + "由", + "其", + "些", + "然", + "前", + "外", + "天", + "政", + "四", + "日", + "那", + "社", + "義", + "事", + "平", + "形", + "相", + "全", + "表", + "間", + "樣", + "與", + "關", + "各", + "重", + "新", + "線", + "內", + "數", + "正", + "心", + "反", + "你", + "明", + "看", + "原", + "又", + "麼", + "利", + "比", + "或", + "但", + "質", + "氣", + "第", + "向", + "道", + "命", + "此", + "變", + "條", + "只", + "沒", + "結", + "解", + "問", + "意", + "建", + "月", + "公", + "無", + "系", + "軍", + "很", + "情", + "者", + "最", + "立", + "代", + "想", + "已", + "通", + "並", + "提", + "直", + "題", + "黨", + "程", + "展", + "五", + "果", + "料", + "象", + "員", + "革", + "位", + "入", + "常", + "文", + "總", + "次", + "品", + "式", + "活", + "設", + "及", + "管", + "特", + "件", + "長", + "求", + "老", + "頭", + "基", + "資", + "邊", + "流", + "路", + "級", + "少", + "圖", + "山", + "統", + "接", + "知", + "較", + "將", + "組", + "見", + "計", + "別", + "她", + "手", + "角", + "期", + "根", + "論", + "運", + "農", + "指", + "幾", + "九", + "區", + "強", + "放", + "決", + "西", + "被", + "幹", + "做", + "必", + "戰", + "先", + "回", + "則", + "任", + "取", + "據", + "處", + "隊", + "南", + "給", + "色", + "光", + "門", + "即", + "保", + "治", + "北", + "造", + "百", + "規", + "熱", + "領", + "七", + "海", + "口", + "東", + "導", + "器", + "壓", + "志", + "世", + "金", + "增", + "爭", + "濟", + "階", + "油", + "思", + "術", + "極", + "交", + "受", + "聯", + "什", + "認", + "六", + "共", + "權", + "收", + "證", + "改", + "清", + "美", + "再", + "採", + "轉", + "更", + "單", + "風", + "切", + "打", + "白", + "教", + "速", + "花", + "帶", + "安", + "場", + "身", + "車", + "例", + "真", + "務", + "具", + "萬", + "每", + "目", + "至", + "達", + "走", + "積", + "示", + "議", + "聲", + "報", + "鬥", + "完", + "類", + "八", + "離", + "華", + "名", + "確", + "才", + "科", + "張", + "信", + "馬", + "節", + "話", + "米", + "整", + "空", + "元", + "況", + "今", + "集", + "溫", + "傳", + "土", + "許", + "步", + "群", + "廣", + "石", + "記", + "需", + "段", + "研", + "界", + "拉", + "林", + "律", + "叫", + "且", + "究", + "觀", + "越", + "織", + "裝", + "影", + "算", + "低", + "持", + "音", + "眾", + "書", + "布", + "复", + "容", + "兒", + "須", + "際", + "商", + "非", + "驗", + "連", + "斷", + "深", + "難", + "近", + "礦", + "千", + "週", + "委", + "素", + "技", + "備", + "半", + "辦", + "青", + "省", + "列", + "習", + "響", + "約", + "支", + "般", + "史", + "感", + "勞", + "便", + "團", + "往", + "酸", + "歷", + "市", + "克", + "何", + "除", + "消", + "構", + "府", + "稱", + "太", + "準", + "精", + "值", + "號", + "率", + "族", + "維", + "劃", + "選", + "標", + "寫", + "存", + "候", + "毛", + "親", + "快", + "效", + "斯", + "院", + "查", + "江", + "型", + "眼", + "王", + "按", + "格", + "養", + "易", + "置", + "派", + "層", + "片", + "始", + "卻", + "專", + "狀", + "育", + "廠", + "京", + "識", + "適", + "屬", + "圓", + "包", + "火", + "住", + "調", + "滿", + "縣", + "局", + "照", + "參", + "紅", + "細", + "引", + "聽", + "該", + "鐵", + "價", + "嚴", + "首", + "底", + "液", + "官", + "德", + "隨", + "病", + "蘇", + "失", + "爾", + "死", + "講", + "配", + "女", + "黃", + "推", + "顯", + "談", + "罪", + "神", + "藝", + "呢", + "席", + "含", + "企", + "望", + "密", + "批", + "營", + "項", + "防", + "舉", + "球", + "英", + "氧", + "勢", + "告", + "李", + "台", + "落", + "木", + "幫", + "輪", + "破", + "亞", + "師", + "圍", + "注", + "遠", + "字", + "材", + "排", + "供", + "河", + "態", + "封", + "另", + "施", + "減", + "樹", + "溶", + "怎", + "止", + "案", + "言", + "士", + "均", + "武", + "固", + "葉", + "魚", + "波", + "視", + "僅", + "費", + "緊", + "愛", + "左", + "章", + "早", + "朝", + "害", + "續", + "輕", + "服", + "試", + "食", + "充", + "兵", + "源", + "判", + "護", + "司", + "足", + "某", + "練", + "差", + "致", + "板", + "田", + "降", + "黑", + "犯", + "負", + "擊", + "范", + "繼", + "興", + "似", + "餘", + "堅", + "曲", + "輸", + "修", + "故", + "城", + "夫", + "夠", + "送", + "筆", + "船", + "佔", + "右", + "財", + "吃", + "富", + "春", + "職", + "覺", + "漢", + "畫", + "功", + "巴", + "跟", + "雖", + "雜", + "飛", + "檢", + "吸", + "助", + "昇", + "陽", + "互", + "初", + "創", + "抗", + "考", + "投", + "壞", + "策", + "古", + "徑", + "換", + "未", + "跑", + "留", + "鋼", + "曾", + "端", + "責", + "站", + "簡", + "述", + "錢", + "副", + "盡", + "帝", + "射", + "草", + "衝", + "承", + "獨", + "令", + "限", + "阿", + "宣", + "環", + "雙", + "請", + "超", + "微", + "讓", + "控", + "州", + "良", + "軸", + "找", + "否", + "紀", + "益", + "依", + "優", + "頂", + "礎", + "載", + "倒", + "房", + "突", + "坐", + "粉", + "敵", + "略", + "客", + "袁", + "冷", + "勝", + "絕", + "析", + "塊", + "劑", + "測", + "絲", + "協", + "訴", + "念", + "陳", + "仍", + "羅", + "鹽", + "友", + "洋", + "錯", + "苦", + "夜", + "刑", + "移", + "頻", + "逐", + "靠", + "混", + "母", + "短", + "皮", + "終", + "聚", + "汽", + "村", + "雲", + "哪", + "既", + "距", + "衛", + "停", + "烈", + "央", + "察", + "燒", + "迅", + "境", + "若", + "印", + "洲", + "刻", + "括", + "激", + "孔", + "搞", + "甚", + "室", + "待", + "核", + "校", + "散", + "侵", + "吧", + "甲", + "遊", + "久", + "菜", + "味", + "舊", + "模", + "湖", + "貨", + "損", + "預", + "阻", + "毫", + "普", + "穩", + "乙", + "媽", + "植", + "息", + "擴", + "銀", + "語", + "揮", + "酒", + "守", + "拿", + "序", + "紙", + "醫", + "缺", + "雨", + "嗎", + "針", + "劉", + "啊", + "急", + "唱", + "誤", + "訓", + "願", + "審", + "附", + "獲", + "茶", + "鮮", + "糧", + "斤", + "孩", + "脫", + "硫", + "肥", + "善", + "龍", + "演", + "父", + "漸", + "血", + "歡", + "械", + "掌", + "歌", + "沙", + "剛", + "攻", + "謂", + "盾", + "討", + "晚", + "粒", + "亂", + "燃", + "矛", + "乎", + "殺", + "藥", + "寧", + "魯", + "貴", + "鐘", + "煤", + "讀", + "班", + "伯", + "香", + "介", + "迫", + "句", + "豐", + "培", + "握", + "蘭", + "擔", + "弦", + "蛋", + "沉", + "假", + "穿", + "執", + "答", + "樂", + "誰", + "順", + "煙", + "縮", + "徵", + "臉", + "喜", + "松", + "腳", + "困", + "異", + "免", + "背", + "星", + "福", + "買", + "染", + "井", + "概", + "慢", + "怕", + "磁", + "倍", + "祖", + "皇", + "促", + "靜", + "補", + "評", + "翻", + "肉", + "踐", + "尼", + "衣", + "寬", + "揚", + "棉", + "希", + "傷", + "操", + "垂", + "秋", + "宜", + "氫", + "套", + "督", + "振", + "架", + "亮", + "末", + "憲", + "慶", + "編", + "牛", + "觸", + "映", + "雷", + "銷", + "詩", + "座", + "居", + "抓", + "裂", + "胞", + "呼", + "娘", + "景", + "威", + "綠", + "晶", + "厚", + "盟", + "衡", + "雞", + "孫", + "延", + "危", + "膠", + "屋", + "鄉", + "臨", + "陸", + "顧", + "掉", + "呀", + "燈", + "歲", + "措", + "束", + "耐", + "劇", + "玉", + "趙", + "跳", + "哥", + "季", + "課", + "凱", + "胡", + "額", + "款", + "紹", + "卷", + "齊", + "偉", + "蒸", + "殖", + "永", + "宗", + "苗", + "川", + "爐", + "岩", + "弱", + "零", + "楊", + "奏", + "沿", + "露", + "桿", + "探", + "滑", + "鎮", + "飯", + "濃", + "航", + "懷", + "趕", + "庫", + "奪", + "伊", + "靈", + "稅", + "途", + "滅", + "賽", + "歸", + "召", + "鼓", + "播", + "盤", + "裁", + "險", + "康", + "唯", + "錄", + "菌", + "純", + "借", + "糖", + "蓋", + "橫", + "符", + "私", + "努", + "堂", + "域", + "槍", + "潤", + "幅", + "哈", + "竟", + "熟", + "蟲", + "澤", + "腦", + "壤", + "碳", + "歐", + "遍", + "側", + "寨", + "敢", + "徹", + "慮", + "斜", + "薄", + "庭", + "納", + "彈", + "飼", + "伸", + "折", + "麥", + "濕", + "暗", + "荷", + "瓦", + "塞", + "床", + "築", + "惡", + "戶", + "訪", + "塔", + "奇", + "透", + "梁", + "刀", + "旋", + "跡", + "卡", + "氯", + "遇", + "份", + "毒", + "泥", + "退", + "洗", + "擺", + "灰", + "彩", + "賣", + "耗", + "夏", + "擇", + "忙", + "銅", + "獻", + "硬", + "予", + "繁", + "圈", + "雪", + "函", + "亦", + "抽", + "篇", + "陣", + "陰", + "丁", + "尺", + "追", + "堆", + "雄", + "迎", + "泛", + "爸", + "樓", + "避", + "謀", + "噸", + "野", + "豬", + "旗", + "累", + "偏", + "典", + "館", + "索", + "秦", + "脂", + "潮", + "爺", + "豆", + "忽", + "托", + "驚", + "塑", + "遺", + "愈", + "朱", + "替", + "纖", + "粗", + "傾", + "尚", + "痛", + "楚", + "謝", + "奮", + "購", + "磨", + "君", + "池", + "旁", + "碎", + "骨", + "監", + "捕", + "弟", + "暴", + "割", + "貫", + "殊", + "釋", + "詞", + "亡", + "壁", + "頓", + "寶", + "午", + "塵", + "聞", + "揭", + "炮", + "殘", + "冬", + "橋", + "婦", + "警", + "綜", + "招", + "吳", + "付", + "浮", + "遭", + "徐", + "您", + "搖", + "谷", + "贊", + "箱", + "隔", + "訂", + "男", + "吹", + "園", + "紛", + "唐", + "敗", + "宋", + "玻", + "巨", + "耕", + "坦", + "榮", + "閉", + "灣", + "鍵", + "凡", + "駐", + "鍋", + "救", + "恩", + "剝", + "凝", + "鹼", + "齒", + "截", + "煉", + "麻", + "紡", + "禁", + "廢", + "盛", + "版", + "緩", + "淨", + "睛", + "昌", + "婚", + "涉", + "筒", + "嘴", + "插", + "岸", + "朗", + "莊", + "街", + "藏", + "姑", + "貿", + "腐", + "奴", + "啦", + "慣", + "乘", + "夥", + "恢", + "勻", + "紗", + "扎", + "辯", + "耳", + "彪", + "臣", + "億", + "璃", + "抵", + "脈", + "秀", + "薩", + "俄", + "網", + "舞", + "店", + "噴", + "縱", + "寸", + "汗", + "掛", + "洪", + "賀", + "閃", + "柬", + "爆", + "烯", + "津", + "稻", + "牆", + "軟", + "勇", + "像", + "滾", + "厘", + "蒙", + "芳", + "肯", + "坡", + "柱", + "盪", + "腿", + "儀", + "旅", + "尾", + "軋", + "冰", + "貢", + "登", + "黎", + "削", + "鑽", + "勒", + "逃", + "障", + "氨", + "郭", + "峰", + "幣", + "港", + "伏", + "軌", + "畝", + "畢", + "擦", + "莫", + "刺", + "浪", + "秘", + "援", + "株", + "健", + "售", + "股", + "島", + "甘", + "泡", + "睡", + "童", + "鑄", + "湯", + "閥", + "休", + "匯", + "舍", + "牧", + "繞", + "炸", + "哲", + "磷", + "績", + "朋", + "淡", + "尖", + "啟", + "陷", + "柴", + "呈", + "徒", + "顏", + "淚", + "稍", + "忘", + "泵", + "藍", + "拖", + "洞", + "授", + "鏡", + "辛", + "壯", + "鋒", + "貧", + "虛", + "彎", + "摩", + "泰", + "幼", + "廷", + "尊", + "窗", + "綱", + "弄", + "隸", + "疑", + "氏", + "宮", + "姐", + "震", + "瑞", + "怪", + "尤", + "琴", + "循", + "描", + "膜", + "違", + "夾", + "腰", + "緣", + "珠", + "窮", + "森", + "枝", + "竹", + "溝", + "催", + "繩", + "憶", + "邦", + "剩", + "幸", + "漿", + "欄", + "擁", + "牙", + "貯", + "禮", + "濾", + "鈉", + "紋", + "罷", + "拍", + "咱", + "喊", + "袖", + "埃", + "勤", + "罰", + "焦", + "潛", + "伍", + "墨", + "欲", + "縫", + "姓", + "刊", + "飽", + "仿", + "獎", + "鋁", + "鬼", + "麗", + "跨", + "默", + "挖", + "鏈", + "掃", + "喝", + "袋", + "炭", + "污", + "幕", + "諸", + "弧", + "勵", + "梅", + "奶", + "潔", + "災", + "舟", + "鑑", + "苯", + "訟", + "抱", + "毀", + "懂", + "寒", + "智", + "埔", + "寄", + "屆", + "躍", + "渡", + "挑", + "丹", + "艱", + "貝", + "碰", + "拔", + "爹", + "戴", + "碼", + "夢", + "芽", + "熔", + "赤", + "漁", + "哭", + "敬", + "顆", + "奔", + "鉛", + "仲", + "虎", + "稀", + "妹", + "乏", + "珍", + "申", + "桌", + "遵", + "允", + "隆", + "螺", + "倉", + "魏", + "銳", + "曉", + "氮", + "兼", + "隱", + "礙", + "赫", + "撥", + "忠", + "肅", + "缸", + "牽", + "搶", + "博", + "巧", + "殼", + "兄", + "杜", + "訊", + "誠", + "碧", + "祥", + "柯", + "頁", + "巡", + "矩", + "悲", + "灌", + "齡", + "倫", + "票", + "尋", + "桂", + "鋪", + "聖", + "恐", + "恰", + "鄭", + "趣", + "抬", + "荒", + "騰", + "貼", + "柔", + "滴", + "猛", + "闊", + "輛", + "妻", + "填", + "撤", + "儲", + "簽", + "鬧", + "擾", + "紫", + "砂", + "遞", + "戲", + "吊", + "陶", + "伐", + "餵", + "療", + "瓶", + "婆", + "撫", + "臂", + "摸", + "忍", + "蝦", + "蠟", + "鄰", + "胸", + "鞏", + "擠", + "偶", + "棄", + "槽", + "勁", + "乳", + "鄧", + "吉", + "仁", + "爛", + "磚", + "租", + "烏", + "艦", + "伴", + "瓜", + "淺", + "丙", + "暫", + "燥", + "橡", + "柳", + "迷", + "暖", + "牌", + "秧", + "膽", + "詳", + "簧", + "踏", + "瓷", + "譜", + "呆", + "賓", + "糊", + "洛", + "輝", + "憤", + "競", + "隙", + "怒", + "粘", + "乃", + "緒", + "肩", + "籍", + "敏", + "塗", + "熙", + "皆", + "偵", + "懸", + "掘", + "享", + "糾", + "醒", + "狂", + "鎖", + "淀", + "恨", + "牲", + "霸", + "爬", + "賞", + "逆", + "玩", + "陵", + "祝", + "秒", + "浙", + "貌", + "役", + "彼", + "悉", + "鴨", + "趨", + "鳳", + "晨", + "畜", + "輩", + "秩", + "卵", + "署", + "梯", + "炎", + "灘", + "棋", + "驅", + "篩", + "峽", + "冒", + "啥", + "壽", + "譯", + "浸", + "泉", + "帽", + "遲", + "矽", + "疆", + "貸", + "漏", + "稿", + "冠", + "嫩", + "脅", + "芯", + "牢", + "叛", + "蝕", + "奧", + "鳴", + "嶺", + "羊", + "憑", + "串", + "塘", + "繪", + "酵", + "融", + "盆", + "錫", + "廟", + "籌", + "凍", + "輔", + "攝", + "襲", + "筋", + "拒", + "僚", + "旱", + "鉀", + "鳥", + "漆", + "沈", + "眉", + "疏", + "添", + "棒", + "穗", + "硝", + "韓", + "逼", + "扭", + "僑", + "涼", + "挺", + "碗", + "栽", + "炒", + "杯", + "患", + "餾", + "勸", + "豪", + "遼", + "勃", + "鴻", + "旦", + "吏", + "拜", + "狗", + "埋", + "輥", + "掩", + "飲", + "搬", + "罵", + "辭", + "勾", + "扣", + "估", + "蔣", + "絨", + "霧", + "丈", + "朵", + "姆", + "擬", + "宇", + "輯", + "陝", + "雕", + "償", + "蓄", + "崇", + "剪", + "倡", + "廳", + "咬", + "駛", + "薯", + "刷", + "斥", + "番", + "賦", + "奉", + "佛", + "澆", + "漫", + "曼", + "扇", + "鈣", + "桃", + "扶", + "仔", + "返", + "俗", + "虧", + "腔", + "鞋", + "棱", + "覆", + "框", + "悄", + "叔", + "撞", + "騙", + "勘", + "旺", + "沸", + "孤", + "吐", + "孟", + "渠", + "屈", + "疾", + "妙", + "惜", + "仰", + "狠", + "脹", + "諧", + "拋", + "黴", + "桑", + "崗", + "嘛", + "衰", + "盜", + "滲", + "臟", + "賴", + "湧", + "甜", + "曹", + "閱", + "肌", + "哩", + "厲", + "烴", + "緯", + "毅", + "昨", + "偽", + "症", + "煮", + "嘆", + "釘", + "搭", + "莖", + "籠", + "酷", + "偷", + "弓", + "錐", + "恆", + "傑", + "坑", + "鼻", + "翼", + "綸", + "敘", + "獄", + "逮", + "罐", + "絡", + "棚", + "抑", + "膨", + "蔬", + "寺", + "驟", + "穆", + "冶", + "枯", + "冊", + "屍", + "凸", + "紳", + "坯", + "犧", + "焰", + "轟", + "欣", + "晉", + "瘦", + "禦", + "錠", + "錦", + "喪", + "旬", + "鍛", + "壟", + "搜", + "撲", + "邀", + "亭", + "酯", + "邁", + "舒", + "脆", + "酶", + "閒", + "憂", + "酚", + "頑", + "羽", + "漲", + "卸", + "仗", + "陪", + "闢", + "懲", + "杭", + "姚", + "肚", + "捉", + "飄", + "漂", + "昆", + "欺", + "吾", + "郎", + "烷", + "汁", + "呵", + "飾", + "蕭", + "雅", + "郵", + "遷", + "燕", + "撒", + "姻", + "赴", + "宴", + "煩", + "債", + "帳", + "斑", + "鈴", + "旨", + "醇", + "董", + "餅", + "雛", + "姿", + "拌", + "傅", + "腹", + "妥", + "揉", + "賢", + "拆", + "歪", + "葡", + "胺", + "丟", + "浩", + "徽", + "昂", + "墊", + "擋", + "覽", + "貪", + "慰", + "繳", + "汪", + "慌", + "馮", + "諾", + "姜", + "誼", + "兇", + "劣", + "誣", + "耀", + "昏", + "躺", + "盈", + "騎", + "喬", + "溪", + "叢", + "盧", + "抹", + "悶", + "諮", + "刮", + "駕", + "纜", + "悟", + "摘", + "鉺", + "擲", + "頗", + "幻", + "柄", + "惠", + "慘", + "佳", + "仇", + "臘", + "窩", + "滌", + "劍", + "瞧", + "堡", + "潑", + "蔥", + "罩", + "霍", + "撈", + "胎", + "蒼", + "濱", + "倆", + "捅", + "湘", + "砍", + "霞", + "邵", + "萄", + "瘋", + "淮", + "遂", + "熊", + "糞", + "烘", + "宿", + "檔", + "戈", + "駁", + "嫂", + "裕", + "徙", + "箭", + "捐", + "腸", + "撐", + "曬", + "辨", + "殿", + "蓮", + "攤", + "攪", + "醬", + "屏", + "疫", + "哀", + "蔡", + "堵", + "沫", + "皺", + "暢", + "疊", + "閣", + "萊", + "敲", + "轄", + "鉤", + "痕", + "壩", + "巷", + "餓", + "禍", + "丘", + "玄", + "溜", + "曰", + "邏", + "彭", + "嘗", + "卿", + "妨", + "艇", + "吞", + "韋", + "怨", + "矮", + "歇" + } + }; + +// Word lists from: +// github.com/bitcoin/bips/blob/master/bip-0039/bip-0039-wordlists.md +const dictionary_list all +{ + &en, + &es, + &ja, + &it, + &fr, + &cs, + &ru, + &uk, + &zh_Hans, + &zh_Hant, +}; + +} // namespace language diff --git a/src/mnemonic/dictionary.h b/src/mnemonic/dictionary.h new file mode 100644 index 000000000..12de23bfe --- /dev/null +++ b/src/mnemonic/dictionary.h @@ -0,0 +1,44 @@ +#ifndef NAVCOIN_DICTIONARY_H +#define NAVCOIN_DICTIONARY_H + +#include +#include + +/** + * A valid mnemonic dictionary has exactly this many words. + */ +static constexpr size_t dictionary_size = 2048; + +/** + * Dictionary definitions for creating mnemonics. + * The bip39 spec calls this a "wordlist". + * This is a POD type, which means the compiler can write it directly + * to static memory with no run-time overhead. + */ +typedef std::array dictionary; + +/** + * A collection of candidate dictionaries for mnemonic metadata. + */ +typedef std::vector dictionary_list; + +namespace language { + +// Individual built-in languages: +extern const dictionary en; +extern const dictionary es; +extern const dictionary ja; +extern const dictionary it; +extern const dictionary fr; +extern const dictionary cs; +extern const dictionary ru; +extern const dictionary uk; +extern const dictionary zh_Hans; +extern const dictionary zh_Hant; + +// All built-in languages: +extern const dictionary_list all; + +} // namespace language + +#endif //NAVCOIN_DICTIONARY_H diff --git a/src/mnemonic/mnemonic.cpp b/src/mnemonic/mnemonic.cpp new file mode 100644 index 000000000..c24cf6523 --- /dev/null +++ b/src/mnemonic/mnemonic.cpp @@ -0,0 +1,272 @@ +/** + * Copyright (c) 2011-2019 libbitcoin developers (see AUTHORS) + * + * This file is part of libbitcoin. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +#include +#include +#include + +//! Boost Locale is its own library that requires an additional flag to link it "-lboost_locale" +// TODO: If we really need this we should check for it in the build-aux boost files +//#include + +#include + +// BIP-39 private constants. +static constexpr size_t bits_per_word = 11; +static constexpr size_t entropy_bit_divisor = 32; +static constexpr size_t hmac_iterations = 2048; +static constexpr uint8_t byte_bits = 8; +static const auto passphrase_prefix = "mnemonic"; + +///////////////////////// +// local helper methods// +///////////////////////// +long_hash pkcs5_pbkdf2_hmac_sha512(data_slice passphrase, data_slice salt, size_t iterations) +{ + long_hash hash; + const auto result = pkcs5_pbkdf2(passphrase.data(), passphrase.size(), salt.data(), salt.size(), hash.data(), + hash.size(), iterations); + + if (result != 0) + throw std::bad_alloc(); + + return hash; +} + +hash_digest sha256_hash(data_slice data) +{ + hash_digest hash; + SHA256_(data.data(), data.size(), hash.data()); + return hash; +} + +template +data_chunk to_chunk(const Source& bytes) +{ + return data_chunk(std::begin(bytes), std::end(bytes)); +} + +template +int find_position(const Container& list, const Element& value) +{ + const auto it = std::find(std::begin(list), std::end(list), value); + + if (it == std::end(list)) + return -1; + + return static_cast(std::distance(list.begin(), it)); +} + +inline data_chunk build_chunk(loaf slices) +{ + size_t size = 0; + for (const auto slice: slices) + size += slice.size(); + + data_chunk out; + out.reserve(size); + for (const auto slice: slices) + out.insert(out.end(), slice.begin(), slice.end()); + + return out; +} + +inline uint8_t bip39_shift(size_t bit) +{ + return (1 << (byte_bits - (bit % byte_bits) - 1)); +} +///////////////////////// + +bool validate_mnemonic(const word_list& words, const dictionary& lexicon) +{ + const auto word_count = words.size(); + if ((word_count % mnemonic_word_multiple) != 0) + return false; + + const auto total_bits = bits_per_word * word_count; + const auto check_bits = total_bits / (entropy_bit_divisor + 1); + const auto entropy_bits = total_bits - check_bits; + + size_t bit = 0; + data_chunk data((total_bits + byte_bits - 1) / byte_bits, 0); + + for (const auto& word: words) + { + const auto position = find_position(lexicon, word); + if (position == -1) + return false; + + for (size_t loop = 0; loop < bits_per_word; loop++, bit++) + { + if (position & (1 << (bits_per_word - loop - 1))) + { + const auto byte = bit / byte_bits; + data[byte] |= bip39_shift(bit); + } + } + } + + data.resize(entropy_bits / byte_bits); + const auto mnemonic = create_mnemonic(data, lexicon); + return std::equal(mnemonic.begin(), mnemonic.end(), words.begin()); +} + +data_chunk key_from_mnemonic(const word_list& words, const dictionary& lexicon) +{ + const auto word_count = words.size(); + if ((word_count % mnemonic_word_multiple) != 0) + return {}; + + const auto total_bits = bits_per_word * word_count; + const auto check_bits = total_bits / (entropy_bit_divisor + 1); + const auto entropy_bits = total_bits - check_bits; + + size_t bit = 0; + data_chunk data((total_bits + byte_bits - 1) / byte_bits, 0); + + for (const auto& word: words) + { + const auto position = find_position(lexicon, word); + if (position == -1) + return {}; + + for (size_t loop = 0; loop < bits_per_word; loop++, bit++) + { + if (position & (1 << (bits_per_word - loop - 1))) + { + const auto byte = bit / byte_bits; + data[byte] |= bip39_shift(bit); + } + } + } + + data.resize(entropy_bits / byte_bits); + const auto mnemonic = create_mnemonic(data, lexicon); + if (!std::equal(mnemonic.begin(), mnemonic.end(), words.begin())) + return {}; + else + return data; +} + +dictionary string_to_lexicon(const std::string& strLanguage) +{ + if (strLanguage == "english") + return language::en; + else if (strLanguage == "spanish") + return language::es; + else if (strLanguage == "italian") + return language::it; + else if (strLanguage == "japanese") + return language::ja; + else if (strLanguage == "french") + return language::fr; + else if (strLanguage == "russian") + return language::ru; + else if (strLanguage == "czech") + return language::cs; + else if (strLanguage == "ukrainian") + return language::uk; + else if (strLanguage == "simplified chinese") + return language::zh_Hans; + else if (strLanguage == "traditional chinese") + return language::zh_Hant; + + return language::en; +} + +word_list create_mnemonic(data_slice entropy, const dictionary &lexicon) +{ + if ((entropy.size() % mnemonic_seed_multiple) != 0) + return {}; + + const size_t entropy_bits = (entropy.size() * byte_bits); + const size_t check_bits = (entropy_bits / entropy_bit_divisor); + const size_t total_bits = (entropy_bits + check_bits); + const size_t word_count = (total_bits / bits_per_word); + + const auto data = build_chunk({entropy, sha256_hash(entropy)}); + + size_t bit = 0; + word_list words; + + for (size_t word = 0; word < word_count; word++) + { + size_t position = 0; + for (size_t loop = 0; loop < bits_per_word; loop++) + { + bit = (word * bits_per_word + loop); + position <<= 1; + + const auto byte = bit / byte_bits; + + if ((data[byte] & bip39_shift(bit)) > 0) + position++; + } + + words.push_back(lexicon[position]); + } + + return words; +} + +bool validate_mnemonic(const word_list& mnemonic, const dictionary_list& lexicons) +{ + for (const auto& lexicon: lexicons) + if (validate_mnemonic(mnemonic, *lexicon)) + return true; + + return false; +} + +long_hash decode_mnemonic(const word_list& mnemonic) +{ + const auto sentence = boost::join(mnemonic, " "); + return decode_mnemonic(sentence); +} + +long_hash decode_mnemonic(const std::string& mnemonic) +{ + const std::string salt(passphrase_prefix); + return pkcs5_pbkdf2_hmac_sha512(to_chunk(mnemonic), to_chunk(salt), + hmac_iterations); +} + +word_list sentence_to_word_list(const std::string& sentence) +{ + word_list words; + unsigned int i, prevPos = 0; + for (i = 0; i <= sentence.length(); i++) + { + if (i == sentence.length() || sentence[i] == ' ') + { + words.push_back(sentence.substr(prevPos, i - prevPos)); + prevPos = i + 1; + } + } + return words; +} + + +//long_hash decode_mnemonic(const word_list& mnemonic, +// const std::string& passphrase) +//{ +// const auto sentence = boost::join(mnemonic, " "); +// const std::string prefix(passphrase_prefix); +// const auto salt = boost::locale::normalize(prefix + passphrase, boost::locale::norm_nfkd); +// return pkcs5_pbkdf2_hmac_sha512(to_chunk(sentence), to_chunk(salt), hmac_iterations); +//} diff --git a/src/mnemonic/mnemonic.h b/src/mnemonic/mnemonic.h new file mode 100644 index 000000000..a9a4ec7ea --- /dev/null +++ b/src/mnemonic/mnemonic.h @@ -0,0 +1,102 @@ +/** + * Copyright (c) 2011-2019 libbitcoin developers (see AUTHORS) + * + * This file is part of libbitcoin. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#ifndef MNEMONIC_H +#define MNEMONIC_H + +#include +#include +#include +#include +#include +#include + +/** +* A valid mnemonic word count is evenly divisible by this number. +*/ +static size_t mnemonic_word_multiple = 3; + +/** +* A valid seed byte count is evenly divisible by this number. +*/ +static size_t mnemonic_seed_multiple = 4; + +template +using byte_array = std::array; + +/** +* Helpful type definitions +*/ +typedef std::vector word_list; +typedef array_slice data_slice; +typedef std::vector data_chunk; +typedef byte_array<64> long_hash; +typedef byte_array<32> hash_digest; +typedef std::initializer_list loaf; + +long_hash pkcs5_pbkdf2_hmac_sha512(data_slice passphrase, data_slice salt, size_t iterations); + +dictionary string_to_lexicon(const std::string& strLanguage); + +/** +* Create a new mnenomic (list of words) from provided entropy and a dictionary +* selection. The mnemonic can later be converted to a seed for use in wallet +* creation. Entropy byte count must be evenly divisible by 4. +*/ +word_list create_mnemonic(data_slice entropy, const dictionary &lexicon=language::en); + +/** +* Convert a mnemonic to a format for creating a CKey object. +*/ +data_chunk key_from_mnemonic(const word_list& words, const dictionary& lexicon=language::en); + +/** +* Checks a mnemonic against a dictionary to determine if the +* words are spelled correctly and the checksum matches. +* The words must have been created using mnemonic encoding. +*/ +bool validate_mnemonic(const word_list& mnemonic, const dictionary &lexicon); + +/** +* Checks that a mnemonic is valid in at least one of the provided languages. +*/ +bool validate_mnemonic(const word_list& mnemonic, const dictionary_list& lexicons=language::all); + +/** +* Convert a mnemonic with no passphrase to a wallet-generation seed. +*/ +long_hash decode_mnemonic(const word_list& mnemonic); +long_hash decode_mnemonic(const std::string& mnemonic); + +/** +* Convert a mnemonic and passphrase to a wallet-generation seed. +* Any passphrase can be used and will change the resulting seed. +*/ +long_hash decode_mnemonic(const word_list& mnemonic, + const std::string& passphrase); + +/** + * @brief sentence_to_word_list - converts a sentence in a vector with + * words + * @param sentence + * @return vector of words + */ +word_list sentence_to_word_list(const std::string& sentence); + +#endif diff --git a/src/qt/navcoingui.cpp b/src/qt/navcoingui.cpp index 02fbf9a64..2d987e2c4 100755 --- a/src/qt/navcoingui.cpp +++ b/src/qt/navcoingui.cpp @@ -150,13 +150,13 @@ NavCoinGUI::NavCoinGUI(const PlatformStyle *platformStyle, const NetworkStyle *n prevBlocks(0), spinnerFrame(0), fDontShowAgain(false), - lastDialogShown(0), unlockWalletAction(0), lockWalletAction(0), toggleStakingAction(0), + lastDialogShown(0), + platformStyle(platformStyle), updatePriceAction(0), - fShowingVoting(0), - platformStyle(platformStyle) + fShowingVoting(0) { GUIUtil::restoreWindowGeometry("nWindow", QSize(840, 600), this); //setFixedSize(QSize(840, 600)); diff --git a/src/qt/navtechinit.cpp b/src/qt/navtechinit.cpp index 5cb09c266..74949d237 100644 --- a/src/qt/navtechinit.cpp +++ b/src/qt/navtechinit.cpp @@ -25,7 +25,6 @@ NavTechInit::~NavTechInit() void NavTechInit::ShowNavtechIntro(bool exitAfter) { NavTechInit navtechinit; - navtechinit.setWindowIcon(QIcon(":icons/navcoin")); navtechinit.setStyleSheet(Skinize()); if(!navtechinit.exec()) diff --git a/src/qt/qt_libnavcoinqt_a-paymentserver-de1601f8.o.tmp b/src/qt/qt_libnavcoinqt_a-paymentserver-de1601f8.o.tmp new file mode 100644 index 000000000..e69de29bb diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp index dc9ea7fe2..e775595c6 100755 --- a/src/wallet/rpcdump.cpp +++ b/src/wallet/rpcdump.cpp @@ -16,6 +16,8 @@ #include "merkleblock.h" #include "core_io.h" +#include + #include #include @@ -653,37 +655,95 @@ UniValue dumpmasterprivkey(const UniValue& params, bool fHelp) if (fHelp || params.size() != 0) throw runtime_error( - "dumpmasterprivkey\n" - "\nReveals the current master private key.\n" - "\nResult:\n" - " \"key\" (string) The HD master private key\n" - "\nExamples:\n" - + HelpExampleCli("dumpmasterprivkey", "") - ); + "dumpmasterprivkey\n" + "\nReveals the current master private key.\n" + "\nResult:\n" + " \"key\" (string) The HD master private key\n" + "\nExamples:\n" + + HelpExampleCli("dumpmasterprivkey", "") + ); LOCK2(cs_main, pwalletMain->cs_wallet); EnsureWalletIsUnlocked(); CKeyID masterKeyID = pwalletMain->GetHDChain().masterKeyID; - if (!pwalletMain->IsHDEnabled()) - { - throw JSONRPCError(RPC_WALLET_ERROR, "Wallet is not a HD wallet."); - } - CKey key; - if (pwalletMain->GetKey(masterKeyID, key)) - { - CExtKey masterKey; - masterKey.SetMaster(key.begin(), key.size()); - - CNavCoinExtKey b58extkey; - b58extkey.SetKey(masterKey); - - return b58extkey.ToString(); - } - else - { - throw JSONRPCError(RPC_WALLET_ERROR, "Unable to retrieve HD master private key"); - return NullUniValue; - } - } + if (!pwalletMain->IsHDEnabled()) + { + throw JSONRPCError(RPC_WALLET_ERROR, "Wallet is not a HD wallet."); + } + CKey key; + if (pwalletMain->GetKey(masterKeyID, key)) + { + CExtKey masterKey; + masterKey.SetMaster(key.begin(), key.size()); + + CNavCoinExtKey b58extkey; + b58extkey.SetKey(masterKey); + + return b58extkey.ToString(); + } + else + { + throw JSONRPCError(RPC_WALLET_ERROR, "Unable to retrieve HD master private key"); + return NullUniValue; + } +} + +UniValue dumpmnemonic(const UniValue& params, bool fHelp) +{ + if (!EnsureWalletIsAvailable(fHelp)) + return NullUniValue; + + if (fHelp || params.size() > 1) + throw runtime_error( + "dumpmnemonic ( \"language\" )\n" + "\nReveals the mnemonic for the current master private key.\n" + "\nSupported languages:\n" + "\n - english, spanish, italian, japanese, french, russian, czech, ukrainian, simplified chinese and traditional chinese\n" + "\nArguments:\n" + "1. \"language\" (string, optional, english by default) The language for generating the mnemonic\n" + "\nExamples:\n" + + HelpExampleCli("dumpmnemonic", "") + + HelpExampleCli("dumpmnemonic", "spanish") + ); + + LOCK2(cs_main, pwalletMain->cs_wallet); + + EnsureWalletIsUnlocked(); + + CKeyID masterKeyID = pwalletMain->GetHDChain().masterKeyID; + if (!pwalletMain->IsHDEnabled()) + { + throw JSONRPCError(RPC_WALLET_ERROR, "Wallet is not a HD wallet."); + } + CKey key; + if (pwalletMain->GetKey(masterKeyID, key)) + { + std::vector keyData; + const unsigned char* ptrKeyData = key.begin(); + for (int i = 0; ptrKeyData != key.end(); i++) { + unsigned char byte = *ptrKeyData; + keyData.push_back(byte); + ptrKeyData++; + } + + std::string mnemonic; + word_list mnemonic_words = create_mnemonic(keyData, string_to_lexicon(params.size() == 1 ? params[0].get_str() : "english")); + for (auto it = mnemonic_words.begin(); it != mnemonic_words.end();) { + const auto word = *it; + mnemonic += word; + ++it; + if (it == mnemonic_words.end()) + break; + mnemonic += " "; + } + + return mnemonic; + } + else + { + throw JSONRPCError(RPC_WALLET_ERROR, "Unable to retrieve HD master private key"); + return NullUniValue; + } +} diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp index 426e50c34..6a95b1b8a 100644 --- a/src/wallet/rpcwallet.cpp +++ b/src/wallet/rpcwallet.cpp @@ -3537,6 +3537,7 @@ UniValue paymentrequestvote(const UniValue& params, bool fHelp) extern UniValue dumpprivkey(const UniValue& params, bool fHelp); // in rpcdump.cpp extern UniValue dumpmasterprivkey(const UniValue& params, bool fHelp); +extern UniValue dumpmnemonic(const UniValue& params, bool fHelp); extern UniValue importprivkey(const UniValue& params, bool fHelp); extern UniValue importaddress(const UniValue& params, bool fHelp); extern UniValue importpubkey(const UniValue& params, bool fHelp); @@ -3556,6 +3557,7 @@ static const CRPCCommand commands[] = { "wallet", "backupwallet", &backupwallet, true }, { "wallet", "dumpprivkey", &dumpprivkey, true }, { "wallet", "dumpmasterprivkey", &dumpmasterprivkey, true }, + { "wallet", "dumpmnemonic", &dumpmnemonic, true }, { "wallet", "dumpwallet", &dumpwallet, true }, { "wallet", "encryptwallet", &encryptwallet, true }, { "wallet", "getaccountaddress", &getaccountaddress, true }, diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp index f10418c76..f0330f315 100644 --- a/src/wallet/wallet.cpp +++ b/src/wallet/wallet.cpp @@ -1684,6 +1684,40 @@ CAmount CWallet::GetChange(const CTransaction& tx) const return nChange; } +CPubKey CWallet::ImportMnemonic(word_list mnemonic, dictionary lang) +{ + CKey key; + + std::vector vKey = key_from_mnemonic(mnemonic, lang); + + key.Set(vKey.begin(), vKey.end(), false); + + int64_t nCreationTime = GetTime(); + CKeyMetadata metadata(nCreationTime); + + // calculate the pubkey + CPubKey pubkey = key.GetPubKey(); + assert(key.VerifyPubKey(pubkey)); + + // set the hd keypath to "m" -> Master, refers the masterkeyid to itself + metadata.hdKeypath = "m"; + metadata.hdMasterKeyID = pubkey.GetID(); + + { + LOCK(cs_wallet); + + // mem store the metadata + mapKeyMetadata[pubkey.GetID()] = metadata; + + // write the key&metadata to the database + if (!AddKeyPubKey(key, pubkey)) + throw std::runtime_error("CWallet::GenerateNewKey(): AddKey failed"); + } + + return pubkey; +} + + CPubKey CWallet::GenerateNewHDMasterKey() { CKey key; @@ -3848,6 +3882,8 @@ std::string CWallet::GetWalletHelpString(bool showDebug) strUsage += HelpMessageOpt("-keypool=", strprintf(_("Set key pool size to (default: %u)"), DEFAULT_KEYPOOL_SIZE)); strUsage += HelpMessageOpt("-fallbackfee=", strprintf(_("A fee rate (in %s/kB) that will be used when fee estimation has insufficient data (default: %s)"), CURRENCY_UNIT, FormatMoney(DEFAULT_FALLBACK_FEE))); + strUsage += HelpMessageOpt("-importmnemonic=\"\"", _("Create a new wallet out of the specified mnemonic")); + strUsage += HelpMessageOpt("-mnemoniclanguage=", _("Use the specified language for the mnemonic import")); strUsage += HelpMessageOpt("-mintxfee=", strprintf(_("Fees (in %s/kB) smaller than this are considered zero fee for transaction creation (default: %s)"), CURRENCY_UNIT, FormatMoney(DEFAULT_TRANSACTION_MINFEE))); strUsage += HelpMessageOpt("-paytxfee=", strprintf(_("Fee (in %s/kB) to add to transactions you send (default: %s)"), @@ -3949,7 +3985,18 @@ bool CWallet::InitLoadWallet() if (GetBoolArg("-usehd", DEFAULT_USE_HD_WALLET) && walletInstance->hdChain.masterKeyID.IsNull()) { // generate a new master key CKey key; - CPubKey masterPubKey = walletInstance->GenerateNewHDMasterKey(); + CPubKey masterPubKey; + if (GetArg("-importmnemonic","") != "") { + word_list words = sentence_to_word_list(GetArg("-importmnemonic","")); + dictionary lexicon = string_to_lexicon(GetArg("-mnemoniclanguage","english")); + if (!validate_mnemonic(words, lexicon)) { + if (validate_mnemonic(words, language::all)) + return InitError(strprintf(_("The specified language does not correspond to the mnemonic."))); + return InitError(strprintf(_("You specified a wrong mnemonic"))); + } + masterPubKey = walletInstance->ImportMnemonic(words, lexicon); + } else + masterPubKey = walletInstance->GenerateNewHDMasterKey(); if (!walletInstance->SetHDMasterKey(masterPubKey)) throw std::runtime_error("CWallet::GenerateNewKey(): Storing master key failed"); } @@ -3962,6 +4009,9 @@ bool CWallet::InitLoadWallet() walletInstance->SetBestChain(chainActive.GetLocator()); } + else if (GetArg("-importmnemonic","") != "") { + return InitError(strprintf(_("You are trying to import a new mnemonic but a wallet already exists. Please rename the existing wallet.dat before trying to import again."))); + } else if (mapArgs.count("-usehd")) { bool useHD = GetBoolArg("-usehd", DEFAULT_USE_HD_WALLET); if (!walletInstance->hdChain.masterKeyID.IsNull() && !useHD) diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h index becc45370..85b452f41 100644 --- a/src/wallet/wallet.h +++ b/src/wallet/wallet.h @@ -7,6 +7,7 @@ #define NAVCOIN_WALLET_WALLET_H #include "amount.h" +#include "mnemonic/mnemonic.h" #include "streams.h" #include "tinyformat.h" #include "ui_interface.h" @@ -1001,6 +1002,7 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface /* Generates a new HD master key (will not be activated) */ CPubKey GenerateNewHDMasterKey(); + CPubKey ImportMnemonic(word_list mnemonic, dictionary lang); /* Set the current HD master key (will reset the chain child index counters) */ bool SetHDMasterKey(const CPubKey& key);