From 9bd3f10f41704a51524514807d28dfe9ad8f3b1b Mon Sep 17 00:00:00 2001
From: maciejhirsz <maciej.hirsz@gmail.com>
Date: Wed, 29 Mar 2017 17:07:58 +0200
Subject: [PATCH] Squashed: Public Node

---
 ethkey/src/brain.rs                        |    2 +-
 js/package.json                            |    2 +
 js/src/api/api.js                          |   16 +
 js/src/api/local/accounts/account.js       |   95 +
 js/src/api/local/accounts/accounts.js      |  120 +
 js/src/api/local/accounts/index.js         |   21 +
 js/src/api/local/ethkey/dictionary.js      | 7778 ++++++++++++++++++++
 js/src/api/local/ethkey/index.js           |   87 +
 js/src/api/local/ethkey/index.spec.js      |   95 +
 js/src/api/local/ethkey/worker.js          |   89 +
 js/src/api/local/index.js                  |   17 +
 js/src/api/local/middleware.js             |  173 +
 js/src/api/local/transactions.js           |  123 +
 js/src/api/local/transactions.spec.js      |   68 +
 js/src/api/transport/error.js              |    4 +
 js/src/api/transport/http/http.js          |    2 +-
 js/src/api/transport/index.js              |    3 +-
 js/src/api/transport/jsonRpcBase.js        |   61 +
 js/src/api/transport/middleware.js         |   42 +
 js/src/api/transport/middleware.spec.js    |   58 +
 js/src/api/transport/ws/ws.js              |    2 +-
 js/webpack/libraries.js                    |    5 +
 parity/cli/config.full.toml                |    1 +
 parity/cli/mod.rs                          |    4 +
 parity/cli/usage.txt                       |    3 +
 parity/configuration.rs                    |   27 +-
 parity/rpc_apis.rs                         |    2 +-
 parity/run.rs                              |    7 +-
 rpc/src/v1/helpers/accounts.rs             |   27 +
 rpc/src/v1/helpers/errors.rs               |    8 +
 rpc/src/v1/helpers/mod.rs                  |    1 +
 rpc/src/v1/impls/eth.rs                    |   15 +-
 rpc/src/v1/impls/light/parity.rs           |    2 +-
 rpc/src/v1/impls/parity.rs                 |   29 +-
 rpc/src/v1/impls/parity_accounts.rs        |   79 +-
 rpc/src/v1/impls/personal.rs               |   19 +-
 rpc/src/v1/impls/signer.rs                 |   13 +-
 rpc/src/v1/impls/signing.rs                |   13 +-
 rpc/src/v1/impls/signing_unsafe.rs         |   13 +-
 rpc/src/v1/tests/mocked/eth.rs             |    5 +-
 rpc/src/v1/tests/mocked/parity.rs          |    4 +-
 rpc/src/v1/tests/mocked/parity_accounts.rs |    3 +-
 rpc/src/v1/tests/mocked/personal.rs        |    3 +-
 rpc/src/v1/tests/mocked/signer.rs          |    3 +-
 rpc/src/v1/tests/mocked/signing.rs         |    5 +-
 45 files changed, 9060 insertions(+), 89 deletions(-)
 create mode 100644 js/src/api/local/accounts/account.js
 create mode 100644 js/src/api/local/accounts/accounts.js
 create mode 100644 js/src/api/local/accounts/index.js
 create mode 100644 js/src/api/local/ethkey/dictionary.js
 create mode 100644 js/src/api/local/ethkey/index.js
 create mode 100644 js/src/api/local/ethkey/index.spec.js
 create mode 100644 js/src/api/local/ethkey/worker.js
 create mode 100644 js/src/api/local/index.js
 create mode 100644 js/src/api/local/middleware.js
 create mode 100644 js/src/api/local/transactions.js
 create mode 100644 js/src/api/local/transactions.spec.js
 create mode 100644 js/src/api/transport/middleware.js
 create mode 100644 js/src/api/transport/middleware.spec.js
 create mode 100644 rpc/src/v1/helpers/accounts.rs

diff --git a/ethkey/src/brain.rs b/ethkey/src/brain.rs
index 605c05f98..5ed23b404 100644
--- a/ethkey/src/brain.rs
+++ b/ethkey/src/brain.rs
@@ -29,7 +29,7 @@ impl Brain {
 impl Generator for Brain {
 	fn generate(self) -> Result<KeyPair, Error> {
 		let seed = self.0;
-		let mut secret = seed.bytes().collect::<Vec<u8>>().keccak256();
+		let mut secret = seed.into_bytes().keccak256();
 
 		let mut i = 0;
 		loop {
diff --git a/js/package.json b/js/package.json
index 803efb84c..846237439 100644
--- a/js/package.json
+++ b/js/package.json
@@ -171,6 +171,7 @@
     "geopattern": "1.2.3",
     "isomorphic-fetch": "2.2.1",
     "js-sha3": "0.5.5",
+    "keythereum": "0.4.3",
     "lodash": "4.17.2",
     "loglevel": "1.4.1",
     "marked": "0.3.6",
@@ -207,6 +208,7 @@
     "redux-thunk": "2.1.0",
     "rlp": "2.0.0",
     "scryptsy": "2.0.0",
+    "secp256k1": "3.2.5",
     "solc": "ngotchac/solc-js",
     "store": "1.3.20",
     "sw-toolbox": "^3.6.0",
diff --git a/js/src/api/api.js b/js/src/api/api.js
index 35158b0d8..c797cae58 100644
--- a/js/src/api/api.js
+++ b/js/src/api/api.js
@@ -23,6 +23,7 @@ import { Db, Eth, Parity, Net, Personal, Shh, Signer, Trace, Web3 } from './rpc'
 import Subscriptions from './subscriptions';
 import util from './util';
 import { isFunction } from './util/types';
+import { LocalAccountsMiddleware } from './local';
 
 export default class Api extends EventEmitter {
   constructor (transport) {
@@ -45,6 +46,21 @@ export default class Api extends EventEmitter {
     this._web3 = new Web3(transport);
 
     this._subscriptions = new Subscriptions(this);
+
+    // Doing a request here in test env would cause an error
+    if (process.env.NODE_ENV !== 'test') {
+      const middleware = this.parity
+        .nodeKind()
+        .then((nodeKind) => {
+          if (nodeKind.availability === 'public') {
+            return new LocalAccountsMiddleware(transport);
+          }
+
+          return null;
+        });
+
+      transport.addMiddleware(middleware);
+    }
   }
 
   get db () {
diff --git a/js/src/api/local/accounts/account.js b/js/src/api/local/accounts/account.js
new file mode 100644
index 000000000..da9de1359
--- /dev/null
+++ b/js/src/api/local/accounts/account.js
@@ -0,0 +1,95 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import { keythereum } from '../ethkey';
+
+export default class Account {
+  constructor (persist, data) {
+    const {
+      keyObject,
+      meta = {},
+      name = ''
+    } = data;
+
+    this._persist = persist;
+    this._keyObject = keyObject;
+    this._name = name;
+    this._meta = meta;
+  }
+
+  isValidPassword (password) {
+    try {
+      keythereum.recover(Buffer.from(password), this._keyObject);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  get address () {
+    return `0x${this._keyObject.address.toLowerCase()}`;
+  }
+
+  get name () {
+    return this._name;
+  }
+
+  set name (name) {
+    this._name = name;
+
+    this._persist();
+  }
+
+  get meta () {
+    return JSON.stringify(this._meta);
+  }
+
+  set meta (meta) {
+    this._meta = JSON.parse(meta);
+
+    this._persist();
+  }
+
+  get uuid () {
+    return this._keyObject.id;
+  }
+
+  decryptPrivateKey (password) {
+    return keythereum.recover(Buffer.from(password), this._keyObject);
+  }
+
+  static fromPrivateKey (persist, key, password) {
+    const iv = keythereum.crypto.randomBytes(16);
+    const salt = keythereum.crypto.randomBytes(32);
+
+    // Keythereum will fail if `password` is an empty string
+    password = Buffer.from(password);
+
+    const keyObject = keythereum.dump(password, key, salt, iv);
+
+    const account = new Account(persist, { keyObject });
+
+    return account;
+  }
+
+  toJSON () {
+    return {
+      keyObject: this._keyObject,
+      name: this._name,
+      meta: this._meta
+    };
+  }
+}
diff --git a/js/src/api/local/accounts/accounts.js b/js/src/api/local/accounts/accounts.js
new file mode 100644
index 000000000..576addcb1
--- /dev/null
+++ b/js/src/api/local/accounts/accounts.js
@@ -0,0 +1,120 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import Account from './account';
+import localStore from 'store';
+import { debounce } from 'lodash';
+
+const NULL_ADDRESS = '0x0000000000000000000000000000000000000000';
+const LS_STORE_KEY = '_parity::localAccounts';
+
+export default class Accounts {
+  constructor (data = localStore.get(LS_STORE_KEY) || {}) {
+    const {
+      last = NULL_ADDRESS,
+      store = []
+    } = data;
+
+    this.persist = debounce(() => {
+      localStore.set(LS_STORE_KEY, this);
+    }, 100);
+
+    this._last = last;
+    this._store = store.map((data) => new Account(this.persist, data));
+  }
+
+  create (secret, password) {
+    const privateKey = Buffer.from(secret.slice(2), 'hex');
+    const account = Account.fromPrivateKey(this.persist, privateKey, password);
+
+    this._store.push(account);
+    this.lastAddress = account.address;
+
+    this.persist();
+
+    return account.address;
+  }
+
+  set lastAddress (value) {
+    this._last = value.toLowerCase();
+  }
+
+  get lastAddress () {
+    return this._last;
+  }
+
+  get (address) {
+    address = address.toLowerCase();
+
+    this.lastAddress = address;
+
+    const account = this._store.find((account) => account.address === address);
+
+    if (!account) {
+      throw new Error(`Account not found: ${address}`);
+    }
+
+    return account;
+  }
+
+  remove (address, password) {
+    address = address.toLowerCase();
+
+    const index = this._store.findIndex((account) => account.address === address);
+
+    if (index === -1) {
+      return false;
+    }
+
+    const account = this._store[index];
+
+    if (!account.isValidPassword(password)) {
+      console.log('invalid password');
+      return false;
+    }
+
+    if (address === this.lastAddress) {
+      this.lastAddress = NULL_ADDRESS;
+    }
+
+    this._store.splice(index, 1);
+
+    this.persist();
+
+    return true;
+  }
+
+  mapArray (mapper) {
+    return this._store.map(mapper);
+  }
+
+  mapObject (mapper) {
+    const result = {};
+
+    this._store.forEach((account) => {
+      result[account.address] = mapper(account);
+    });
+
+    return result;
+  }
+
+  toJSON () {
+    return {
+      last: this._last,
+      store: this._store
+    };
+  }
+}
diff --git a/js/src/api/local/accounts/index.js b/js/src/api/local/accounts/index.js
new file mode 100644
index 000000000..800cf95f6
--- /dev/null
+++ b/js/src/api/local/accounts/index.js
@@ -0,0 +1,21 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import Accounts from './accounts';
+
+const accounts = new Accounts();
+
+export default accounts;
diff --git a/js/src/api/local/ethkey/dictionary.js b/js/src/api/local/ethkey/dictionary.js
new file mode 100644
index 000000000..7cfdb8e36
--- /dev/null
+++ b/js/src/api/local/ethkey/dictionary.js
@@ -0,0 +1,7778 @@
+export default [
+  'abacus',
+  'abdomen',
+  'abdominal',
+  'abide',
+  'abiding',
+  'ability',
+  'ablaze',
+  'able',
+  'abnormal',
+  'abrasion',
+  'abrasive',
+  'abreast',
+  'abridge',
+  'abroad',
+  'abruptly',
+  'absence',
+  'absentee',
+  'absently',
+  'absinthe',
+  'absolute',
+  'absolve',
+  'abstain',
+  'abstract',
+  'absurd',
+  'accent',
+  'acclaim',
+  'acclimate',
+  'accompany',
+  'account',
+  'accuracy',
+  'accurate',
+  'accustom',
+  'acetone',
+  'achiness',
+  'aching',
+  'acid',
+  'acorn',
+  'acquaint',
+  'acquire',
+  'acre',
+  'acrobat',
+  'acronym',
+  'acting',
+  'action',
+  'activate',
+  'activator',
+  'active',
+  'activism',
+  'activist',
+  'activity',
+  'actress',
+  'acts',
+  'acutely',
+  'acuteness',
+  'aeration',
+  'aerobics',
+  'aerosol',
+  'aerospace',
+  'afar',
+  'affair',
+  'affected',
+  'affecting',
+  'affection',
+  'affidavit',
+  'affiliate',
+  'affirm',
+  'affix',
+  'afflicted',
+  'affluent',
+  'afford',
+  'affront',
+  'aflame',
+  'afloat',
+  'aflutter',
+  'afoot',
+  'afraid',
+  'afterglow',
+  'afterlife',
+  'aftermath',
+  'aftermost',
+  'afternoon',
+  'aged',
+  'ageless',
+  'agency',
+  'agenda',
+  'agent',
+  'aggregate',
+  'aghast',
+  'agile',
+  'agility',
+  'aging',
+  'agnostic',
+  'agonize',
+  'agonizing',
+  'agony',
+  'agreeable',
+  'agreeably',
+  'agreed',
+  'agreeing',
+  'agreement',
+  'aground',
+  'ahead',
+  'ahoy',
+  'aide',
+  'aids',
+  'aim',
+  'ajar',
+  'alabaster',
+  'alarm',
+  'albatross',
+  'album',
+  'alfalfa',
+  'algebra',
+  'algorithm',
+  'alias',
+  'alibi',
+  'alienable',
+  'alienate',
+  'aliens',
+  'alike',
+  'alive',
+  'alkaline',
+  'alkalize',
+  'almanac',
+  'almighty',
+  'almost',
+  'aloe',
+  'aloft',
+  'aloha',
+  'alone',
+  'alongside',
+  'aloof',
+  'alphabet',
+  'alright',
+  'although',
+  'altitude',
+  'alto',
+  'aluminum',
+  'alumni',
+  'always',
+  'amaretto',
+  'amaze',
+  'amazingly',
+  'amber',
+  'ambiance',
+  'ambiguity',
+  'ambiguous',
+  'ambition',
+  'ambitious',
+  'ambulance',
+  'ambush',
+  'amendable',
+  'amendment',
+  'amends',
+  'amenity',
+  'amiable',
+  'amicably',
+  'amid',
+  'amigo',
+  'amino',
+  'amiss',
+  'ammonia',
+  'ammonium',
+  'amnesty',
+  'amniotic',
+  'among',
+  'amount',
+  'amperage',
+  'ample',
+  'amplifier',
+  'amplify',
+  'amply',
+  'amuck',
+  'amulet',
+  'amusable',
+  'amused',
+  'amusement',
+  'amuser',
+  'amusing',
+  'anaconda',
+  'anaerobic',
+  'anagram',
+  'anatomist',
+  'anatomy',
+  'anchor',
+  'anchovy',
+  'ancient',
+  'android',
+  'anemia',
+  'anemic',
+  'aneurism',
+  'anew',
+  'angelfish',
+  'angelic',
+  'anger',
+  'angled',
+  'angler',
+  'angles',
+  'angling',
+  'angrily',
+  'angriness',
+  'anguished',
+  'angular',
+  'animal',
+  'animate',
+  'animating',
+  'animation',
+  'animator',
+  'anime',
+  'animosity',
+  'ankle',
+  'annex',
+  'annotate',
+  'announcer',
+  'annoying',
+  'annually',
+  'annuity',
+  'anointer',
+  'another',
+  'answering',
+  'antacid',
+  'antarctic',
+  'anteater',
+  'antelope',
+  'antennae',
+  'anthem',
+  'anthill',
+  'anthology',
+  'antibody',
+  'antics',
+  'antidote',
+  'antihero',
+  'antiquely',
+  'antiques',
+  'antiquity',
+  'antirust',
+  'antitoxic',
+  'antitrust',
+  'antiviral',
+  'antivirus',
+  'antler',
+  'antonym',
+  'antsy',
+  'anvil',
+  'anybody',
+  'anyhow',
+  'anymore',
+  'anyone',
+  'anyplace',
+  'anything',
+  'anytime',
+  'anyway',
+  'anywhere',
+  'aorta',
+  'apache',
+  'apostle',
+  'appealing',
+  'appear',
+  'appease',
+  'appeasing',
+  'appendage',
+  'appendix',
+  'appetite',
+  'appetizer',
+  'applaud',
+  'applause',
+  'apple',
+  'appliance',
+  'applicant',
+  'applied',
+  'apply',
+  'appointee',
+  'appraisal',
+  'appraiser',
+  'apprehend',
+  'approach',
+  'approval',
+  'approve',
+  'apricot',
+  'april',
+  'apron',
+  'aptitude',
+  'aptly',
+  'aqua',
+  'aqueduct',
+  'arbitrary',
+  'arbitrate',
+  'ardently',
+  'area',
+  'arena',
+  'arguable',
+  'arguably',
+  'argue',
+  'arise',
+  'armadillo',
+  'armband',
+  'armchair',
+  'armed',
+  'armful',
+  'armhole',
+  'arming',
+  'armless',
+  'armoire',
+  'armored',
+  'armory',
+  'armrest',
+  'army',
+  'aroma',
+  'arose',
+  'around',
+  'arousal',
+  'arrange',
+  'array',
+  'arrest',
+  'arrival',
+  'arrive',
+  'arrogance',
+  'arrogant',
+  'arson',
+  'art',
+  'ascend',
+  'ascension',
+  'ascent',
+  'ascertain',
+  'ashamed',
+  'ashen',
+  'ashes',
+  'ashy',
+  'aside',
+  'askew',
+  'asleep',
+  'asparagus',
+  'aspect',
+  'aspirate',
+  'aspire',
+  'aspirin',
+  'astonish',
+  'astound',
+  'astride',
+  'astrology',
+  'astronaut',
+  'astronomy',
+  'astute',
+  'atlantic',
+  'atlas',
+  'atom',
+  'atonable',
+  'atop',
+  'atrium',
+  'atrocious',
+  'atrophy',
+  'attach',
+  'attain',
+  'attempt',
+  'attendant',
+  'attendee',
+  'attention',
+  'attentive',
+  'attest',
+  'attic',
+  'attire',
+  'attitude',
+  'attractor',
+  'attribute',
+  'atypical',
+  'auction',
+  'audacious',
+  'audacity',
+  'audible',
+  'audibly',
+  'audience',
+  'audio',
+  'audition',
+  'augmented',
+  'august',
+  'authentic',
+  'author',
+  'autism',
+  'autistic',
+  'autograph',
+  'automaker',
+  'automated',
+  'automatic',
+  'autopilot',
+  'available',
+  'avalanche',
+  'avatar',
+  'avenge',
+  'avenging',
+  'avenue',
+  'average',
+  'aversion',
+  'avert',
+  'aviation',
+  'aviator',
+  'avid',
+  'avoid',
+  'await',
+  'awaken',
+  'award',
+  'aware',
+  'awhile',
+  'awkward',
+  'awning',
+  'awoke',
+  'awry',
+  'axis',
+  'babble',
+  'babbling',
+  'babied',
+  'baboon',
+  'backache',
+  'backboard',
+  'backboned',
+  'backdrop',
+  'backed',
+  'backer',
+  'backfield',
+  'backfire',
+  'backhand',
+  'backing',
+  'backlands',
+  'backlash',
+  'backless',
+  'backlight',
+  'backlit',
+  'backlog',
+  'backpack',
+  'backpedal',
+  'backrest',
+  'backroom',
+  'backshift',
+  'backside',
+  'backslid',
+  'backspace',
+  'backspin',
+  'backstab',
+  'backstage',
+  'backtalk',
+  'backtrack',
+  'backup',
+  'backward',
+  'backwash',
+  'backwater',
+  'backyard',
+  'bacon',
+  'bacteria',
+  'bacterium',
+  'badass',
+  'badge',
+  'badland',
+  'badly',
+  'badness',
+  'baffle',
+  'baffling',
+  'bagel',
+  'bagful',
+  'baggage',
+  'bagged',
+  'baggie',
+  'bagginess',
+  'bagging',
+  'baggy',
+  'bagpipe',
+  'baguette',
+  'baked',
+  'bakery',
+  'bakeshop',
+  'baking',
+  'balance',
+  'balancing',
+  'balcony',
+  'balmy',
+  'balsamic',
+  'bamboo',
+  'banana',
+  'banish',
+  'banister',
+  'banjo',
+  'bankable',
+  'bankbook',
+  'banked',
+  'banker',
+  'banking',
+  'banknote',
+  'bankroll',
+  'banner',
+  'bannister',
+  'banshee',
+  'banter',
+  'barbecue',
+  'barbed',
+  'barbell',
+  'barber',
+  'barcode',
+  'barge',
+  'bargraph',
+  'barista',
+  'baritone',
+  'barley',
+  'barmaid',
+  'barman',
+  'barn',
+  'barometer',
+  'barrack',
+  'barracuda',
+  'barrel',
+  'barrette',
+  'barricade',
+  'barrier',
+  'barstool',
+  'bartender',
+  'barterer',
+  'bash',
+  'basically',
+  'basics',
+  'basil',
+  'basin',
+  'basis',
+  'basket',
+  'batboy',
+  'batch',
+  'bath',
+  'baton',
+  'bats',
+  'battalion',
+  'battered',
+  'battering',
+  'battery',
+  'batting',
+  'battle',
+  'bauble',
+  'bazooka',
+  'blabber',
+  'bladder',
+  'blade',
+  'blah',
+  'blame',
+  'blaming',
+  'blanching',
+  'blandness',
+  'blank',
+  'blaspheme',
+  'blasphemy',
+  'blast',
+  'blatancy',
+  'blatantly',
+  'blazer',
+  'blazing',
+  'bleach',
+  'bleak',
+  'bleep',
+  'blemish',
+  'blend',
+  'bless',
+  'blighted',
+  'blimp',
+  'bling',
+  'blinked',
+  'blinker',
+  'blinking',
+  'blinks',
+  'blip',
+  'blissful',
+  'blitz',
+  'blizzard',
+  'bloated',
+  'bloating',
+  'blob',
+  'blog',
+  'bloomers',
+  'blooming',
+  'blooper',
+  'blot',
+  'blouse',
+  'blubber',
+  'bluff',
+  'bluish',
+  'blunderer',
+  'blunt',
+  'blurb',
+  'blurred',
+  'blurry',
+  'blurt',
+  'blush',
+  'blustery',
+  'boaster',
+  'boastful',
+  'boasting',
+  'boat',
+  'bobbed',
+  'bobbing',
+  'bobble',
+  'bobcat',
+  'bobsled',
+  'bobtail',
+  'bodacious',
+  'body',
+  'bogged',
+  'boggle',
+  'bogus',
+  'boil',
+  'bok',
+  'bolster',
+  'bolt',
+  'bonanza',
+  'bonded',
+  'bonding',
+  'bondless',
+  'boned',
+  'bonehead',
+  'boneless',
+  'bonelike',
+  'boney',
+  'bonfire',
+  'bonnet',
+  'bonsai',
+  'bonus',
+  'bony',
+  'boogeyman',
+  'boogieman',
+  'book',
+  'boondocks',
+  'booted',
+  'booth',
+  'bootie',
+  'booting',
+  'bootlace',
+  'bootleg',
+  'boots',
+  'boozy',
+  'borax',
+  'boring',
+  'borough',
+  'borrower',
+  'borrowing',
+  'boss',
+  'botanical',
+  'botanist',
+  'botany',
+  'botch',
+  'both',
+  'bottle',
+  'bottling',
+  'bottom',
+  'bounce',
+  'bouncing',
+  'bouncy',
+  'bounding',
+  'boundless',
+  'bountiful',
+  'bovine',
+  'boxcar',
+  'boxer',
+  'boxing',
+  'boxlike',
+  'boxy',
+  'breach',
+  'breath',
+  'breeches',
+  'breeching',
+  'breeder',
+  'breeding',
+  'breeze',
+  'breezy',
+  'brethren',
+  'brewery',
+  'brewing',
+  'briar',
+  'bribe',
+  'brick',
+  'bride',
+  'bridged',
+  'brigade',
+  'bright',
+  'brilliant',
+  'brim',
+  'bring',
+  'brink',
+  'brisket',
+  'briskly',
+  'briskness',
+  'bristle',
+  'brittle',
+  'broadband',
+  'broadcast',
+  'broaden',
+  'broadly',
+  'broadness',
+  'broadside',
+  'broadways',
+  'broiler',
+  'broiling',
+  'broken',
+  'broker',
+  'bronchial',
+  'bronco',
+  'bronze',
+  'bronzing',
+  'brook',
+  'broom',
+  'brought',
+  'browbeat',
+  'brownnose',
+  'browse',
+  'browsing',
+  'bruising',
+  'brunch',
+  'brunette',
+  'brunt',
+  'brush',
+  'brussels',
+  'brute',
+  'brutishly',
+  'bubble',
+  'bubbling',
+  'bubbly',
+  'buccaneer',
+  'bucked',
+  'bucket',
+  'buckle',
+  'buckshot',
+  'buckskin',
+  'bucktooth',
+  'buckwheat',
+  'buddhism',
+  'buddhist',
+  'budding',
+  'buddy',
+  'budget',
+  'buffalo',
+  'buffed',
+  'buffer',
+  'buffing',
+  'buffoon',
+  'buggy',
+  'bulb',
+  'bulge',
+  'bulginess',
+  'bulgur',
+  'bulk',
+  'bulldog',
+  'bulldozer',
+  'bullfight',
+  'bullfrog',
+  'bullhorn',
+  'bullion',
+  'bullish',
+  'bullpen',
+  'bullring',
+  'bullseye',
+  'bullwhip',
+  'bully',
+  'bunch',
+  'bundle',
+  'bungee',
+  'bunion',
+  'bunkbed',
+  'bunkhouse',
+  'bunkmate',
+  'bunny',
+  'bunt',
+  'busboy',
+  'bush',
+  'busily',
+  'busload',
+  'bust',
+  'busybody',
+  'buzz',
+  'cabana',
+  'cabbage',
+  'cabbie',
+  'cabdriver',
+  'cable',
+  'caboose',
+  'cache',
+  'cackle',
+  'cacti',
+  'cactus',
+  'caddie',
+  'caddy',
+  'cadet',
+  'cadillac',
+  'cadmium',
+  'cage',
+  'cahoots',
+  'cake',
+  'calamari',
+  'calamity',
+  'calcium',
+  'calculate',
+  'calculus',
+  'caliber',
+  'calibrate',
+  'calm',
+  'caloric',
+  'calorie',
+  'calzone',
+  'camcorder',
+  'cameo',
+  'camera',
+  'camisole',
+  'camper',
+  'campfire',
+  'camping',
+  'campsite',
+  'campus',
+  'canal',
+  'canary',
+  'cancel',
+  'candied',
+  'candle',
+  'candy',
+  'cane',
+  'canine',
+  'canister',
+  'cannabis',
+  'canned',
+  'canning',
+  'cannon',
+  'cannot',
+  'canola',
+  'canon',
+  'canopener',
+  'canopy',
+  'canteen',
+  'canyon',
+  'capable',
+  'capably',
+  'capacity',
+  'cape',
+  'capillary',
+  'capital',
+  'capitol',
+  'capped',
+  'capricorn',
+  'capsize',
+  'capsule',
+  'caption',
+  'captivate',
+  'captive',
+  'captivity',
+  'capture',
+  'caramel',
+  'carat',
+  'caravan',
+  'carbon',
+  'cardboard',
+  'carded',
+  'cardiac',
+  'cardigan',
+  'cardinal',
+  'cardstock',
+  'carefully',
+  'caregiver',
+  'careless',
+  'caress',
+  'caretaker',
+  'cargo',
+  'caring',
+  'carless',
+  'carload',
+  'carmaker',
+  'carnage',
+  'carnation',
+  'carnival',
+  'carnivore',
+  'carol',
+  'carpenter',
+  'carpentry',
+  'carpool',
+  'carport',
+  'carried',
+  'carrot',
+  'carrousel',
+  'carry',
+  'cartel',
+  'cartload',
+  'carton',
+  'cartoon',
+  'cartridge',
+  'cartwheel',
+  'carve',
+  'carving',
+  'carwash',
+  'cascade',
+  'case',
+  'cash',
+  'casing',
+  'casino',
+  'casket',
+  'cassette',
+  'casually',
+  'casualty',
+  'catacomb',
+  'catalog',
+  'catalyst',
+  'catalyze',
+  'catapult',
+  'cataract',
+  'catatonic',
+  'catcall',
+  'catchable',
+  'catcher',
+  'catching',
+  'catchy',
+  'caterer',
+  'catering',
+  'catfight',
+  'catfish',
+  'cathedral',
+  'cathouse',
+  'catlike',
+  'catnap',
+  'catnip',
+  'catsup',
+  'cattail',
+  'cattishly',
+  'cattle',
+  'catty',
+  'catwalk',
+  'caucasian',
+  'caucus',
+  'causal',
+  'causation',
+  'cause',
+  'causing',
+  'cauterize',
+  'caution',
+  'cautious',
+  'cavalier',
+  'cavalry',
+  'caviar',
+  'cavity',
+  'cedar',
+  'celery',
+  'celestial',
+  'celibacy',
+  'celibate',
+  'celtic',
+  'cement',
+  'census',
+  'ceramics',
+  'ceremony',
+  'certainly',
+  'certainty',
+  'certified',
+  'certify',
+  'cesarean',
+  'cesspool',
+  'chafe',
+  'chaffing',
+  'chain',
+  'chair',
+  'chalice',
+  'challenge',
+  'chamber',
+  'chamomile',
+  'champion',
+  'chance',
+  'change',
+  'channel',
+  'chant',
+  'chaos',
+  'chaperone',
+  'chaplain',
+  'chapped',
+  'chaps',
+  'chapter',
+  'character',
+  'charbroil',
+  'charcoal',
+  'charger',
+  'charging',
+  'chariot',
+  'charity',
+  'charm',
+  'charred',
+  'charter',
+  'charting',
+  'chase',
+  'chasing',
+  'chaste',
+  'chastise',
+  'chastity',
+  'chatroom',
+  'chatter',
+  'chatting',
+  'chatty',
+  'cheating',
+  'cheddar',
+  'cheek',
+  'cheer',
+  'cheese',
+  'cheesy',
+  'chef',
+  'chemicals',
+  'chemist',
+  'chemo',
+  'cherisher',
+  'cherub',
+  'chess',
+  'chest',
+  'chevron',
+  'chevy',
+  'chewable',
+  'chewer',
+  'chewing',
+  'chewy',
+  'chief',
+  'chihuahua',
+  'childcare',
+  'childhood',
+  'childish',
+  'childless',
+  'childlike',
+  'chili',
+  'chill',
+  'chimp',
+  'chip',
+  'chirping',
+  'chirpy',
+  'chitchat',
+  'chivalry',
+  'chive',
+  'chloride',
+  'chlorine',
+  'choice',
+  'chokehold',
+  'choking',
+  'chomp',
+  'chooser',
+  'choosing',
+  'choosy',
+  'chop',
+  'chosen',
+  'chowder',
+  'chowtime',
+  'chrome',
+  'chubby',
+  'chuck',
+  'chug',
+  'chummy',
+  'chump',
+  'chunk',
+  'churn',
+  'chute',
+  'cider',
+  'cilantro',
+  'cinch',
+  'cinema',
+  'cinnamon',
+  'circle',
+  'circling',
+  'circular',
+  'circulate',
+  'circus',
+  'citable',
+  'citadel',
+  'citation',
+  'citizen',
+  'citric',
+  'citrus',
+  'city',
+  'civic',
+  'civil',
+  'clad',
+  'claim',
+  'clambake',
+  'clammy',
+  'clamor',
+  'clamp',
+  'clamshell',
+  'clang',
+  'clanking',
+  'clapped',
+  'clapper',
+  'clapping',
+  'clarify',
+  'clarinet',
+  'clarity',
+  'clash',
+  'clasp',
+  'class',
+  'clatter',
+  'clause',
+  'clavicle',
+  'claw',
+  'clay',
+  'clean',
+  'clear',
+  'cleat',
+  'cleaver',
+  'cleft',
+  'clench',
+  'clergyman',
+  'clerical',
+  'clerk',
+  'clever',
+  'clicker',
+  'client',
+  'climate',
+  'climatic',
+  'cling',
+  'clinic',
+  'clinking',
+  'clip',
+  'clique',
+  'cloak',
+  'clobber',
+  'clock',
+  'clone',
+  'cloning',
+  'closable',
+  'closure',
+  'clothes',
+  'clothing',
+  'cloud',
+  'clover',
+  'clubbed',
+  'clubbing',
+  'clubhouse',
+  'clump',
+  'clumsily',
+  'clumsy',
+  'clunky',
+  'clustered',
+  'clutch',
+  'clutter',
+  'coach',
+  'coagulant',
+  'coastal',
+  'coaster',
+  'coasting',
+  'coastland',
+  'coastline',
+  'coat',
+  'coauthor',
+  'cobalt',
+  'cobbler',
+  'cobweb',
+  'cocoa',
+  'coconut',
+  'cod',
+  'coeditor',
+  'coerce',
+  'coexist',
+  'coffee',
+  'cofounder',
+  'cognition',
+  'cognitive',
+  'cogwheel',
+  'coherence',
+  'coherent',
+  'cohesive',
+  'coil',
+  'coke',
+  'cola',
+  'cold',
+  'coleslaw',
+  'coliseum',
+  'collage',
+  'collapse',
+  'collar',
+  'collected',
+  'collector',
+  'collide',
+  'collie',
+  'collision',
+  'colonial',
+  'colonist',
+  'colonize',
+  'colony',
+  'colossal',
+  'colt',
+  'coma',
+  'come',
+  'comfort',
+  'comfy',
+  'comic',
+  'coming',
+  'comma',
+  'commence',
+  'commend',
+  'comment',
+  'commerce',
+  'commode',
+  'commodity',
+  'commodore',
+  'common',
+  'commotion',
+  'commute',
+  'commuting',
+  'compacted',
+  'compacter',
+  'compactly',
+  'compactor',
+  'companion',
+  'company',
+  'compare',
+  'compel',
+  'compile',
+  'comply',
+  'component',
+  'composed',
+  'composer',
+  'composite',
+  'compost',
+  'composure',
+  'compound',
+  'compress',
+  'comprised',
+  'computer',
+  'computing',
+  'comrade',
+  'concave',
+  'conceal',
+  'conceded',
+  'concept',
+  'concerned',
+  'concert',
+  'conch',
+  'concierge',
+  'concise',
+  'conclude',
+  'concrete',
+  'concur',
+  'condense',
+  'condiment',
+  'condition',
+  'condone',
+  'conducive',
+  'conductor',
+  'conduit',
+  'cone',
+  'confess',
+  'confetti',
+  'confidant',
+  'confident',
+  'confider',
+  'confiding',
+  'configure',
+  'confined',
+  'confining',
+  'confirm',
+  'conflict',
+  'conform',
+  'confound',
+  'confront',
+  'confused',
+  'confusing',
+  'confusion',
+  'congenial',
+  'congested',
+  'congrats',
+  'congress',
+  'conical',
+  'conjoined',
+  'conjure',
+  'conjuror',
+  'connected',
+  'connector',
+  'consensus',
+  'consent',
+  'console',
+  'consoling',
+  'consonant',
+  'constable',
+  'constant',
+  'constrain',
+  'constrict',
+  'construct',
+  'consult',
+  'consumer',
+  'consuming',
+  'contact',
+  'container',
+  'contempt',
+  'contend',
+  'contented',
+  'contently',
+  'contents',
+  'contest',
+  'context',
+  'contort',
+  'contour',
+  'contrite',
+  'control',
+  'contusion',
+  'convene',
+  'convent',
+  'copartner',
+  'cope',
+  'copied',
+  'copier',
+  'copilot',
+  'coping',
+  'copious',
+  'copper',
+  'copy',
+  'coral',
+  'cork',
+  'cornball',
+  'cornbread',
+  'corncob',
+  'cornea',
+  'corned',
+  'corner',
+  'cornfield',
+  'cornflake',
+  'cornhusk',
+  'cornmeal',
+  'cornstalk',
+  'corny',
+  'coronary',
+  'coroner',
+  'corporal',
+  'corporate',
+  'corral',
+  'correct',
+  'corridor',
+  'corrode',
+  'corroding',
+  'corrosive',
+  'corsage',
+  'corset',
+  'cortex',
+  'cosigner',
+  'cosmetics',
+  'cosmic',
+  'cosmos',
+  'cosponsor',
+  'cost',
+  'cottage',
+  'cotton',
+  'couch',
+  'cough',
+  'could',
+  'countable',
+  'countdown',
+  'counting',
+  'countless',
+  'country',
+  'county',
+  'courier',
+  'covenant',
+  'cover',
+  'coveted',
+  'coveting',
+  'coyness',
+  'cozily',
+  'coziness',
+  'cozy',
+  'crabbing',
+  'crabgrass',
+  'crablike',
+  'crabmeat',
+  'cradle',
+  'cradling',
+  'crafter',
+  'craftily',
+  'craftsman',
+  'craftwork',
+  'crafty',
+  'cramp',
+  'cranberry',
+  'crane',
+  'cranial',
+  'cranium',
+  'crank',
+  'crate',
+  'crave',
+  'craving',
+  'crawfish',
+  'crawlers',
+  'crawling',
+  'crayfish',
+  'crayon',
+  'crazed',
+  'crazily',
+  'craziness',
+  'crazy',
+  'creamed',
+  'creamer',
+  'creamlike',
+  'crease',
+  'creasing',
+  'creatable',
+  'create',
+  'creation',
+  'creative',
+  'creature',
+  'credible',
+  'credibly',
+  'credit',
+  'creed',
+  'creme',
+  'creole',
+  'crepe',
+  'crept',
+  'crescent',
+  'crested',
+  'cresting',
+  'crestless',
+  'crevice',
+  'crewless',
+  'crewman',
+  'crewmate',
+  'crib',
+  'cricket',
+  'cried',
+  'crier',
+  'crimp',
+  'crimson',
+  'cringe',
+  'cringing',
+  'crinkle',
+  'crinkly',
+  'crisped',
+  'crisping',
+  'crisply',
+  'crispness',
+  'crispy',
+  'criteria',
+  'critter',
+  'croak',
+  'crock',
+  'crook',
+  'croon',
+  'crop',
+  'cross',
+  'crouch',
+  'crouton',
+  'crowbar',
+  'crowd',
+  'crown',
+  'crucial',
+  'crudely',
+  'crudeness',
+  'cruelly',
+  'cruelness',
+  'cruelty',
+  'crumb',
+  'crummiest',
+  'crummy',
+  'crumpet',
+  'crumpled',
+  'cruncher',
+  'crunching',
+  'crunchy',
+  'crusader',
+  'crushable',
+  'crushed',
+  'crusher',
+  'crushing',
+  'crust',
+  'crux',
+  'crying',
+  'cryptic',
+  'crystal',
+  'cubbyhole',
+  'cube',
+  'cubical',
+  'cubicle',
+  'cucumber',
+  'cuddle',
+  'cuddly',
+  'cufflink',
+  'culinary',
+  'culminate',
+  'culpable',
+  'culprit',
+  'cultivate',
+  'cultural',
+  'culture',
+  'cupbearer',
+  'cupcake',
+  'cupid',
+  'cupped',
+  'cupping',
+  'curable',
+  'curator',
+  'curdle',
+  'cure',
+  'curfew',
+  'curing',
+  'curled',
+  'curler',
+  'curliness',
+  'curling',
+  'curly',
+  'curry',
+  'curse',
+  'cursive',
+  'cursor',
+  'curtain',
+  'curtly',
+  'curtsy',
+  'curvature',
+  'curve',
+  'curvy',
+  'cushy',
+  'cusp',
+  'cussed',
+  'custard',
+  'custodian',
+  'custody',
+  'customary',
+  'customer',
+  'customize',
+  'customs',
+  'cut',
+  'cycle',
+  'cyclic',
+  'cycling',
+  'cyclist',
+  'cylinder',
+  'cymbal',
+  'cytoplasm',
+  'cytoplast',
+  'dab',
+  'dad',
+  'daffodil',
+  'dagger',
+  'daily',
+  'daintily',
+  'dainty',
+  'dairy',
+  'daisy',
+  'dallying',
+  'dance',
+  'dancing',
+  'dandelion',
+  'dander',
+  'dandruff',
+  'dandy',
+  'danger',
+  'dangle',
+  'dangling',
+  'daredevil',
+  'dares',
+  'daringly',
+  'darkened',
+  'darkening',
+  'darkish',
+  'darkness',
+  'darkroom',
+  'darling',
+  'darn',
+  'dart',
+  'darwinism',
+  'dash',
+  'dastardly',
+  'data',
+  'datebook',
+  'dating',
+  'daughter',
+  'daunting',
+  'dawdler',
+  'dawn',
+  'daybed',
+  'daybreak',
+  'daycare',
+  'daydream',
+  'daylight',
+  'daylong',
+  'dayroom',
+  'daytime',
+  'dazzler',
+  'dazzling',
+  'deacon',
+  'deafening',
+  'deafness',
+  'dealer',
+  'dealing',
+  'dealmaker',
+  'dealt',
+  'dean',
+  'debatable',
+  'debate',
+  'debating',
+  'debit',
+  'debrief',
+  'debtless',
+  'debtor',
+  'debug',
+  'debunk',
+  'decade',
+  'decaf',
+  'decal',
+  'decathlon',
+  'decay',
+  'deceased',
+  'deceit',
+  'deceiver',
+  'deceiving',
+  'december',
+  'decency',
+  'decent',
+  'deception',
+  'deceptive',
+  'decibel',
+  'decidable',
+  'decimal',
+  'decimeter',
+  'decipher',
+  'deck',
+  'declared',
+  'decline',
+  'decode',
+  'decompose',
+  'decorated',
+  'decorator',
+  'decoy',
+  'decrease',
+  'decree',
+  'dedicate',
+  'dedicator',
+  'deduce',
+  'deduct',
+  'deed',
+  'deem',
+  'deepen',
+  'deeply',
+  'deepness',
+  'deface',
+  'defacing',
+  'defame',
+  'default',
+  'defeat',
+  'defection',
+  'defective',
+  'defendant',
+  'defender',
+  'defense',
+  'defensive',
+  'deferral',
+  'deferred',
+  'defiance',
+  'defiant',
+  'defile',
+  'defiling',
+  'define',
+  'definite',
+  'deflate',
+  'deflation',
+  'deflator',
+  'deflected',
+  'deflector',
+  'defog',
+  'deforest',
+  'defraud',
+  'defrost',
+  'deftly',
+  'defuse',
+  'defy',
+  'degraded',
+  'degrading',
+  'degrease',
+  'degree',
+  'dehydrate',
+  'deity',
+  'dejected',
+  'delay',
+  'delegate',
+  'delegator',
+  'delete',
+  'deletion',
+  'delicacy',
+  'delicate',
+  'delicious',
+  'delighted',
+  'delirious',
+  'delirium',
+  'deliverer',
+  'delivery',
+  'delouse',
+  'delta',
+  'deluge',
+  'delusion',
+  'deluxe',
+  'demanding',
+  'demeaning',
+  'demeanor',
+  'demise',
+  'democracy',
+  'democrat',
+  'demote',
+  'demotion',
+  'demystify',
+  'denatured',
+  'deniable',
+  'denial',
+  'denim',
+  'denote',
+  'dense',
+  'density',
+  'dental',
+  'dentist',
+  'denture',
+  'deny',
+  'deodorant',
+  'deodorize',
+  'departed',
+  'departure',
+  'depict',
+  'deplete',
+  'depletion',
+  'deplored',
+  'deploy',
+  'deport',
+  'depose',
+  'depraved',
+  'depravity',
+  'deprecate',
+  'depress',
+  'deprive',
+  'depth',
+  'deputize',
+  'deputy',
+  'derail',
+  'deranged',
+  'derby',
+  'derived',
+  'desecrate',
+  'deserve',
+  'deserving',
+  'designate',
+  'designed',
+  'designer',
+  'designing',
+  'deskbound',
+  'desktop',
+  'deskwork',
+  'desolate',
+  'despair',
+  'despise',
+  'despite',
+  'destiny',
+  'destitute',
+  'destruct',
+  'detached',
+  'detail',
+  'detection',
+  'detective',
+  'detector',
+  'detention',
+  'detergent',
+  'detest',
+  'detonate',
+  'detonator',
+  'detoxify',
+  'detract',
+  'deuce',
+  'devalue',
+  'deviancy',
+  'deviant',
+  'deviate',
+  'deviation',
+  'deviator',
+  'device',
+  'devious',
+  'devotedly',
+  'devotee',
+  'devotion',
+  'devourer',
+  'devouring',
+  'devoutly',
+  'dexterity',
+  'dexterous',
+  'diabetes',
+  'diabetic',
+  'diabolic',
+  'diagnoses',
+  'diagnosis',
+  'diagram',
+  'dial',
+  'diameter',
+  'diaper',
+  'diaphragm',
+  'diary',
+  'dice',
+  'dicing',
+  'dictate',
+  'dictation',
+  'dictator',
+  'difficult',
+  'diffused',
+  'diffuser',
+  'diffusion',
+  'diffusive',
+  'dig',
+  'dilation',
+  'diligence',
+  'diligent',
+  'dill',
+  'dilute',
+  'dime',
+  'diminish',
+  'dimly',
+  'dimmed',
+  'dimmer',
+  'dimness',
+  'dimple',
+  'diner',
+  'dingbat',
+  'dinghy',
+  'dinginess',
+  'dingo',
+  'dingy',
+  'dining',
+  'dinner',
+  'diocese',
+  'dioxide',
+  'diploma',
+  'dipped',
+  'dipper',
+  'dipping',
+  'directed',
+  'direction',
+  'directive',
+  'directly',
+  'directory',
+  'direness',
+  'dirtiness',
+  'disabled',
+  'disagree',
+  'disallow',
+  'disarm',
+  'disarray',
+  'disaster',
+  'disband',
+  'disbelief',
+  'disburse',
+  'discard',
+  'discern',
+  'discharge',
+  'disclose',
+  'discolor',
+  'discount',
+  'discourse',
+  'discover',
+  'discuss',
+  'disdain',
+  'disengage',
+  'disfigure',
+  'disgrace',
+  'dish',
+  'disinfect',
+  'disjoin',
+  'disk',
+  'dislike',
+  'disliking',
+  'dislocate',
+  'dislodge',
+  'disloyal',
+  'dismantle',
+  'dismay',
+  'dismiss',
+  'dismount',
+  'disobey',
+  'disorder',
+  'disown',
+  'disparate',
+  'disparity',
+  'dispatch',
+  'dispense',
+  'dispersal',
+  'dispersed',
+  'disperser',
+  'displace',
+  'display',
+  'displease',
+  'disposal',
+  'dispose',
+  'disprove',
+  'dispute',
+  'disregard',
+  'disrupt',
+  'dissuade',
+  'distance',
+  'distant',
+  'distaste',
+  'distill',
+  'distinct',
+  'distort',
+  'distract',
+  'distress',
+  'district',
+  'distrust',
+  'ditch',
+  'ditto',
+  'ditzy',
+  'dividable',
+  'divided',
+  'dividend',
+  'dividers',
+  'dividing',
+  'divinely',
+  'diving',
+  'divinity',
+  'divisible',
+  'divisibly',
+  'division',
+  'divisive',
+  'divorcee',
+  'dizziness',
+  'dizzy',
+  'doable',
+  'docile',
+  'dock',
+  'doctrine',
+  'document',
+  'dodge',
+  'dodgy',
+  'doily',
+  'doing',
+  'dole',
+  'dollar',
+  'dollhouse',
+  'dollop',
+  'dolly',
+  'dolphin',
+  'domain',
+  'domelike',
+  'domestic',
+  'dominion',
+  'dominoes',
+  'donated',
+  'donation',
+  'donator',
+  'donor',
+  'donut',
+  'doodle',
+  'doorbell',
+  'doorframe',
+  'doorknob',
+  'doorman',
+  'doormat',
+  'doornail',
+  'doorpost',
+  'doorstep',
+  'doorstop',
+  'doorway',
+  'doozy',
+  'dork',
+  'dormitory',
+  'dorsal',
+  'dosage',
+  'dose',
+  'dotted',
+  'doubling',
+  'douche',
+  'dove',
+  'down',
+  'dowry',
+  'doze',
+  'drab',
+  'dragging',
+  'dragonfly',
+  'dragonish',
+  'dragster',
+  'drainable',
+  'drainage',
+  'drained',
+  'drainer',
+  'drainpipe',
+  'dramatic',
+  'dramatize',
+  'drank',
+  'drapery',
+  'drastic',
+  'draw',
+  'dreaded',
+  'dreadful',
+  'dreadlock',
+  'dreamboat',
+  'dreamily',
+  'dreamland',
+  'dreamless',
+  'dreamlike',
+  'dreamt',
+  'dreamy',
+  'drearily',
+  'dreary',
+  'drench',
+  'dress',
+  'drew',
+  'dribble',
+  'dried',
+  'drier',
+  'drift',
+  'driller',
+  'drilling',
+  'drinkable',
+  'drinking',
+  'dripping',
+  'drippy',
+  'drivable',
+  'driven',
+  'driver',
+  'driveway',
+  'driving',
+  'drizzle',
+  'drizzly',
+  'drone',
+  'drool',
+  'droop',
+  'drop-down',
+  'dropbox',
+  'dropkick',
+  'droplet',
+  'dropout',
+  'dropper',
+  'drove',
+  'drown',
+  'drowsily',
+  'drudge',
+  'drum',
+  'dry',
+  'dubbed',
+  'dubiously',
+  'duchess',
+  'duckbill',
+  'ducking',
+  'duckling',
+  'ducktail',
+  'ducky',
+  'duct',
+  'dude',
+  'duffel',
+  'dugout',
+  'duh',
+  'duke',
+  'duller',
+  'dullness',
+  'duly',
+  'dumping',
+  'dumpling',
+  'dumpster',
+  'duo',
+  'dupe',
+  'duplex',
+  'duplicate',
+  'duplicity',
+  'durable',
+  'durably',
+  'duration',
+  'duress',
+  'during',
+  'dusk',
+  'dust',
+  'dutiful',
+  'duty',
+  'duvet',
+  'dwarf',
+  'dweeb',
+  'dwelled',
+  'dweller',
+  'dwelling',
+  'dwindle',
+  'dwindling',
+  'dynamic',
+  'dynamite',
+  'dynasty',
+  'dyslexia',
+  'dyslexic',
+  'each',
+  'eagle',
+  'earache',
+  'eardrum',
+  'earflap',
+  'earful',
+  'earlobe',
+  'early',
+  'earmark',
+  'earmuff',
+  'earphone',
+  'earpiece',
+  'earplugs',
+  'earring',
+  'earshot',
+  'earthen',
+  'earthlike',
+  'earthling',
+  'earthly',
+  'earthworm',
+  'earthy',
+  'earwig',
+  'easeful',
+  'easel',
+  'easiest',
+  'easily',
+  'easiness',
+  'easing',
+  'eastbound',
+  'eastcoast',
+  'easter',
+  'eastward',
+  'eatable',
+  'eaten',
+  'eatery',
+  'eating',
+  'eats',
+  'ebay',
+  'ebony',
+  'ebook',
+  'ecard',
+  'eccentric',
+  'echo',
+  'eclair',
+  'eclipse',
+  'ecologist',
+  'ecology',
+  'economic',
+  'economist',
+  'economy',
+  'ecosphere',
+  'ecosystem',
+  'edge',
+  'edginess',
+  'edging',
+  'edgy',
+  'edition',
+  'editor',
+  'educated',
+  'education',
+  'educator',
+  'eel',
+  'effective',
+  'effects',
+  'efficient',
+  'effort',
+  'eggbeater',
+  'egging',
+  'eggnog',
+  'eggplant',
+  'eggshell',
+  'egomaniac',
+  'egotism',
+  'egotistic',
+  'either',
+  'eject',
+  'elaborate',
+  'elastic',
+  'elated',
+  'elbow',
+  'eldercare',
+  'elderly',
+  'eldest',
+  'electable',
+  'election',
+  'elective',
+  'elephant',
+  'elevate',
+  'elevating',
+  'elevation',
+  'elevator',
+  'eleven',
+  'elf',
+  'eligible',
+  'eligibly',
+  'eliminate',
+  'elite',
+  'elitism',
+  'elixir',
+  'elk',
+  'ellipse',
+  'elliptic',
+  'elm',
+  'elongated',
+  'elope',
+  'eloquence',
+  'eloquent',
+  'elsewhere',
+  'elude',
+  'elusive',
+  'elves',
+  'email',
+  'embargo',
+  'embark',
+  'embassy',
+  'embattled',
+  'embellish',
+  'ember',
+  'embezzle',
+  'emblaze',
+  'emblem',
+  'embody',
+  'embolism',
+  'emboss',
+  'embroider',
+  'emcee',
+  'emerald',
+  'emergency',
+  'emission',
+  'emit',
+  'emote',
+  'emoticon',
+  'emotion',
+  'empathic',
+  'empathy',
+  'emperor',
+  'emphases',
+  'emphasis',
+  'emphasize',
+  'emphatic',
+  'empirical',
+  'employed',
+  'employee',
+  'employer',
+  'emporium',
+  'empower',
+  'emptier',
+  'emptiness',
+  'empty',
+  'emu',
+  'enable',
+  'enactment',
+  'enamel',
+  'enchanted',
+  'enchilada',
+  'encircle',
+  'enclose',
+  'enclosure',
+  'encode',
+  'encore',
+  'encounter',
+  'encourage',
+  'encroach',
+  'encrust',
+  'encrypt',
+  'endanger',
+  'endeared',
+  'endearing',
+  'ended',
+  'ending',
+  'endless',
+  'endnote',
+  'endocrine',
+  'endorphin',
+  'endorse',
+  'endowment',
+  'endpoint',
+  'endurable',
+  'endurance',
+  'enduring',
+  'energetic',
+  'energize',
+  'energy',
+  'enforced',
+  'enforcer',
+  'engaged',
+  'engaging',
+  'engine',
+  'engorge',
+  'engraved',
+  'engraver',
+  'engraving',
+  'engross',
+  'engulf',
+  'enhance',
+  'enigmatic',
+  'enjoyable',
+  'enjoyably',
+  'enjoyer',
+  'enjoying',
+  'enjoyment',
+  'enlarged',
+  'enlarging',
+  'enlighten',
+  'enlisted',
+  'enquirer',
+  'enrage',
+  'enrich',
+  'enroll',
+  'enslave',
+  'ensnare',
+  'ensure',
+  'entail',
+  'entangled',
+  'entering',
+  'entertain',
+  'enticing',
+  'entire',
+  'entitle',
+  'entity',
+  'entomb',
+  'entourage',
+  'entrap',
+  'entree',
+  'entrench',
+  'entrust',
+  'entryway',
+  'entwine',
+  'enunciate',
+  'envelope',
+  'enviable',
+  'enviably',
+  'envious',
+  'envision',
+  'envoy',
+  'envy',
+  'enzyme',
+  'epic',
+  'epidemic',
+  'epidermal',
+  'epidermis',
+  'epidural',
+  'epilepsy',
+  'epileptic',
+  'epilogue',
+  'epiphany',
+  'episode',
+  'equal',
+  'equate',
+  'equation',
+  'equator',
+  'equinox',
+  'equipment',
+  'equity',
+  'equivocal',
+  'eradicate',
+  'erasable',
+  'erased',
+  'eraser',
+  'erasure',
+  'ergonomic',
+  'errand',
+  'errant',
+  'erratic',
+  'error',
+  'erupt',
+  'escalate',
+  'escalator',
+  'escapable',
+  'escapade',
+  'escapist',
+  'escargot',
+  'eskimo',
+  'esophagus',
+  'espionage',
+  'espresso',
+  'esquire',
+  'essay',
+  'essence',
+  'essential',
+  'establish',
+  'estate',
+  'esteemed',
+  'estimate',
+  'estimator',
+  'estranged',
+  'estrogen',
+  'etching',
+  'eternal',
+  'eternity',
+  'ethanol',
+  'ether',
+  'ethically',
+  'ethics',
+  'euphemism',
+  'evacuate',
+  'evacuee',
+  'evade',
+  'evaluate',
+  'evaluator',
+  'evaporate',
+  'evasion',
+  'evasive',
+  'even',
+  'everglade',
+  'evergreen',
+  'everybody',
+  'everyday',
+  'everyone',
+  'evict',
+  'evidence',
+  'evident',
+  'evil',
+  'evoke',
+  'evolution',
+  'evolve',
+  'exact',
+  'exalted',
+  'example',
+  'excavate',
+  'excavator',
+  'exceeding',
+  'exception',
+  'excess',
+  'exchange',
+  'excitable',
+  'exciting',
+  'exclaim',
+  'exclude',
+  'excluding',
+  'exclusion',
+  'exclusive',
+  'excretion',
+  'excretory',
+  'excursion',
+  'excusable',
+  'excusably',
+  'excuse',
+  'exemplary',
+  'exemplify',
+  'exemption',
+  'exerciser',
+  'exert',
+  'exes',
+  'exfoliate',
+  'exhale',
+  'exhaust',
+  'exhume',
+  'exile',
+  'existing',
+  'exit',
+  'exodus',
+  'exonerate',
+  'exorcism',
+  'exorcist',
+  'expand',
+  'expanse',
+  'expansion',
+  'expansive',
+  'expectant',
+  'expedited',
+  'expediter',
+  'expel',
+  'expend',
+  'expenses',
+  'expensive',
+  'expert',
+  'expire',
+  'expiring',
+  'explain',
+  'expletive',
+  'explicit',
+  'explode',
+  'exploit',
+  'explore',
+  'exploring',
+  'exponent',
+  'exporter',
+  'exposable',
+  'expose',
+  'exposure',
+  'express',
+  'expulsion',
+  'exquisite',
+  'extended',
+  'extending',
+  'extent',
+  'extenuate',
+  'exterior',
+  'external',
+  'extinct',
+  'extortion',
+  'extradite',
+  'extras',
+  'extrovert',
+  'extrude',
+  'extruding',
+  'exuberant',
+  'fable',
+  'fabric',
+  'fabulous',
+  'facebook',
+  'facecloth',
+  'facedown',
+  'faceless',
+  'facelift',
+  'faceplate',
+  'faceted',
+  'facial',
+  'facility',
+  'facing',
+  'facsimile',
+  'faction',
+  'factoid',
+  'factor',
+  'factsheet',
+  'factual',
+  'faculty',
+  'fade',
+  'fading',
+  'failing',
+  'falcon',
+  'fall',
+  'false',
+  'falsify',
+  'fame',
+  'familiar',
+  'family',
+  'famine',
+  'famished',
+  'fanatic',
+  'fancied',
+  'fanciness',
+  'fancy',
+  'fanfare',
+  'fang',
+  'fanning',
+  'fantasize',
+  'fantastic',
+  'fantasy',
+  'fascism',
+  'fastball',
+  'faster',
+  'fasting',
+  'fastness',
+  'faucet',
+  'favorable',
+  'favorably',
+  'favored',
+  'favoring',
+  'favorite',
+  'fax',
+  'feast',
+  'federal',
+  'fedora',
+  'feeble',
+  'feed',
+  'feel',
+  'feisty',
+  'feline',
+  'felt-tip',
+  'feminine',
+  'feminism',
+  'feminist',
+  'feminize',
+  'femur',
+  'fence',
+  'fencing',
+  'fender',
+  'ferment',
+  'fernlike',
+  'ferocious',
+  'ferocity',
+  'ferret',
+  'ferris',
+  'ferry',
+  'fervor',
+  'fester',
+  'festival',
+  'festive',
+  'festivity',
+  'fetal',
+  'fetch',
+  'fever',
+  'fiber',
+  'fiction',
+  'fiddle',
+  'fiddling',
+  'fidelity',
+  'fidgeting',
+  'fidgety',
+  'fifteen',
+  'fifth',
+  'fiftieth',
+  'fifty',
+  'figment',
+  'figure',
+  'figurine',
+  'filing',
+  'filled',
+  'filler',
+  'filling',
+  'film',
+  'filter',
+  'filth',
+  'filtrate',
+  'finale',
+  'finalist',
+  'finalize',
+  'finally',
+  'finance',
+  'financial',
+  'finch',
+  'fineness',
+  'finer',
+  'finicky',
+  'finished',
+  'finisher',
+  'finishing',
+  'finite',
+  'finless',
+  'finlike',
+  'fiscally',
+  'fit',
+  'five',
+  'flaccid',
+  'flagman',
+  'flagpole',
+  'flagship',
+  'flagstick',
+  'flagstone',
+  'flail',
+  'flakily',
+  'flaky',
+  'flame',
+  'flammable',
+  'flanked',
+  'flanking',
+  'flannels',
+  'flap',
+  'flaring',
+  'flashback',
+  'flashbulb',
+  'flashcard',
+  'flashily',
+  'flashing',
+  'flashy',
+  'flask',
+  'flatbed',
+  'flatfoot',
+  'flatly',
+  'flatness',
+  'flatten',
+  'flattered',
+  'flatterer',
+  'flattery',
+  'flattop',
+  'flatware',
+  'flatworm',
+  'flavored',
+  'flavorful',
+  'flavoring',
+  'flaxseed',
+  'fled',
+  'fleshed',
+  'fleshy',
+  'flick',
+  'flier',
+  'flight',
+  'flinch',
+  'fling',
+  'flint',
+  'flip',
+  'flirt',
+  'float',
+  'flock',
+  'flogging',
+  'flop',
+  'floral',
+  'florist',
+  'floss',
+  'flounder',
+  'flyable',
+  'flyaway',
+  'flyer',
+  'flying',
+  'flyover',
+  'flypaper',
+  'foam',
+  'foe',
+  'fog',
+  'foil',
+  'folic',
+  'folk',
+  'follicle',
+  'follow',
+  'fondling',
+  'fondly',
+  'fondness',
+  'fondue',
+  'font',
+  'food',
+  'fool',
+  'footage',
+  'football',
+  'footbath',
+  'footboard',
+  'footer',
+  'footgear',
+  'foothill',
+  'foothold',
+  'footing',
+  'footless',
+  'footman',
+  'footnote',
+  'footpad',
+  'footpath',
+  'footprint',
+  'footrest',
+  'footsie',
+  'footsore',
+  'footwear',
+  'footwork',
+  'fossil',
+  'foster',
+  'founder',
+  'founding',
+  'fountain',
+  'fox',
+  'foyer',
+  'fraction',
+  'fracture',
+  'fragile',
+  'fragility',
+  'fragment',
+  'fragrance',
+  'fragrant',
+  'frail',
+  'frame',
+  'framing',
+  'frantic',
+  'fraternal',
+  'frayed',
+  'fraying',
+  'frays',
+  'freckled',
+  'freckles',
+  'freebase',
+  'freebee',
+  'freebie',
+  'freedom',
+  'freefall',
+  'freehand',
+  'freeing',
+  'freeload',
+  'freely',
+  'freemason',
+  'freeness',
+  'freestyle',
+  'freeware',
+  'freeway',
+  'freewill',
+  'freezable',
+  'freezing',
+  'freight',
+  'french',
+  'frenzied',
+  'frenzy',
+  'frequency',
+  'frequent',
+  'fresh',
+  'fretful',
+  'fretted',
+  'friction',
+  'friday',
+  'fridge',
+  'fried',
+  'friend',
+  'frighten',
+  'frightful',
+  'frigidity',
+  'frigidly',
+  'frill',
+  'fringe',
+  'frisbee',
+  'frisk',
+  'fritter',
+  'frivolous',
+  'frolic',
+  'from',
+  'front',
+  'frostbite',
+  'frosted',
+  'frostily',
+  'frosting',
+  'frostlike',
+  'frosty',
+  'froth',
+  'frown',
+  'frozen',
+  'fructose',
+  'frugality',
+  'frugally',
+  'fruit',
+  'frustrate',
+  'frying',
+  'gab',
+  'gaffe',
+  'gag',
+  'gainfully',
+  'gaining',
+  'gains',
+  'gala',
+  'gallantly',
+  'galleria',
+  'gallery',
+  'galley',
+  'gallon',
+  'gallows',
+  'gallstone',
+  'galore',
+  'galvanize',
+  'gambling',
+  'game',
+  'gaming',
+  'gamma',
+  'gander',
+  'gangly',
+  'gangrene',
+  'gangway',
+  'gap',
+  'garage',
+  'garbage',
+  'garden',
+  'gargle',
+  'garland',
+  'garlic',
+  'garment',
+  'garnet',
+  'garnish',
+  'garter',
+  'gas',
+  'gatherer',
+  'gathering',
+  'gating',
+  'gauging',
+  'gauntlet',
+  'gauze',
+  'gave',
+  'gawk',
+  'gazing',
+  'gear',
+  'gecko',
+  'geek',
+  'geiger',
+  'gem',
+  'gender',
+  'generic',
+  'generous',
+  'genetics',
+  'genre',
+  'gentile',
+  'gentleman',
+  'gently',
+  'gents',
+  'geography',
+  'geologic',
+  'geologist',
+  'geology',
+  'geometric',
+  'geometry',
+  'geranium',
+  'gerbil',
+  'geriatric',
+  'germicide',
+  'germinate',
+  'germless',
+  'germproof',
+  'gestate',
+  'gestation',
+  'gesture',
+  'getaway',
+  'getting',
+  'getup',
+  'giant',
+  'gibberish',
+  'giblet',
+  'giddily',
+  'giddiness',
+  'giddy',
+  'gift',
+  'gigabyte',
+  'gigahertz',
+  'gigantic',
+  'giggle',
+  'giggling',
+  'giggly',
+  'gigolo',
+  'gilled',
+  'gills',
+  'gimmick',
+  'girdle',
+  'giveaway',
+  'given',
+  'giver',
+  'giving',
+  'gizmo',
+  'gizzard',
+  'glacial',
+  'glacier',
+  'glade',
+  'gladiator',
+  'gladly',
+  'glamorous',
+  'glamour',
+  'glance',
+  'glancing',
+  'glandular',
+  'glare',
+  'glaring',
+  'glass',
+  'glaucoma',
+  'glazing',
+  'gleaming',
+  'gleeful',
+  'glider',
+  'gliding',
+  'glimmer',
+  'glimpse',
+  'glisten',
+  'glitch',
+  'glitter',
+  'glitzy',
+  'gloater',
+  'gloating',
+  'gloomily',
+  'gloomy',
+  'glorified',
+  'glorifier',
+  'glorify',
+  'glorious',
+  'glory',
+  'gloss',
+  'glove',
+  'glowing',
+  'glowworm',
+  'glucose',
+  'glue',
+  'gluten',
+  'glutinous',
+  'glutton',
+  'gnarly',
+  'gnat',
+  'goal',
+  'goatskin',
+  'goes',
+  'goggles',
+  'going',
+  'goldfish',
+  'goldmine',
+  'goldsmith',
+  'golf',
+  'goliath',
+  'gonad',
+  'gondola',
+  'gone',
+  'gong',
+  'good',
+  'gooey',
+  'goofball',
+  'goofiness',
+  'goofy',
+  'google',
+  'goon',
+  'gopher',
+  'gore',
+  'gorged',
+  'gorgeous',
+  'gory',
+  'gosling',
+  'gossip',
+  'gothic',
+  'gotten',
+  'gout',
+  'gown',
+  'grab',
+  'graceful',
+  'graceless',
+  'gracious',
+  'gradation',
+  'graded',
+  'grader',
+  'gradient',
+  'grading',
+  'gradually',
+  'graduate',
+  'graffiti',
+  'grafted',
+  'grafting',
+  'grain',
+  'granddad',
+  'grandkid',
+  'grandly',
+  'grandma',
+  'grandpa',
+  'grandson',
+  'granite',
+  'granny',
+  'granola',
+  'grant',
+  'granular',
+  'grape',
+  'graph',
+  'grapple',
+  'grappling',
+  'grasp',
+  'grass',
+  'gratified',
+  'gratify',
+  'grating',
+  'gratitude',
+  'gratuity',
+  'gravel',
+  'graveness',
+  'graves',
+  'graveyard',
+  'gravitate',
+  'gravity',
+  'gravy',
+  'gray',
+  'grazing',
+  'greasily',
+  'greedily',
+  'greedless',
+  'greedy',
+  'green',
+  'greeter',
+  'greeting',
+  'grew',
+  'greyhound',
+  'grid',
+  'grief',
+  'grievance',
+  'grieving',
+  'grievous',
+  'grill',
+  'grimace',
+  'grimacing',
+  'grime',
+  'griminess',
+  'grimy',
+  'grinch',
+  'grinning',
+  'grip',
+  'gristle',
+  'grit',
+  'groggily',
+  'groggy',
+  'groin',
+  'groom',
+  'groove',
+  'grooving',
+  'groovy',
+  'grope',
+  'ground',
+  'grouped',
+  'grout',
+  'grove',
+  'grower',
+  'growing',
+  'growl',
+  'grub',
+  'grudge',
+  'grudging',
+  'grueling',
+  'gruffly',
+  'grumble',
+  'grumbling',
+  'grumbly',
+  'grumpily',
+  'grunge',
+  'grunt',
+  'guacamole',
+  'guidable',
+  'guidance',
+  'guide',
+  'guiding',
+  'guileless',
+  'guise',
+  'gulf',
+  'gullible',
+  'gully',
+  'gulp',
+  'gumball',
+  'gumdrop',
+  'gumminess',
+  'gumming',
+  'gummy',
+  'gurgle',
+  'gurgling',
+  'guru',
+  'gush',
+  'gusto',
+  'gusty',
+  'gutless',
+  'guts',
+  'gutter',
+  'guy',
+  'guzzler',
+  'gyration',
+  'habitable',
+  'habitant',
+  'habitat',
+  'habitual',
+  'hacked',
+  'hacker',
+  'hacking',
+  'hacksaw',
+  'had',
+  'haggler',
+  'haiku',
+  'half',
+  'halogen',
+  'halt',
+  'halved',
+  'halves',
+  'hamburger',
+  'hamlet',
+  'hammock',
+  'hamper',
+  'hamster',
+  'hamstring',
+  'handbag',
+  'handball',
+  'handbook',
+  'handbrake',
+  'handcart',
+  'handclap',
+  'handclasp',
+  'handcraft',
+  'handcuff',
+  'handed',
+  'handful',
+  'handgrip',
+  'handgun',
+  'handheld',
+  'handiness',
+  'handiwork',
+  'handlebar',
+  'handled',
+  'handler',
+  'handling',
+  'handmade',
+  'handoff',
+  'handpick',
+  'handprint',
+  'handrail',
+  'handsaw',
+  'handset',
+  'handsfree',
+  'handshake',
+  'handstand',
+  'handwash',
+  'handwork',
+  'handwoven',
+  'handwrite',
+  'handyman',
+  'hangnail',
+  'hangout',
+  'hangover',
+  'hangup',
+  'hankering',
+  'hankie',
+  'hanky',
+  'haphazard',
+  'happening',
+  'happier',
+  'happiest',
+  'happily',
+  'happiness',
+  'happy',
+  'harbor',
+  'hardcopy',
+  'hardcore',
+  'hardcover',
+  'harddisk',
+  'hardened',
+  'hardener',
+  'hardening',
+  'hardhat',
+  'hardhead',
+  'hardiness',
+  'hardly',
+  'hardness',
+  'hardship',
+  'hardware',
+  'hardwired',
+  'hardwood',
+  'hardy',
+  'harmful',
+  'harmless',
+  'harmonica',
+  'harmonics',
+  'harmonize',
+  'harmony',
+  'harness',
+  'harpist',
+  'harsh',
+  'harvest',
+  'hash',
+  'hassle',
+  'haste',
+  'hastily',
+  'hastiness',
+  'hasty',
+  'hatbox',
+  'hatchback',
+  'hatchery',
+  'hatchet',
+  'hatching',
+  'hatchling',
+  'hate',
+  'hatless',
+  'hatred',
+  'haunt',
+  'haven',
+  'hazard',
+  'hazelnut',
+  'hazily',
+  'haziness',
+  'hazing',
+  'hazy',
+  'headache',
+  'headband',
+  'headboard',
+  'headcount',
+  'headdress',
+  'headed',
+  'header',
+  'headfirst',
+  'headgear',
+  'heading',
+  'headlamp',
+  'headless',
+  'headlock',
+  'headphone',
+  'headpiece',
+  'headrest',
+  'headroom',
+  'headscarf',
+  'headset',
+  'headsman',
+  'headstand',
+  'headstone',
+  'headway',
+  'headwear',
+  'heap',
+  'heat',
+  'heave',
+  'heavily',
+  'heaviness',
+  'heaving',
+  'hedge',
+  'hedging',
+  'heftiness',
+  'hefty',
+  'helium',
+  'helmet',
+  'helper',
+  'helpful',
+  'helping',
+  'helpless',
+  'helpline',
+  'hemlock',
+  'hemstitch',
+  'hence',
+  'henchman',
+  'henna',
+  'herald',
+  'herbal',
+  'herbicide',
+  'herbs',
+  'heritage',
+  'hermit',
+  'heroics',
+  'heroism',
+  'herring',
+  'herself',
+  'hertz',
+  'hesitancy',
+  'hesitant',
+  'hesitate',
+  'hexagon',
+  'hexagram',
+  'hubcap',
+  'huddle',
+  'huddling',
+  'huff',
+  'hug',
+  'hula',
+  'hulk',
+  'hull',
+  'human',
+  'humble',
+  'humbling',
+  'humbly',
+  'humid',
+  'humiliate',
+  'humility',
+  'humming',
+  'hummus',
+  'humongous',
+  'humorist',
+  'humorless',
+  'humorous',
+  'humpback',
+  'humped',
+  'humvee',
+  'hunchback',
+  'hundredth',
+  'hunger',
+  'hungrily',
+  'hungry',
+  'hunk',
+  'hunter',
+  'hunting',
+  'huntress',
+  'huntsman',
+  'hurdle',
+  'hurled',
+  'hurler',
+  'hurling',
+  'hurray',
+  'hurricane',
+  'hurried',
+  'hurry',
+  'hurt',
+  'husband',
+  'hush',
+  'husked',
+  'huskiness',
+  'hut',
+  'hybrid',
+  'hydrant',
+  'hydrated',
+  'hydration',
+  'hydrogen',
+  'hydroxide',
+  'hyperlink',
+  'hypertext',
+  'hyphen',
+  'hypnoses',
+  'hypnosis',
+  'hypnotic',
+  'hypnotism',
+  'hypnotist',
+  'hypnotize',
+  'hypocrisy',
+  'hypocrite',
+  'ibuprofen',
+  'ice',
+  'iciness',
+  'icing',
+  'icky',
+  'icon',
+  'icy',
+  'idealism',
+  'idealist',
+  'idealize',
+  'ideally',
+  'idealness',
+  'identical',
+  'identify',
+  'identity',
+  'ideology',
+  'idiocy',
+  'idiom',
+  'idly',
+  'igloo',
+  'ignition',
+  'ignore',
+  'iguana',
+  'illicitly',
+  'illusion',
+  'illusive',
+  'image',
+  'imaginary',
+  'imagines',
+  'imaging',
+  'imbecile',
+  'imitate',
+  'imitation',
+  'immature',
+  'immerse',
+  'immersion',
+  'imminent',
+  'immobile',
+  'immodest',
+  'immorally',
+  'immortal',
+  'immovable',
+  'immovably',
+  'immunity',
+  'immunize',
+  'impaired',
+  'impale',
+  'impart',
+  'impatient',
+  'impeach',
+  'impeding',
+  'impending',
+  'imperfect',
+  'imperial',
+  'impish',
+  'implant',
+  'implement',
+  'implicate',
+  'implicit',
+  'implode',
+  'implosion',
+  'implosive',
+  'imply',
+  'impolite',
+  'important',
+  'importer',
+  'impose',
+  'imposing',
+  'impotence',
+  'impotency',
+  'impotent',
+  'impound',
+  'imprecise',
+  'imprint',
+  'imprison',
+  'impromptu',
+  'improper',
+  'improve',
+  'improving',
+  'improvise',
+  'imprudent',
+  'impulse',
+  'impulsive',
+  'impure',
+  'impurity',
+  'iodine',
+  'iodize',
+  'ion',
+  'ipad',
+  'iphone',
+  'ipod',
+  'irate',
+  'irk',
+  'iron',
+  'irregular',
+  'irrigate',
+  'irritable',
+  'irritably',
+  'irritant',
+  'irritate',
+  'islamic',
+  'islamist',
+  'isolated',
+  'isolating',
+  'isolation',
+  'isotope',
+  'issue',
+  'issuing',
+  'italicize',
+  'italics',
+  'item',
+  'itinerary',
+  'itunes',
+  'ivory',
+  'ivy',
+  'jab',
+  'jackal',
+  'jacket',
+  'jackknife',
+  'jackpot',
+  'jailbird',
+  'jailbreak',
+  'jailer',
+  'jailhouse',
+  'jalapeno',
+  'jam',
+  'janitor',
+  'january',
+  'jargon',
+  'jarring',
+  'jasmine',
+  'jaundice',
+  'jaunt',
+  'java',
+  'jawed',
+  'jawless',
+  'jawline',
+  'jaws',
+  'jaybird',
+  'jaywalker',
+  'jazz',
+  'jeep',
+  'jeeringly',
+  'jellied',
+  'jelly',
+  'jersey',
+  'jester',
+  'jet',
+  'jiffy',
+  'jigsaw',
+  'jimmy',
+  'jingle',
+  'jingling',
+  'jinx',
+  'jitters',
+  'jittery',
+  'job',
+  'jockey',
+  'jockstrap',
+  'jogger',
+  'jogging',
+  'john',
+  'joining',
+  'jokester',
+  'jokingly',
+  'jolliness',
+  'jolly',
+  'jolt',
+  'jot',
+  'jovial',
+  'joyfully',
+  'joylessly',
+  'joyous',
+  'joyride',
+  'joystick',
+  'jubilance',
+  'jubilant',
+  'judge',
+  'judgingly',
+  'judicial',
+  'judiciary',
+  'judo',
+  'juggle',
+  'juggling',
+  'jugular',
+  'juice',
+  'juiciness',
+  'juicy',
+  'jujitsu',
+  'jukebox',
+  'july',
+  'jumble',
+  'jumbo',
+  'jump',
+  'junction',
+  'juncture',
+  'june',
+  'junior',
+  'juniper',
+  'junkie',
+  'junkman',
+  'junkyard',
+  'jurist',
+  'juror',
+  'jury',
+  'justice',
+  'justifier',
+  'justify',
+  'justly',
+  'justness',
+  'juvenile',
+  'kabob',
+  'kangaroo',
+  'karaoke',
+  'karate',
+  'karma',
+  'kebab',
+  'keenly',
+  'keenness',
+  'keep',
+  'keg',
+  'kelp',
+  'kennel',
+  'kept',
+  'kerchief',
+  'kerosene',
+  'kettle',
+  'kick',
+  'kiln',
+  'kilobyte',
+  'kilogram',
+  'kilometer',
+  'kilowatt',
+  'kilt',
+  'kimono',
+  'kindle',
+  'kindling',
+  'kindly',
+  'kindness',
+  'kindred',
+  'kinetic',
+  'kinfolk',
+  'king',
+  'kinship',
+  'kinsman',
+  'kinswoman',
+  'kissable',
+  'kisser',
+  'kissing',
+  'kitchen',
+  'kite',
+  'kitten',
+  'kitty',
+  'kiwi',
+  'kleenex',
+  'knapsack',
+  'knee',
+  'knelt',
+  'knickers',
+  'knoll',
+  'koala',
+  'kooky',
+  'kosher',
+  'krypton',
+  'kudos',
+  'kung',
+  'labored',
+  'laborer',
+  'laboring',
+  'laborious',
+  'labrador',
+  'ladder',
+  'ladies',
+  'ladle',
+  'ladybug',
+  'ladylike',
+  'lagged',
+  'lagging',
+  'lagoon',
+  'lair',
+  'lake',
+  'lance',
+  'landed',
+  'landfall',
+  'landfill',
+  'landing',
+  'landlady',
+  'landless',
+  'landline',
+  'landlord',
+  'landmark',
+  'landmass',
+  'landmine',
+  'landowner',
+  'landscape',
+  'landside',
+  'landslide',
+  'language',
+  'lankiness',
+  'lanky',
+  'lantern',
+  'lapdog',
+  'lapel',
+  'lapped',
+  'lapping',
+  'laptop',
+  'lard',
+  'large',
+  'lark',
+  'lash',
+  'lasso',
+  'last',
+  'latch',
+  'late',
+  'lather',
+  'latitude',
+  'latrine',
+  'latter',
+  'latticed',
+  'launch',
+  'launder',
+  'laundry',
+  'laurel',
+  'lavender',
+  'lavish',
+  'laxative',
+  'lazily',
+  'laziness',
+  'lazy',
+  'lecturer',
+  'left',
+  'legacy',
+  'legal',
+  'legend',
+  'legged',
+  'leggings',
+  'legible',
+  'legibly',
+  'legislate',
+  'lego',
+  'legroom',
+  'legume',
+  'legwarmer',
+  'legwork',
+  'lemon',
+  'lend',
+  'length',
+  'lens',
+  'lent',
+  'leotard',
+  'lesser',
+  'letdown',
+  'lethargic',
+  'lethargy',
+  'letter',
+  'lettuce',
+  'level',
+  'leverage',
+  'levers',
+  'levitate',
+  'levitator',
+  'liability',
+  'liable',
+  'liberty',
+  'librarian',
+  'library',
+  'licking',
+  'licorice',
+  'lid',
+  'life',
+  'lifter',
+  'lifting',
+  'liftoff',
+  'ligament',
+  'likely',
+  'likeness',
+  'likewise',
+  'liking',
+  'lilac',
+  'lilly',
+  'lily',
+  'limb',
+  'limeade',
+  'limelight',
+  'limes',
+  'limit',
+  'limping',
+  'limpness',
+  'line',
+  'lingo',
+  'linguini',
+  'linguist',
+  'lining',
+  'linked',
+  'linoleum',
+  'linseed',
+  'lint',
+  'lion',
+  'lip',
+  'liquefy',
+  'liqueur',
+  'liquid',
+  'lisp',
+  'list',
+  'litigate',
+  'litigator',
+  'litmus',
+  'litter',
+  'little',
+  'livable',
+  'lived',
+  'lively',
+  'liver',
+  'livestock',
+  'lividly',
+  'living',
+  'lizard',
+  'lubricant',
+  'lubricate',
+  'lucid',
+  'luckily',
+  'luckiness',
+  'luckless',
+  'lucrative',
+  'ludicrous',
+  'lugged',
+  'lukewarm',
+  'lullaby',
+  'lumber',
+  'luminance',
+  'luminous',
+  'lumpiness',
+  'lumping',
+  'lumpish',
+  'lunacy',
+  'lunar',
+  'lunchbox',
+  'luncheon',
+  'lunchroom',
+  'lunchtime',
+  'lung',
+  'lurch',
+  'lure',
+  'luridness',
+  'lurk',
+  'lushly',
+  'lushness',
+  'luster',
+  'lustfully',
+  'lustily',
+  'lustiness',
+  'lustrous',
+  'lusty',
+  'luxurious',
+  'luxury',
+  'lying',
+  'lyrically',
+  'lyricism',
+  'lyricist',
+  'lyrics',
+  'macarena',
+  'macaroni',
+  'macaw',
+  'mace',
+  'machine',
+  'machinist',
+  'magazine',
+  'magenta',
+  'maggot',
+  'magical',
+  'magician',
+  'magma',
+  'magnesium',
+  'magnetic',
+  'magnetism',
+  'magnetize',
+  'magnifier',
+  'magnify',
+  'magnitude',
+  'magnolia',
+  'mahogany',
+  'maimed',
+  'majestic',
+  'majesty',
+  'majorette',
+  'majority',
+  'makeover',
+  'maker',
+  'makeshift',
+  'making',
+  'malformed',
+  'malt',
+  'mama',
+  'mammal',
+  'mammary',
+  'mammogram',
+  'manager',
+  'managing',
+  'manatee',
+  'mandarin',
+  'mandate',
+  'mandatory',
+  'mandolin',
+  'manger',
+  'mangle',
+  'mango',
+  'mangy',
+  'manhandle',
+  'manhole',
+  'manhood',
+  'manhunt',
+  'manicotti',
+  'manicure',
+  'manifesto',
+  'manila',
+  'mankind',
+  'manlike',
+  'manliness',
+  'manly',
+  'manmade',
+  'manned',
+  'mannish',
+  'manor',
+  'manpower',
+  'mantis',
+  'mantra',
+  'manual',
+  'many',
+  'map',
+  'marathon',
+  'marauding',
+  'marbled',
+  'marbles',
+  'marbling',
+  'march',
+  'mardi',
+  'margarine',
+  'margarita',
+  'margin',
+  'marigold',
+  'marina',
+  'marine',
+  'marital',
+  'maritime',
+  'marlin',
+  'marmalade',
+  'maroon',
+  'married',
+  'marrow',
+  'marry',
+  'marshland',
+  'marshy',
+  'marsupial',
+  'marvelous',
+  'marxism',
+  'mascot',
+  'masculine',
+  'mashed',
+  'mashing',
+  'massager',
+  'masses',
+  'massive',
+  'mastiff',
+  'matador',
+  'matchbook',
+  'matchbox',
+  'matcher',
+  'matching',
+  'matchless',
+  'material',
+  'maternal',
+  'maternity',
+  'math',
+  'mating',
+  'matriarch',
+  'matrimony',
+  'matrix',
+  'matron',
+  'matted',
+  'matter',
+  'maturely',
+  'maturing',
+  'maturity',
+  'mauve',
+  'maverick',
+  'maximize',
+  'maximum',
+  'maybe',
+  'mayday',
+  'mayflower',
+  'moaner',
+  'moaning',
+  'mobile',
+  'mobility',
+  'mobilize',
+  'mobster',
+  'mocha',
+  'mocker',
+  'mockup',
+  'modified',
+  'modify',
+  'modular',
+  'modulator',
+  'module',
+  'moisten',
+  'moistness',
+  'moisture',
+  'molar',
+  'molasses',
+  'mold',
+  'molecular',
+  'molecule',
+  'molehill',
+  'mollusk',
+  'mom',
+  'monastery',
+  'monday',
+  'monetary',
+  'monetize',
+  'moneybags',
+  'moneyless',
+  'moneywise',
+  'mongoose',
+  'mongrel',
+  'monitor',
+  'monkhood',
+  'monogamy',
+  'monogram',
+  'monologue',
+  'monopoly',
+  'monorail',
+  'monotone',
+  'monotype',
+  'monoxide',
+  'monsieur',
+  'monsoon',
+  'monstrous',
+  'monthly',
+  'monument',
+  'moocher',
+  'moodiness',
+  'moody',
+  'mooing',
+  'moonbeam',
+  'mooned',
+  'moonlight',
+  'moonlike',
+  'moonlit',
+  'moonrise',
+  'moonscape',
+  'moonshine',
+  'moonstone',
+  'moonwalk',
+  'mop',
+  'morale',
+  'morality',
+  'morally',
+  'morbidity',
+  'morbidly',
+  'morphine',
+  'morphing',
+  'morse',
+  'mortality',
+  'mortally',
+  'mortician',
+  'mortified',
+  'mortify',
+  'mortuary',
+  'mosaic',
+  'mossy',
+  'most',
+  'mothball',
+  'mothproof',
+  'motion',
+  'motivate',
+  'motivator',
+  'motive',
+  'motocross',
+  'motor',
+  'motto',
+  'mountable',
+  'mountain',
+  'mounted',
+  'mounting',
+  'mourner',
+  'mournful',
+  'mouse',
+  'mousiness',
+  'moustache',
+  'mousy',
+  'mouth',
+  'movable',
+  'move',
+  'movie',
+  'moving',
+  'mower',
+  'mowing',
+  'much',
+  'muck',
+  'mud',
+  'mug',
+  'mulberry',
+  'mulch',
+  'mule',
+  'mulled',
+  'mullets',
+  'multiple',
+  'multiply',
+  'multitask',
+  'multitude',
+  'mumble',
+  'mumbling',
+  'mumbo',
+  'mummified',
+  'mummify',
+  'mummy',
+  'mumps',
+  'munchkin',
+  'mundane',
+  'municipal',
+  'muppet',
+  'mural',
+  'murkiness',
+  'murky',
+  'murmuring',
+  'muscular',
+  'museum',
+  'mushily',
+  'mushiness',
+  'mushroom',
+  'mushy',
+  'music',
+  'musket',
+  'muskiness',
+  'musky',
+  'mustang',
+  'mustard',
+  'muster',
+  'mustiness',
+  'musty',
+  'mutable',
+  'mutate',
+  'mutation',
+  'mute',
+  'mutilated',
+  'mutilator',
+  'mutiny',
+  'mutt',
+  'mutual',
+  'muzzle',
+  'myself',
+  'myspace',
+  'mystified',
+  'mystify',
+  'myth',
+  'nacho',
+  'nag',
+  'nail',
+  'name',
+  'naming',
+  'nanny',
+  'nanometer',
+  'nape',
+  'napkin',
+  'napped',
+  'napping',
+  'nappy',
+  'narrow',
+  'nastily',
+  'nastiness',
+  'national',
+  'native',
+  'nativity',
+  'natural',
+  'nature',
+  'naturist',
+  'nautical',
+  'navigate',
+  'navigator',
+  'navy',
+  'nearby',
+  'nearest',
+  'nearly',
+  'nearness',
+  'neatly',
+  'neatness',
+  'nebula',
+  'nebulizer',
+  'nectar',
+  'negate',
+  'negation',
+  'negative',
+  'neglector',
+  'negligee',
+  'negligent',
+  'negotiate',
+  'nemeses',
+  'nemesis',
+  'neon',
+  'nephew',
+  'nerd',
+  'nervous',
+  'nervy',
+  'nest',
+  'net',
+  'neurology',
+  'neuron',
+  'neurosis',
+  'neurotic',
+  'neuter',
+  'neutron',
+  'never',
+  'next',
+  'nibble',
+  'nickname',
+  'nicotine',
+  'niece',
+  'nifty',
+  'nimble',
+  'nimbly',
+  'nineteen',
+  'ninetieth',
+  'ninja',
+  'nintendo',
+  'ninth',
+  'nuclear',
+  'nuclei',
+  'nucleus',
+  'nugget',
+  'nullify',
+  'number',
+  'numbing',
+  'numbly',
+  'numbness',
+  'numeral',
+  'numerate',
+  'numerator',
+  'numeric',
+  'numerous',
+  'nuptials',
+  'nursery',
+  'nursing',
+  'nurture',
+  'nutcase',
+  'nutlike',
+  'nutmeg',
+  'nutrient',
+  'nutshell',
+  'nuttiness',
+  'nutty',
+  'nuzzle',
+  'nylon',
+  'oaf',
+  'oak',
+  'oasis',
+  'oat',
+  'obedience',
+  'obedient',
+  'obituary',
+  'object',
+  'obligate',
+  'obliged',
+  'oblivion',
+  'oblivious',
+  'oblong',
+  'obnoxious',
+  'oboe',
+  'obscure',
+  'obscurity',
+  'observant',
+  'observer',
+  'observing',
+  'obsessed',
+  'obsession',
+  'obsessive',
+  'obsolete',
+  'obstacle',
+  'obstinate',
+  'obstruct',
+  'obtain',
+  'obtrusive',
+  'obtuse',
+  'obvious',
+  'occultist',
+  'occupancy',
+  'occupant',
+  'occupier',
+  'occupy',
+  'ocean',
+  'ocelot',
+  'octagon',
+  'octane',
+  'october',
+  'octopus',
+  'ogle',
+  'oil',
+  'oink',
+  'ointment',
+  'okay',
+  'old',
+  'olive',
+  'olympics',
+  'omega',
+  'omen',
+  'ominous',
+  'omission',
+  'omit',
+  'omnivore',
+  'onboard',
+  'oncoming',
+  'ongoing',
+  'onion',
+  'online',
+  'onlooker',
+  'only',
+  'onscreen',
+  'onset',
+  'onshore',
+  'onslaught',
+  'onstage',
+  'onto',
+  'onward',
+  'onyx',
+  'oops',
+  'ooze',
+  'oozy',
+  'opacity',
+  'opal',
+  'open',
+  'operable',
+  'operate',
+  'operating',
+  'operation',
+  'operative',
+  'operator',
+  'opium',
+  'opossum',
+  'opponent',
+  'oppose',
+  'opposing',
+  'opposite',
+  'oppressed',
+  'oppressor',
+  'opt',
+  'opulently',
+  'osmosis',
+  'other',
+  'otter',
+  'ouch',
+  'ought',
+  'ounce',
+  'outage',
+  'outback',
+  'outbid',
+  'outboard',
+  'outbound',
+  'outbreak',
+  'outburst',
+  'outcast',
+  'outclass',
+  'outcome',
+  'outdated',
+  'outdoors',
+  'outer',
+  'outfield',
+  'outfit',
+  'outflank',
+  'outgoing',
+  'outgrow',
+  'outhouse',
+  'outing',
+  'outlast',
+  'outlet',
+  'outline',
+  'outlook',
+  'outlying',
+  'outmatch',
+  'outmost',
+  'outnumber',
+  'outplayed',
+  'outpost',
+  'outpour',
+  'output',
+  'outrage',
+  'outrank',
+  'outreach',
+  'outright',
+  'outscore',
+  'outsell',
+  'outshine',
+  'outshoot',
+  'outsider',
+  'outskirts',
+  'outsmart',
+  'outsource',
+  'outspoken',
+  'outtakes',
+  'outthink',
+  'outward',
+  'outweigh',
+  'outwit',
+  'oval',
+  'ovary',
+  'oven',
+  'overact',
+  'overall',
+  'overarch',
+  'overbid',
+  'overbill',
+  'overbite',
+  'overblown',
+  'overboard',
+  'overbook',
+  'overbuilt',
+  'overcast',
+  'overcoat',
+  'overcome',
+  'overcook',
+  'overcrowd',
+  'overdraft',
+  'overdrawn',
+  'overdress',
+  'overdrive',
+  'overdue',
+  'overeager',
+  'overeater',
+  'overexert',
+  'overfed',
+  'overfeed',
+  'overfill',
+  'overflow',
+  'overfull',
+  'overgrown',
+  'overhand',
+  'overhang',
+  'overhaul',
+  'overhead',
+  'overhear',
+  'overheat',
+  'overhung',
+  'overjoyed',
+  'overkill',
+  'overlabor',
+  'overlaid',
+  'overlap',
+  'overlay',
+  'overload',
+  'overlook',
+  'overlord',
+  'overlying',
+  'overnight',
+  'overpass',
+  'overpay',
+  'overplant',
+  'overplay',
+  'overpower',
+  'overprice',
+  'overrate',
+  'overreach',
+  'overreact',
+  'override',
+  'overripe',
+  'overrule',
+  'overrun',
+  'overshoot',
+  'overshot',
+  'oversight',
+  'oversized',
+  'oversleep',
+  'oversold',
+  'overspend',
+  'overstate',
+  'overstay',
+  'overstep',
+  'overstock',
+  'overstuff',
+  'oversweet',
+  'overtake',
+  'overthrow',
+  'overtime',
+  'overtly',
+  'overtone',
+  'overture',
+  'overturn',
+  'overuse',
+  'overvalue',
+  'overview',
+  'overwrite',
+  'owl',
+  'oxford',
+  'oxidant',
+  'oxidation',
+  'oxidize',
+  'oxidizing',
+  'oxygen',
+  'oxymoron',
+  'oyster',
+  'ozone',
+  'paced',
+  'pacemaker',
+  'pacific',
+  'pacifier',
+  'pacifism',
+  'pacifist',
+  'pacify',
+  'padded',
+  'padding',
+  'paddle',
+  'paddling',
+  'padlock',
+  'pagan',
+  'pager',
+  'paging',
+  'pajamas',
+  'palace',
+  'palatable',
+  'palm',
+  'palpable',
+  'palpitate',
+  'paltry',
+  'pampered',
+  'pamperer',
+  'pampers',
+  'pamphlet',
+  'panama',
+  'pancake',
+  'pancreas',
+  'panda',
+  'pandemic',
+  'pang',
+  'panhandle',
+  'panic',
+  'panning',
+  'panorama',
+  'panoramic',
+  'panther',
+  'pantomime',
+  'pantry',
+  'pants',
+  'pantyhose',
+  'paparazzi',
+  'papaya',
+  'paper',
+  'paprika',
+  'papyrus',
+  'parabola',
+  'parachute',
+  'parade',
+  'paradox',
+  'paragraph',
+  'parakeet',
+  'paralegal',
+  'paralyses',
+  'paralysis',
+  'paralyze',
+  'paramedic',
+  'parameter',
+  'paramount',
+  'parasail',
+  'parasite',
+  'parasitic',
+  'parcel',
+  'parched',
+  'parchment',
+  'pardon',
+  'parish',
+  'parka',
+  'parking',
+  'parkway',
+  'parlor',
+  'parmesan',
+  'parole',
+  'parrot',
+  'parsley',
+  'parsnip',
+  'partake',
+  'parted',
+  'parting',
+  'partition',
+  'partly',
+  'partner',
+  'partridge',
+  'party',
+  'passable',
+  'passably',
+  'passage',
+  'passcode',
+  'passenger',
+  'passerby',
+  'passing',
+  'passion',
+  'passive',
+  'passivism',
+  'passover',
+  'passport',
+  'password',
+  'pasta',
+  'pasted',
+  'pastel',
+  'pastime',
+  'pastor',
+  'pastrami',
+  'pasture',
+  'pasty',
+  'patchwork',
+  'patchy',
+  'paternal',
+  'paternity',
+  'path',
+  'patience',
+  'patient',
+  'patio',
+  'patriarch',
+  'patriot',
+  'patrol',
+  'patronage',
+  'patronize',
+  'pauper',
+  'pavement',
+  'paver',
+  'pavestone',
+  'pavilion',
+  'paving',
+  'pawing',
+  'payable',
+  'payback',
+  'paycheck',
+  'payday',
+  'payee',
+  'payer',
+  'paying',
+  'payment',
+  'payphone',
+  'payroll',
+  'pebble',
+  'pebbly',
+  'pecan',
+  'pectin',
+  'peculiar',
+  'peddling',
+  'pediatric',
+  'pedicure',
+  'pedigree',
+  'pedometer',
+  'pegboard',
+  'pelican',
+  'pellet',
+  'pelt',
+  'pelvis',
+  'penalize',
+  'penalty',
+  'pencil',
+  'pendant',
+  'pending',
+  'penholder',
+  'penknife',
+  'pennant',
+  'penniless',
+  'penny',
+  'penpal',
+  'pension',
+  'pentagon',
+  'pentagram',
+  'pep',
+  'perceive',
+  'percent',
+  'perch',
+  'percolate',
+  'perennial',
+  'perfected',
+  'perfectly',
+  'perfume',
+  'periscope',
+  'perish',
+  'perjurer',
+  'perjury',
+  'perkiness',
+  'perky',
+  'perm',
+  'peroxide',
+  'perpetual',
+  'perplexed',
+  'persecute',
+  'persevere',
+  'persuaded',
+  'persuader',
+  'pesky',
+  'peso',
+  'pessimism',
+  'pessimist',
+  'pester',
+  'pesticide',
+  'petal',
+  'petite',
+  'petition',
+  'petri',
+  'petroleum',
+  'petted',
+  'petticoat',
+  'pettiness',
+  'petty',
+  'petunia',
+  'phantom',
+  'phobia',
+  'phoenix',
+  'phonebook',
+  'phoney',
+  'phonics',
+  'phoniness',
+  'phony',
+  'phosphate',
+  'photo',
+  'phrase',
+  'phrasing',
+  'placard',
+  'placate',
+  'placidly',
+  'plank',
+  'planner',
+  'plant',
+  'plasma',
+  'plaster',
+  'plastic',
+  'plated',
+  'platform',
+  'plating',
+  'platinum',
+  'platonic',
+  'platter',
+  'platypus',
+  'plausible',
+  'plausibly',
+  'playable',
+  'playback',
+  'player',
+  'playful',
+  'playgroup',
+  'playhouse',
+  'playing',
+  'playlist',
+  'playmaker',
+  'playmate',
+  'playoff',
+  'playpen',
+  'playroom',
+  'playset',
+  'plaything',
+  'playtime',
+  'plaza',
+  'pleading',
+  'pleat',
+  'pledge',
+  'plentiful',
+  'plenty',
+  'plethora',
+  'plexiglas',
+  'pliable',
+  'plod',
+  'plop',
+  'plot',
+  'plow',
+  'ploy',
+  'pluck',
+  'plug',
+  'plunder',
+  'plunging',
+  'plural',
+  'plus',
+  'plutonium',
+  'plywood',
+  'poach',
+  'pod',
+  'poem',
+  'poet',
+  'pogo',
+  'pointed',
+  'pointer',
+  'pointing',
+  'pointless',
+  'pointy',
+  'poise',
+  'poison',
+  'poker',
+  'poking',
+  'polar',
+  'police',
+  'policy',
+  'polio',
+  'polish',
+  'politely',
+  'polka',
+  'polo',
+  'polyester',
+  'polygon',
+  'polygraph',
+  'polymer',
+  'poncho',
+  'pond',
+  'pony',
+  'popcorn',
+  'pope',
+  'poplar',
+  'popper',
+  'poppy',
+  'popsicle',
+  'populace',
+  'popular',
+  'populate',
+  'porcupine',
+  'pork',
+  'porous',
+  'porridge',
+  'portable',
+  'portal',
+  'portfolio',
+  'porthole',
+  'portion',
+  'portly',
+  'portside',
+  'poser',
+  'posh',
+  'posing',
+  'possible',
+  'possibly',
+  'possum',
+  'postage',
+  'postal',
+  'postbox',
+  'postcard',
+  'posted',
+  'poster',
+  'posting',
+  'postnasal',
+  'posture',
+  'postwar',
+  'pouch',
+  'pounce',
+  'pouncing',
+  'pound',
+  'pouring',
+  'pout',
+  'powdered',
+  'powdering',
+  'powdery',
+  'power',
+  'powwow',
+  'pox',
+  'praising',
+  'prance',
+  'prancing',
+  'pranker',
+  'prankish',
+  'prankster',
+  'prayer',
+  'praying',
+  'preacher',
+  'preaching',
+  'preachy',
+  'preamble',
+  'precinct',
+  'precise',
+  'precision',
+  'precook',
+  'precut',
+  'predator',
+  'predefine',
+  'predict',
+  'preface',
+  'prefix',
+  'preflight',
+  'preformed',
+  'pregame',
+  'pregnancy',
+  'pregnant',
+  'preheated',
+  'prelaunch',
+  'prelaw',
+  'prelude',
+  'premiere',
+  'premises',
+  'premium',
+  'prenatal',
+  'preoccupy',
+  'preorder',
+  'prepaid',
+  'prepay',
+  'preplan',
+  'preppy',
+  'preschool',
+  'prescribe',
+  'preseason',
+  'preset',
+  'preshow',
+  'president',
+  'presoak',
+  'press',
+  'presume',
+  'presuming',
+  'preteen',
+  'pretended',
+  'pretender',
+  'pretense',
+  'pretext',
+  'pretty',
+  'pretzel',
+  'prevail',
+  'prevalent',
+  'prevent',
+  'preview',
+  'previous',
+  'prewar',
+  'prewashed',
+  'prideful',
+  'pried',
+  'primal',
+  'primarily',
+  'primary',
+  'primate',
+  'primer',
+  'primp',
+  'princess',
+  'print',
+  'prior',
+  'prism',
+  'prison',
+  'prissy',
+  'pristine',
+  'privacy',
+  'private',
+  'privatize',
+  'prize',
+  'proactive',
+  'probable',
+  'probably',
+  'probation',
+  'probe',
+  'probing',
+  'probiotic',
+  'problem',
+  'procedure',
+  'process',
+  'proclaim',
+  'procreate',
+  'procurer',
+  'prodigal',
+  'prodigy',
+  'produce',
+  'product',
+  'profane',
+  'profanity',
+  'professed',
+  'professor',
+  'profile',
+  'profound',
+  'profusely',
+  'progeny',
+  'prognosis',
+  'program',
+  'progress',
+  'projector',
+  'prologue',
+  'prolonged',
+  'promenade',
+  'prominent',
+  'promoter',
+  'promotion',
+  'prompter',
+  'promptly',
+  'prone',
+  'prong',
+  'pronounce',
+  'pronto',
+  'proofing',
+  'proofread',
+  'proofs',
+  'propeller',
+  'properly',
+  'property',
+  'proponent',
+  'proposal',
+  'propose',
+  'props',
+  'prorate',
+  'protector',
+  'protegee',
+  'proton',
+  'prototype',
+  'protozoan',
+  'protract',
+  'protrude',
+  'proud',
+  'provable',
+  'proved',
+  'proven',
+  'provided',
+  'provider',
+  'providing',
+  'province',
+  'proving',
+  'provoke',
+  'provoking',
+  'provolone',
+  'prowess',
+  'prowler',
+  'prowling',
+  'proximity',
+  'proxy',
+  'prozac',
+  'prude',
+  'prudishly',
+  'prune',
+  'pruning',
+  'pry',
+  'psychic',
+  'public',
+  'publisher',
+  'pucker',
+  'pueblo',
+  'pug',
+  'pull',
+  'pulmonary',
+  'pulp',
+  'pulsate',
+  'pulse',
+  'pulverize',
+  'puma',
+  'pumice',
+  'pummel',
+  'punch',
+  'punctual',
+  'punctuate',
+  'punctured',
+  'pungent',
+  'punisher',
+  'punk',
+  'pupil',
+  'puppet',
+  'puppy',
+  'purchase',
+  'pureblood',
+  'purebred',
+  'purely',
+  'pureness',
+  'purgatory',
+  'purge',
+  'purging',
+  'purifier',
+  'purify',
+  'purist',
+  'puritan',
+  'purity',
+  'purple',
+  'purplish',
+  'purposely',
+  'purr',
+  'purse',
+  'pursuable',
+  'pursuant',
+  'pursuit',
+  'purveyor',
+  'pushcart',
+  'pushchair',
+  'pusher',
+  'pushiness',
+  'pushing',
+  'pushover',
+  'pushpin',
+  'pushup',
+  'pushy',
+  'putdown',
+  'putt',
+  'puzzle',
+  'puzzling',
+  'pyramid',
+  'pyromania',
+  'python',
+  'quack',
+  'quadrant',
+  'quail',
+  'quaintly',
+  'quake',
+  'quaking',
+  'qualified',
+  'qualifier',
+  'qualify',
+  'quality',
+  'qualm',
+  'quantum',
+  'quarrel',
+  'quarry',
+  'quartered',
+  'quarterly',
+  'quarters',
+  'quartet',
+  'quench',
+  'query',
+  'quicken',
+  'quickly',
+  'quickness',
+  'quicksand',
+  'quickstep',
+  'quiet',
+  'quill',
+  'quilt',
+  'quintet',
+  'quintuple',
+  'quirk',
+  'quit',
+  'quiver',
+  'quizzical',
+  'quotable',
+  'quotation',
+  'quote',
+  'rabid',
+  'race',
+  'racing',
+  'racism',
+  'rack',
+  'racoon',
+  'radar',
+  'radial',
+  'radiance',
+  'radiantly',
+  'radiated',
+  'radiation',
+  'radiator',
+  'radio',
+  'radish',
+  'raffle',
+  'raft',
+  'rage',
+  'ragged',
+  'raging',
+  'ragweed',
+  'raider',
+  'railcar',
+  'railing',
+  'railroad',
+  'railway',
+  'raisin',
+  'rake',
+  'raking',
+  'rally',
+  'ramble',
+  'rambling',
+  'ramp',
+  'ramrod',
+  'ranch',
+  'rancidity',
+  'random',
+  'ranged',
+  'ranger',
+  'ranging',
+  'ranked',
+  'ranking',
+  'ransack',
+  'ranting',
+  'rants',
+  'rare',
+  'rarity',
+  'rascal',
+  'rash',
+  'rasping',
+  'ravage',
+  'raven',
+  'ravine',
+  'raving',
+  'ravioli',
+  'ravishing',
+  'reabsorb',
+  'reach',
+  'reacquire',
+  'reaction',
+  'reactive',
+  'reactor',
+  'reaffirm',
+  'ream',
+  'reanalyze',
+  'reappear',
+  'reapply',
+  'reappoint',
+  'reapprove',
+  'rearrange',
+  'rearview',
+  'reason',
+  'reassign',
+  'reassure',
+  'reattach',
+  'reawake',
+  'rebalance',
+  'rebate',
+  'rebel',
+  'rebirth',
+  'reboot',
+  'reborn',
+  'rebound',
+  'rebuff',
+  'rebuild',
+  'rebuilt',
+  'reburial',
+  'rebuttal',
+  'recall',
+  'recant',
+  'recapture',
+  'recast',
+  'recede',
+  'recent',
+  'recess',
+  'recharger',
+  'recipient',
+  'recital',
+  'recite',
+  'reckless',
+  'reclaim',
+  'recliner',
+  'reclining',
+  'recluse',
+  'reclusive',
+  'recognize',
+  'recoil',
+  'recollect',
+  'recolor',
+  'reconcile',
+  'reconfirm',
+  'reconvene',
+  'recopy',
+  'record',
+  'recount',
+  'recoup',
+  'recovery',
+  'recreate',
+  'rectal',
+  'rectangle',
+  'rectified',
+  'rectify',
+  'recycled',
+  'recycler',
+  'recycling',
+  'reemerge',
+  'reenact',
+  'reenter',
+  'reentry',
+  'reexamine',
+  'referable',
+  'referee',
+  'reference',
+  'refill',
+  'refinance',
+  'refined',
+  'refinery',
+  'refining',
+  'refinish',
+  'reflected',
+  'reflector',
+  'reflex',
+  'reflux',
+  'refocus',
+  'refold',
+  'reforest',
+  'reformat',
+  'reformed',
+  'reformer',
+  'reformist',
+  'refract',
+  'refrain',
+  'refreeze',
+  'refresh',
+  'refried',
+  'refueling',
+  'refund',
+  'refurbish',
+  'refurnish',
+  'refusal',
+  'refuse',
+  'refusing',
+  'refutable',
+  'refute',
+  'regain',
+  'regalia',
+  'regally',
+  'reggae',
+  'regime',
+  'region',
+  'register',
+  'registrar',
+  'registry',
+  'regress',
+  'regretful',
+  'regroup',
+  'regular',
+  'regulate',
+  'regulator',
+  'rehab',
+  'reheat',
+  'rehire',
+  'rehydrate',
+  'reimburse',
+  'reissue',
+  'reiterate',
+  'rejoice',
+  'rejoicing',
+  'rejoin',
+  'rekindle',
+  'relapse',
+  'relapsing',
+  'relatable',
+  'related',
+  'relation',
+  'relative',
+  'relax',
+  'relay',
+  'relearn',
+  'release',
+  'relenting',
+  'reliable',
+  'reliably',
+  'reliance',
+  'reliant',
+  'relic',
+  'relieve',
+  'relieving',
+  'relight',
+  'relish',
+  'relive',
+  'reload',
+  'relocate',
+  'relock',
+  'reluctant',
+  'rely',
+  'remake',
+  'remark',
+  'remarry',
+  'rematch',
+  'remedial',
+  'remedy',
+  'remember',
+  'reminder',
+  'remindful',
+  'remission',
+  'remix',
+  'remnant',
+  'remodeler',
+  'remold',
+  'remorse',
+  'remote',
+  'removable',
+  'removal',
+  'removed',
+  'remover',
+  'removing',
+  'rename',
+  'renderer',
+  'rendering',
+  'rendition',
+  'renegade',
+  'renewable',
+  'renewably',
+  'renewal',
+  'renewed',
+  'renounce',
+  'renovate',
+  'renovator',
+  'rentable',
+  'rental',
+  'rented',
+  'renter',
+  'reoccupy',
+  'reoccur',
+  'reopen',
+  'reorder',
+  'repackage',
+  'repacking',
+  'repaint',
+  'repair',
+  'repave',
+  'repaying',
+  'repayment',
+  'repeal',
+  'repeated',
+  'repeater',
+  'repent',
+  'rephrase',
+  'replace',
+  'replay',
+  'replica',
+  'reply',
+  'reporter',
+  'repose',
+  'repossess',
+  'repost',
+  'repressed',
+  'reprimand',
+  'reprint',
+  'reprise',
+  'reproach',
+  'reprocess',
+  'reproduce',
+  'reprogram',
+  'reps',
+  'reptile',
+  'reptilian',
+  'repugnant',
+  'repulsion',
+  'repulsive',
+  'repurpose',
+  'reputable',
+  'reputably',
+  'request',
+  'require',
+  'requisite',
+  'reroute',
+  'rerun',
+  'resale',
+  'resample',
+  'rescuer',
+  'reseal',
+  'research',
+  'reselect',
+  'reseller',
+  'resemble',
+  'resend',
+  'resent',
+  'reset',
+  'reshape',
+  'reshoot',
+  'reshuffle',
+  'residence',
+  'residency',
+  'resident',
+  'residual',
+  'residue',
+  'resigned',
+  'resilient',
+  'resistant',
+  'resisting',
+  'resize',
+  'resolute',
+  'resolved',
+  'resonant',
+  'resonate',
+  'resort',
+  'resource',
+  'respect',
+  'resubmit',
+  'result',
+  'resume',
+  'resupply',
+  'resurface',
+  'resurrect',
+  'retail',
+  'retainer',
+  'retaining',
+  'retake',
+  'retaliate',
+  'retention',
+  'rethink',
+  'retinal',
+  'retired',
+  'retiree',
+  'retiring',
+  'retold',
+  'retool',
+  'retorted',
+  'retouch',
+  'retrace',
+  'retract',
+  'retrain',
+  'retread',
+  'retreat',
+  'retrial',
+  'retrieval',
+  'retriever',
+  'retry',
+  'return',
+  'retying',
+  'retype',
+  'reunion',
+  'reunite',
+  'reusable',
+  'reuse',
+  'reveal',
+  'reveler',
+  'revenge',
+  'revenue',
+  'reverb',
+  'revered',
+  'reverence',
+  'reverend',
+  'reversal',
+  'reverse',
+  'reversing',
+  'reversion',
+  'revert',
+  'revisable',
+  'revise',
+  'revision',
+  'revisit',
+  'revivable',
+  'revival',
+  'reviver',
+  'reviving',
+  'revocable',
+  'revoke',
+  'revolt',
+  'revolver',
+  'revolving',
+  'reward',
+  'rewash',
+  'rewind',
+  'rewire',
+  'reword',
+  'rework',
+  'rewrap',
+  'rewrite',
+  'rhyme',
+  'ribbon',
+  'ribcage',
+  'rice',
+  'riches',
+  'richly',
+  'richness',
+  'rickety',
+  'ricotta',
+  'riddance',
+  'ridden',
+  'ride',
+  'riding',
+  'rifling',
+  'rift',
+  'rigging',
+  'rigid',
+  'rigor',
+  'rimless',
+  'rimmed',
+  'rind',
+  'rink',
+  'rinse',
+  'rinsing',
+  'riot',
+  'ripcord',
+  'ripeness',
+  'ripening',
+  'ripping',
+  'ripple',
+  'rippling',
+  'riptide',
+  'rise',
+  'rising',
+  'risk',
+  'risotto',
+  'ritalin',
+  'ritzy',
+  'rival',
+  'riverbank',
+  'riverbed',
+  'riverboat',
+  'riverside',
+  'riveter',
+  'riveting',
+  'roamer',
+  'roaming',
+  'roast',
+  'robbing',
+  'robe',
+  'robin',
+  'robotics',
+  'robust',
+  'rockband',
+  'rocker',
+  'rocket',
+  'rockfish',
+  'rockiness',
+  'rocking',
+  'rocklike',
+  'rockslide',
+  'rockstar',
+  'rocky',
+  'rogue',
+  'roman',
+  'romp',
+  'rope',
+  'roping',
+  'roster',
+  'rosy',
+  'rotten',
+  'rotting',
+  'rotunda',
+  'roulette',
+  'rounding',
+  'roundish',
+  'roundness',
+  'roundup',
+  'roundworm',
+  'routine',
+  'routing',
+  'rover',
+  'roving',
+  'royal',
+  'rubbed',
+  'rubber',
+  'rubbing',
+  'rubble',
+  'rubdown',
+  'ruby',
+  'ruckus',
+  'rudder',
+  'rug',
+  'ruined',
+  'rule',
+  'rumble',
+  'rumbling',
+  'rummage',
+  'rumor',
+  'runaround',
+  'rundown',
+  'runner',
+  'running',
+  'runny',
+  'runt',
+  'runway',
+  'rupture',
+  'rural',
+  'ruse',
+  'rush',
+  'rust',
+  'rut',
+  'sabbath',
+  'sabotage',
+  'sacrament',
+  'sacred',
+  'sacrifice',
+  'sadden',
+  'saddlebag',
+  'saddled',
+  'saddling',
+  'sadly',
+  'sadness',
+  'safari',
+  'safeguard',
+  'safehouse',
+  'safely',
+  'safeness',
+  'saffron',
+  'saga',
+  'sage',
+  'sagging',
+  'saggy',
+  'said',
+  'saint',
+  'sake',
+  'salad',
+  'salami',
+  'salaried',
+  'salary',
+  'saline',
+  'salon',
+  'saloon',
+  'salsa',
+  'salt',
+  'salutary',
+  'salute',
+  'salvage',
+  'salvaging',
+  'salvation',
+  'same',
+  'sample',
+  'sampling',
+  'sanction',
+  'sanctity',
+  'sanctuary',
+  'sandal',
+  'sandbag',
+  'sandbank',
+  'sandbar',
+  'sandblast',
+  'sandbox',
+  'sanded',
+  'sandfish',
+  'sanding',
+  'sandlot',
+  'sandpaper',
+  'sandpit',
+  'sandstone',
+  'sandstorm',
+  'sandworm',
+  'sandy',
+  'sanitary',
+  'sanitizer',
+  'sank',
+  'santa',
+  'sapling',
+  'sappiness',
+  'sappy',
+  'sarcasm',
+  'sarcastic',
+  'sardine',
+  'sash',
+  'sasquatch',
+  'sassy',
+  'satchel',
+  'satiable',
+  'satin',
+  'satirical',
+  'satisfied',
+  'satisfy',
+  'saturate',
+  'saturday',
+  'sauciness',
+  'saucy',
+  'sauna',
+  'savage',
+  'savanna',
+  'saved',
+  'savings',
+  'savior',
+  'savor',
+  'saxophone',
+  'say',
+  'scabbed',
+  'scabby',
+  'scalded',
+  'scalding',
+  'scale',
+  'scaling',
+  'scallion',
+  'scallop',
+  'scalping',
+  'scam',
+  'scandal',
+  'scanner',
+  'scanning',
+  'scant',
+  'scapegoat',
+  'scarce',
+  'scarcity',
+  'scarecrow',
+  'scared',
+  'scarf',
+  'scarily',
+  'scariness',
+  'scarring',
+  'scary',
+  'scavenger',
+  'scenic',
+  'schedule',
+  'schematic',
+  'scheme',
+  'scheming',
+  'schilling',
+  'schnapps',
+  'scholar',
+  'science',
+  'scientist',
+  'scion',
+  'scoff',
+  'scolding',
+  'scone',
+  'scoop',
+  'scooter',
+  'scope',
+  'scorch',
+  'scorebook',
+  'scorecard',
+  'scored',
+  'scoreless',
+  'scorer',
+  'scoring',
+  'scorn',
+  'scorpion',
+  'scotch',
+  'scoundrel',
+  'scoured',
+  'scouring',
+  'scouting',
+  'scouts',
+  'scowling',
+  'scrabble',
+  'scraggly',
+  'scrambled',
+  'scrambler',
+  'scrap',
+  'scratch',
+  'scrawny',
+  'screen',
+  'scribble',
+  'scribe',
+  'scribing',
+  'scrimmage',
+  'script',
+  'scroll',
+  'scrooge',
+  'scrounger',
+  'scrubbed',
+  'scrubber',
+  'scruffy',
+  'scrunch',
+  'scrutiny',
+  'scuba',
+  'scuff',
+  'sculptor',
+  'sculpture',
+  'scurvy',
+  'scuttle',
+  'secluded',
+  'secluding',
+  'seclusion',
+  'second',
+  'secrecy',
+  'secret',
+  'sectional',
+  'sector',
+  'secular',
+  'securely',
+  'security',
+  'sedan',
+  'sedate',
+  'sedation',
+  'sedative',
+  'sediment',
+  'seduce',
+  'seducing',
+  'segment',
+  'seismic',
+  'seizing',
+  'seldom',
+  'selected',
+  'selection',
+  'selective',
+  'selector',
+  'self',
+  'seltzer',
+  'semantic',
+  'semester',
+  'semicolon',
+  'semifinal',
+  'seminar',
+  'semisoft',
+  'semisweet',
+  'senate',
+  'senator',
+  'send',
+  'senior',
+  'senorita',
+  'sensation',
+  'sensitive',
+  'sensitize',
+  'sensually',
+  'sensuous',
+  'sepia',
+  'september',
+  'septic',
+  'septum',
+  'sequel',
+  'sequence',
+  'sequester',
+  'series',
+  'sermon',
+  'serotonin',
+  'serpent',
+  'serrated',
+  'serve',
+  'service',
+  'serving',
+  'sesame',
+  'sessions',
+  'setback',
+  'setting',
+  'settle',
+  'settling',
+  'setup',
+  'sevenfold',
+  'seventeen',
+  'seventh',
+  'seventy',
+  'severity',
+  'shabby',
+  'shack',
+  'shaded',
+  'shadily',
+  'shadiness',
+  'shading',
+  'shadow',
+  'shady',
+  'shaft',
+  'shakable',
+  'shakily',
+  'shakiness',
+  'shaking',
+  'shaky',
+  'shale',
+  'shallot',
+  'shallow',
+  'shame',
+  'shampoo',
+  'shamrock',
+  'shank',
+  'shanty',
+  'shape',
+  'shaping',
+  'share',
+  'sharpener',
+  'sharper',
+  'sharpie',
+  'sharply',
+  'sharpness',
+  'shawl',
+  'sheath',
+  'shed',
+  'sheep',
+  'sheet',
+  'shelf',
+  'shell',
+  'shelter',
+  'shelve',
+  'shelving',
+  'sherry',
+  'shield',
+  'shifter',
+  'shifting',
+  'shiftless',
+  'shifty',
+  'shimmer',
+  'shimmy',
+  'shindig',
+  'shine',
+  'shingle',
+  'shininess',
+  'shining',
+  'shiny',
+  'ship',
+  'shirt',
+  'shivering',
+  'shock',
+  'shone',
+  'shoplift',
+  'shopper',
+  'shopping',
+  'shoptalk',
+  'shore',
+  'shortage',
+  'shortcake',
+  'shortcut',
+  'shorten',
+  'shorter',
+  'shorthand',
+  'shortlist',
+  'shortly',
+  'shortness',
+  'shorts',
+  'shortwave',
+  'shorty',
+  'shout',
+  'shove',
+  'showbiz',
+  'showcase',
+  'showdown',
+  'shower',
+  'showgirl',
+  'showing',
+  'showman',
+  'shown',
+  'showoff',
+  'showpiece',
+  'showplace',
+  'showroom',
+  'showy',
+  'shrank',
+  'shrapnel',
+  'shredder',
+  'shredding',
+  'shrewdly',
+  'shriek',
+  'shrill',
+  'shrimp',
+  'shrine',
+  'shrink',
+  'shrivel',
+  'shrouded',
+  'shrubbery',
+  'shrubs',
+  'shrug',
+  'shrunk',
+  'shucking',
+  'shudder',
+  'shuffle',
+  'shuffling',
+  'shun',
+  'shush',
+  'shut',
+  'shy',
+  'siamese',
+  'siberian',
+  'sibling',
+  'siding',
+  'sierra',
+  'siesta',
+  'sift',
+  'sighing',
+  'silenced',
+  'silencer',
+  'silent',
+  'silica',
+  'silicon',
+  'silk',
+  'silliness',
+  'silly',
+  'silo',
+  'silt',
+  'silver',
+  'similarly',
+  'simile',
+  'simmering',
+  'simple',
+  'simplify',
+  'simply',
+  'sincere',
+  'sincerity',
+  'singer',
+  'singing',
+  'single',
+  'singular',
+  'sinister',
+  'sinless',
+  'sinner',
+  'sinuous',
+  'sip',
+  'siren',
+  'sister',
+  'sitcom',
+  'sitter',
+  'sitting',
+  'situated',
+  'situation',
+  'sixfold',
+  'sixteen',
+  'sixth',
+  'sixties',
+  'sixtieth',
+  'sixtyfold',
+  'sizable',
+  'sizably',
+  'size',
+  'sizing',
+  'sizzle',
+  'sizzling',
+  'skater',
+  'skating',
+  'skedaddle',
+  'skeletal',
+  'skeleton',
+  'skeptic',
+  'sketch',
+  'skewed',
+  'skewer',
+  'skid',
+  'skied',
+  'skier',
+  'skies',
+  'skiing',
+  'skilled',
+  'skillet',
+  'skillful',
+  'skimmed',
+  'skimmer',
+  'skimming',
+  'skimpily',
+  'skincare',
+  'skinhead',
+  'skinless',
+  'skinning',
+  'skinny',
+  'skintight',
+  'skipper',
+  'skipping',
+  'skirmish',
+  'skirt',
+  'skittle',
+  'skydiver',
+  'skylight',
+  'skyline',
+  'skype',
+  'skyrocket',
+  'skyward',
+  'slab',
+  'slacked',
+  'slacker',
+  'slacking',
+  'slackness',
+  'slacks',
+  'slain',
+  'slam',
+  'slander',
+  'slang',
+  'slapping',
+  'slapstick',
+  'slashed',
+  'slashing',
+  'slate',
+  'slather',
+  'slaw',
+  'sled',
+  'sleek',
+  'sleep',
+  'sleet',
+  'sleeve',
+  'slept',
+  'sliceable',
+  'sliced',
+  'slicer',
+  'slicing',
+  'slick',
+  'slider',
+  'slideshow',
+  'sliding',
+  'slighted',
+  'slighting',
+  'slightly',
+  'slimness',
+  'slimy',
+  'slinging',
+  'slingshot',
+  'slinky',
+  'slip',
+  'slit',
+  'sliver',
+  'slobbery',
+  'slogan',
+  'sloped',
+  'sloping',
+  'sloppily',
+  'sloppy',
+  'slot',
+  'slouching',
+  'slouchy',
+  'sludge',
+  'slug',
+  'slum',
+  'slurp',
+  'slush',
+  'sly',
+  'small',
+  'smartly',
+  'smartness',
+  'smasher',
+  'smashing',
+  'smashup',
+  'smell',
+  'smelting',
+  'smile',
+  'smilingly',
+  'smirk',
+  'smite',
+  'smith',
+  'smitten',
+  'smock',
+  'smog',
+  'smoked',
+  'smokeless',
+  'smokiness',
+  'smoking',
+  'smoky',
+  'smolder',
+  'smooth',
+  'smother',
+  'smudge',
+  'smudgy',
+  'smuggler',
+  'smuggling',
+  'smugly',
+  'smugness',
+  'snack',
+  'snagged',
+  'snaking',
+  'snap',
+  'snare',
+  'snarl',
+  'snazzy',
+  'sneak',
+  'sneer',
+  'sneeze',
+  'sneezing',
+  'snide',
+  'sniff',
+  'snippet',
+  'snipping',
+  'snitch',
+  'snooper',
+  'snooze',
+  'snore',
+  'snoring',
+  'snorkel',
+  'snort',
+  'snout',
+  'snowbird',
+  'snowboard',
+  'snowbound',
+  'snowcap',
+  'snowdrift',
+  'snowdrop',
+  'snowfall',
+  'snowfield',
+  'snowflake',
+  'snowiness',
+  'snowless',
+  'snowman',
+  'snowplow',
+  'snowshoe',
+  'snowstorm',
+  'snowsuit',
+  'snowy',
+  'snub',
+  'snuff',
+  'snuggle',
+  'snugly',
+  'snugness',
+  'speak',
+  'spearfish',
+  'spearhead',
+  'spearman',
+  'spearmint',
+  'species',
+  'specimen',
+  'specked',
+  'speckled',
+  'specks',
+  'spectacle',
+  'spectator',
+  'spectrum',
+  'speculate',
+  'speech',
+  'speed',
+  'spellbind',
+  'speller',
+  'spelling',
+  'spendable',
+  'spender',
+  'spending',
+  'spent',
+  'spew',
+  'sphere',
+  'spherical',
+  'sphinx',
+  'spider',
+  'spied',
+  'spiffy',
+  'spill',
+  'spilt',
+  'spinach',
+  'spinal',
+  'spindle',
+  'spinner',
+  'spinning',
+  'spinout',
+  'spinster',
+  'spiny',
+  'spiral',
+  'spirited',
+  'spiritism',
+  'spirits',
+  'spiritual',
+  'splashed',
+  'splashing',
+  'splashy',
+  'splatter',
+  'spleen',
+  'splendid',
+  'splendor',
+  'splice',
+  'splicing',
+  'splinter',
+  'splotchy',
+  'splurge',
+  'spoilage',
+  'spoiled',
+  'spoiler',
+  'spoiling',
+  'spoils',
+  'spoken',
+  'spokesman',
+  'sponge',
+  'spongy',
+  'sponsor',
+  'spoof',
+  'spookily',
+  'spooky',
+  'spool',
+  'spoon',
+  'spore',
+  'sporting',
+  'sports',
+  'sporty',
+  'spotless',
+  'spotlight',
+  'spotted',
+  'spotter',
+  'spotting',
+  'spotty',
+  'spousal',
+  'spouse',
+  'spout',
+  'sprain',
+  'sprang',
+  'sprawl',
+  'spray',
+  'spree',
+  'sprig',
+  'spring',
+  'sprinkled',
+  'sprinkler',
+  'sprint',
+  'sprite',
+  'sprout',
+  'spruce',
+  'sprung',
+  'spry',
+  'spud',
+  'spur',
+  'sputter',
+  'spyglass',
+  'squabble',
+  'squad',
+  'squall',
+  'squander',
+  'squash',
+  'squatted',
+  'squatter',
+  'squatting',
+  'squeak',
+  'squealer',
+  'squealing',
+  'squeamish',
+  'squeegee',
+  'squeeze',
+  'squeezing',
+  'squid',
+  'squiggle',
+  'squiggly',
+  'squint',
+  'squire',
+  'squirt',
+  'squishier',
+  'squishy',
+  'stability',
+  'stabilize',
+  'stable',
+  'stack',
+  'stadium',
+  'staff',
+  'stage',
+  'staging',
+  'stagnant',
+  'stagnate',
+  'stainable',
+  'stained',
+  'staining',
+  'stainless',
+  'stalemate',
+  'staleness',
+  'stalling',
+  'stallion',
+  'stamina',
+  'stammer',
+  'stamp',
+  'stand',
+  'stank',
+  'staple',
+  'stapling',
+  'starboard',
+  'starch',
+  'stardom',
+  'stardust',
+  'starfish',
+  'stargazer',
+  'staring',
+  'stark',
+  'starless',
+  'starlet',
+  'starlight',
+  'starlit',
+  'starring',
+  'starry',
+  'starship',
+  'starter',
+  'starting',
+  'startle',
+  'startling',
+  'startup',
+  'starved',
+  'starving',
+  'stash',
+  'state',
+  'static',
+  'statistic',
+  'statue',
+  'stature',
+  'status',
+  'statute',
+  'statutory',
+  'staunch',
+  'stays',
+  'steadfast',
+  'steadier',
+  'steadily',
+  'steadying',
+  'steam',
+  'steed',
+  'steep',
+  'steerable',
+  'steering',
+  'steersman',
+  'stegosaur',
+  'stellar',
+  'stem',
+  'stench',
+  'stencil',
+  'step',
+  'stereo',
+  'sterile',
+  'sterility',
+  'sterilize',
+  'sterling',
+  'sternness',
+  'sternum',
+  'stew',
+  'stick',
+  'stiffen',
+  'stiffly',
+  'stiffness',
+  'stifle',
+  'stifling',
+  'stillness',
+  'stilt',
+  'stimulant',
+  'stimulate',
+  'stimuli',
+  'stimulus',
+  'stinger',
+  'stingily',
+  'stinging',
+  'stingray',
+  'stingy',
+  'stinking',
+  'stinky',
+  'stipend',
+  'stipulate',
+  'stir',
+  'stitch',
+  'stock',
+  'stoic',
+  'stoke',
+  'stole',
+  'stomp',
+  'stonewall',
+  'stoneware',
+  'stonework',
+  'stoning',
+  'stony',
+  'stood',
+  'stooge',
+  'stool',
+  'stoop',
+  'stoplight',
+  'stoppable',
+  'stoppage',
+  'stopped',
+  'stopper',
+  'stopping',
+  'stopwatch',
+  'storable',
+  'storage',
+  'storeroom',
+  'storewide',
+  'storm',
+  'stout',
+  'stove',
+  'stowaway',
+  'stowing',
+  'straddle',
+  'straggler',
+  'strained',
+  'strainer',
+  'straining',
+  'strangely',
+  'stranger',
+  'strangle',
+  'strategic',
+  'strategy',
+  'stratus',
+  'straw',
+  'stray',
+  'streak',
+  'stream',
+  'street',
+  'strength',
+  'strenuous',
+  'strep',
+  'stress',
+  'stretch',
+  'strewn',
+  'stricken',
+  'strict',
+  'stride',
+  'strife',
+  'strike',
+  'striking',
+  'strive',
+  'striving',
+  'strobe',
+  'strode',
+  'stroller',
+  'strongbox',
+  'strongly',
+  'strongman',
+  'struck',
+  'structure',
+  'strudel',
+  'struggle',
+  'strum',
+  'strung',
+  'strut',
+  'stubbed',
+  'stubble',
+  'stubbly',
+  'stubborn',
+  'stucco',
+  'stuck',
+  'student',
+  'studied',
+  'studio',
+  'study',
+  'stuffed',
+  'stuffing',
+  'stuffy',
+  'stumble',
+  'stumbling',
+  'stump',
+  'stung',
+  'stunned',
+  'stunner',
+  'stunning',
+  'stunt',
+  'stupor',
+  'sturdily',
+  'sturdy',
+  'styling',
+  'stylishly',
+  'stylist',
+  'stylized',
+  'stylus',
+  'suave',
+  'subarctic',
+  'subatomic',
+  'subdivide',
+  'subdued',
+  'subduing',
+  'subfloor',
+  'subgroup',
+  'subheader',
+  'subject',
+  'sublease',
+  'sublet',
+  'sublevel',
+  'sublime',
+  'submarine',
+  'submerge',
+  'submersed',
+  'submitter',
+  'subpanel',
+  'subpar',
+  'subplot',
+  'subprime',
+  'subscribe',
+  'subscript',
+  'subsector',
+  'subside',
+  'subsiding',
+  'subsidize',
+  'subsidy',
+  'subsoil',
+  'subsonic',
+  'substance',
+  'subsystem',
+  'subtext',
+  'subtitle',
+  'subtly',
+  'subtotal',
+  'subtract',
+  'subtype',
+  'suburb',
+  'subway',
+  'subwoofer',
+  'subzero',
+  'succulent',
+  'such',
+  'suction',
+  'sudden',
+  'sudoku',
+  'suds',
+  'sufferer',
+  'suffering',
+  'suffice',
+  'suffix',
+  'suffocate',
+  'suffrage',
+  'sugar',
+  'suggest',
+  'suing',
+  'suitable',
+  'suitably',
+  'suitcase',
+  'suitor',
+  'sulfate',
+  'sulfide',
+  'sulfite',
+  'sulfur',
+  'sulk',
+  'sullen',
+  'sulphate',
+  'sulphuric',
+  'sultry',
+  'superbowl',
+  'superglue',
+  'superhero',
+  'superior',
+  'superjet',
+  'superman',
+  'supermom',
+  'supernova',
+  'supervise',
+  'supper',
+  'supplier',
+  'supply',
+  'support',
+  'supremacy',
+  'supreme',
+  'surcharge',
+  'surely',
+  'sureness',
+  'surface',
+  'surfacing',
+  'surfboard',
+  'surfer',
+  'surgery',
+  'surgical',
+  'surging',
+  'surname',
+  'surpass',
+  'surplus',
+  'surprise',
+  'surreal',
+  'surrender',
+  'surrogate',
+  'surround',
+  'survey',
+  'survival',
+  'survive',
+  'surviving',
+  'survivor',
+  'sushi',
+  'suspect',
+  'suspend',
+  'suspense',
+  'sustained',
+  'sustainer',
+  'swab',
+  'swaddling',
+  'swagger',
+  'swampland',
+  'swan',
+  'swapping',
+  'swarm',
+  'sway',
+  'swear',
+  'sweat',
+  'sweep',
+  'swell',
+  'swept',
+  'swerve',
+  'swifter',
+  'swiftly',
+  'swiftness',
+  'swimmable',
+  'swimmer',
+  'swimming',
+  'swimsuit',
+  'swimwear',
+  'swinger',
+  'swinging',
+  'swipe',
+  'swirl',
+  'switch',
+  'swivel',
+  'swizzle',
+  'swooned',
+  'swoop',
+  'swoosh',
+  'swore',
+  'sworn',
+  'swung',
+  'sycamore',
+  'sympathy',
+  'symphonic',
+  'symphony',
+  'symptom',
+  'synapse',
+  'syndrome',
+  'synergy',
+  'synopses',
+  'synopsis',
+  'synthesis',
+  'synthetic',
+  'syrup',
+  'system',
+  't-shirt',
+  'tabasco',
+  'tabby',
+  'tableful',
+  'tables',
+  'tablet',
+  'tableware',
+  'tabloid',
+  'tackiness',
+  'tacking',
+  'tackle',
+  'tackling',
+  'tacky',
+  'taco',
+  'tactful',
+  'tactical',
+  'tactics',
+  'tactile',
+  'tactless',
+  'tadpole',
+  'taekwondo',
+  'tag',
+  'tainted',
+  'take',
+  'taking',
+  'talcum',
+  'talisman',
+  'tall',
+  'talon',
+  'tamale',
+  'tameness',
+  'tamer',
+  'tamper',
+  'tank',
+  'tanned',
+  'tannery',
+  'tanning',
+  'tantrum',
+  'tapeless',
+  'tapered',
+  'tapering',
+  'tapestry',
+  'tapioca',
+  'tapping',
+  'taps',
+  'tarantula',
+  'target',
+  'tarmac',
+  'tarnish',
+  'tarot',
+  'tartar',
+  'tartly',
+  'tartness',
+  'task',
+  'tassel',
+  'taste',
+  'tastiness',
+  'tasting',
+  'tasty',
+  'tattered',
+  'tattle',
+  'tattling',
+  'tattoo',
+  'taunt',
+  'tavern',
+  'thank',
+  'that',
+  'thaw',
+  'theater',
+  'theatrics',
+  'thee',
+  'theft',
+  'theme',
+  'theology',
+  'theorize',
+  'thermal',
+  'thermos',
+  'thesaurus',
+  'these',
+  'thesis',
+  'thespian',
+  'thicken',
+  'thicket',
+  'thickness',
+  'thieving',
+  'thievish',
+  'thigh',
+  'thimble',
+  'thing',
+  'think',
+  'thinly',
+  'thinner',
+  'thinness',
+  'thinning',
+  'thirstily',
+  'thirsting',
+  'thirsty',
+  'thirteen',
+  'thirty',
+  'thong',
+  'thorn',
+  'those',
+  'thousand',
+  'thrash',
+  'thread',
+  'threaten',
+  'threefold',
+  'thrift',
+  'thrill',
+  'thrive',
+  'thriving',
+  'throat',
+  'throbbing',
+  'throng',
+  'throttle',
+  'throwaway',
+  'throwback',
+  'thrower',
+  'throwing',
+  'thud',
+  'thumb',
+  'thumping',
+  'thursday',
+  'thus',
+  'thwarting',
+  'thyself',
+  'tiara',
+  'tibia',
+  'tidal',
+  'tidbit',
+  'tidiness',
+  'tidings',
+  'tidy',
+  'tiger',
+  'tighten',
+  'tightly',
+  'tightness',
+  'tightrope',
+  'tightwad',
+  'tigress',
+  'tile',
+  'tiling',
+  'till',
+  'tilt',
+  'timid',
+  'timing',
+  'timothy',
+  'tinderbox',
+  'tinfoil',
+  'tingle',
+  'tingling',
+  'tingly',
+  'tinker',
+  'tinkling',
+  'tinsel',
+  'tinsmith',
+  'tint',
+  'tinwork',
+  'tiny',
+  'tipoff',
+  'tipped',
+  'tipper',
+  'tipping',
+  'tiptoeing',
+  'tiptop',
+  'tiring',
+  'tissue',
+  'trace',
+  'tracing',
+  'track',
+  'traction',
+  'tractor',
+  'trade',
+  'trading',
+  'tradition',
+  'traffic',
+  'tragedy',
+  'trailing',
+  'trailside',
+  'train',
+  'traitor',
+  'trance',
+  'tranquil',
+  'transfer',
+  'transform',
+  'translate',
+  'transpire',
+  'transport',
+  'transpose',
+  'trapdoor',
+  'trapeze',
+  'trapezoid',
+  'trapped',
+  'trapper',
+  'trapping',
+  'traps',
+  'trash',
+  'travel',
+  'traverse',
+  'travesty',
+  'tray',
+  'treachery',
+  'treading',
+  'treadmill',
+  'treason',
+  'treat',
+  'treble',
+  'tree',
+  'trekker',
+  'tremble',
+  'trembling',
+  'tremor',
+  'trench',
+  'trend',
+  'trespass',
+  'triage',
+  'trial',
+  'triangle',
+  'tribesman',
+  'tribunal',
+  'tribune',
+  'tributary',
+  'tribute',
+  'triceps',
+  'trickery',
+  'trickily',
+  'tricking',
+  'trickle',
+  'trickster',
+  'tricky',
+  'tricolor',
+  'tricycle',
+  'trident',
+  'tried',
+  'trifle',
+  'trifocals',
+  'trillion',
+  'trilogy',
+  'trimester',
+  'trimmer',
+  'trimming',
+  'trimness',
+  'trinity',
+  'trio',
+  'tripod',
+  'tripping',
+  'triumph',
+  'trivial',
+  'trodden',
+  'trolling',
+  'trombone',
+  'trophy',
+  'tropical',
+  'tropics',
+  'trouble',
+  'troubling',
+  'trough',
+  'trousers',
+  'trout',
+  'trowel',
+  'truce',
+  'truck',
+  'truffle',
+  'trump',
+  'trunks',
+  'trustable',
+  'trustee',
+  'trustful',
+  'trusting',
+  'trustless',
+  'truth',
+  'try',
+  'tubby',
+  'tubeless',
+  'tubular',
+  'tucking',
+  'tuesday',
+  'tug',
+  'tuition',
+  'tulip',
+  'tumble',
+  'tumbling',
+  'tummy',
+  'turban',
+  'turbine',
+  'turbofan',
+  'turbojet',
+  'turbulent',
+  'turf',
+  'turkey',
+  'turmoil',
+  'turret',
+  'turtle',
+  'tusk',
+  'tutor',
+  'tutu',
+  'tux',
+  'tweak',
+  'tweed',
+  'tweet',
+  'tweezers',
+  'twelve',
+  'twentieth',
+  'twenty',
+  'twerp',
+  'twice',
+  'twiddle',
+  'twiddling',
+  'twig',
+  'twilight',
+  'twine',
+  'twins',
+  'twirl',
+  'twistable',
+  'twisted',
+  'twister',
+  'twisting',
+  'twisty',
+  'twitch',
+  'twitter',
+  'tycoon',
+  'tying',
+  'tyke',
+  'udder',
+  'ultimate',
+  'ultimatum',
+  'ultra',
+  'umbilical',
+  'umbrella',
+  'umpire',
+  'unabashed',
+  'unable',
+  'unadorned',
+  'unadvised',
+  'unafraid',
+  'unaired',
+  'unaligned',
+  'unaltered',
+  'unarmored',
+  'unashamed',
+  'unaudited',
+  'unawake',
+  'unaware',
+  'unbaked',
+  'unbalance',
+  'unbeaten',
+  'unbend',
+  'unbent',
+  'unbiased',
+  'unbitten',
+  'unblended',
+  'unblessed',
+  'unblock',
+  'unbolted',
+  'unbounded',
+  'unboxed',
+  'unbraided',
+  'unbridle',
+  'unbroken',
+  'unbuckled',
+  'unbundle',
+  'unburned',
+  'unbutton',
+  'uncanny',
+  'uncapped',
+  'uncaring',
+  'uncertain',
+  'unchain',
+  'unchanged',
+  'uncharted',
+  'uncheck',
+  'uncivil',
+  'unclad',
+  'unclaimed',
+  'unclamped',
+  'unclasp',
+  'uncle',
+  'unclip',
+  'uncloak',
+  'unclog',
+  'unclothed',
+  'uncoated',
+  'uncoiled',
+  'uncolored',
+  'uncombed',
+  'uncommon',
+  'uncooked',
+  'uncork',
+  'uncorrupt',
+  'uncounted',
+  'uncouple',
+  'uncouth',
+  'uncover',
+  'uncross',
+  'uncrown',
+  'uncrushed',
+  'uncured',
+  'uncurious',
+  'uncurled',
+  'uncut',
+  'undamaged',
+  'undated',
+  'undaunted',
+  'undead',
+  'undecided',
+  'undefined',
+  'underage',
+  'underarm',
+  'undercoat',
+  'undercook',
+  'undercut',
+  'underdog',
+  'underdone',
+  'underfed',
+  'underfeed',
+  'underfoot',
+  'undergo',
+  'undergrad',
+  'underhand',
+  'underline',
+  'underling',
+  'undermine',
+  'undermost',
+  'underpaid',
+  'underpass',
+  'underpay',
+  'underrate',
+  'undertake',
+  'undertone',
+  'undertook',
+  'undertow',
+  'underuse',
+  'underwear',
+  'underwent',
+  'underwire',
+  'undesired',
+  'undiluted',
+  'undivided',
+  'undocked',
+  'undoing',
+  'undone',
+  'undrafted',
+  'undress',
+  'undrilled',
+  'undusted',
+  'undying',
+  'unearned',
+  'unearth',
+  'unease',
+  'uneasily',
+  'uneasy',
+  'uneatable',
+  'uneaten',
+  'unedited',
+  'unelected',
+  'unending',
+  'unengaged',
+  'unenvied',
+  'unequal',
+  'unethical',
+  'uneven',
+  'unexpired',
+  'unexposed',
+  'unfailing',
+  'unfair',
+  'unfasten',
+  'unfazed',
+  'unfeeling',
+  'unfiled',
+  'unfilled',
+  'unfitted',
+  'unfitting',
+  'unfixable',
+  'unfixed',
+  'unflawed',
+  'unfocused',
+  'unfold',
+  'unfounded',
+  'unframed',
+  'unfreeze',
+  'unfrosted',
+  'unfrozen',
+  'unfunded',
+  'unglazed',
+  'ungloved',
+  'unglue',
+  'ungodly',
+  'ungraded',
+  'ungreased',
+  'unguarded',
+  'unguided',
+  'unhappily',
+  'unhappy',
+  'unharmed',
+  'unhealthy',
+  'unheard',
+  'unhearing',
+  'unheated',
+  'unhelpful',
+  'unhidden',
+  'unhinge',
+  'unhitched',
+  'unholy',
+  'unhook',
+  'unicorn',
+  'unicycle',
+  'unified',
+  'unifier',
+  'uniformed',
+  'uniformly',
+  'unify',
+  'unimpeded',
+  'uninjured',
+  'uninstall',
+  'uninsured',
+  'uninvited',
+  'union',
+  'uniquely',
+  'unisexual',
+  'unison',
+  'unissued',
+  'unit',
+  'universal',
+  'universe',
+  'unjustly',
+  'unkempt',
+  'unkind',
+  'unknotted',
+  'unknowing',
+  'unknown',
+  'unlaced',
+  'unlatch',
+  'unlawful',
+  'unleaded',
+  'unlearned',
+  'unleash',
+  'unless',
+  'unleveled',
+  'unlighted',
+  'unlikable',
+  'unlimited',
+  'unlined',
+  'unlinked',
+  'unlisted',
+  'unlit',
+  'unlivable',
+  'unloaded',
+  'unloader',
+  'unlocked',
+  'unlocking',
+  'unlovable',
+  'unloved',
+  'unlovely',
+  'unloving',
+  'unluckily',
+  'unlucky',
+  'unmade',
+  'unmanaged',
+  'unmanned',
+  'unmapped',
+  'unmarked',
+  'unmasked',
+  'unmasking',
+  'unmatched',
+  'unmindful',
+  'unmixable',
+  'unmixed',
+  'unmolded',
+  'unmoral',
+  'unmovable',
+  'unmoved',
+  'unmoving',
+  'unnamable',
+  'unnamed',
+  'unnatural',
+  'unneeded',
+  'unnerve',
+  'unnerving',
+  'unnoticed',
+  'unopened',
+  'unopposed',
+  'unpack',
+  'unpadded',
+  'unpaid',
+  'unpainted',
+  'unpaired',
+  'unpaved',
+  'unpeeled',
+  'unpicked',
+  'unpiloted',
+  'unpinned',
+  'unplanned',
+  'unplanted',
+  'unpleased',
+  'unpledged',
+  'unplowed',
+  'unplug',
+  'unpopular',
+  'unproven',
+  'unquote',
+  'unranked',
+  'unrated',
+  'unraveled',
+  'unreached',
+  'unread',
+  'unreal',
+  'unreeling',
+  'unrefined',
+  'unrelated',
+  'unrented',
+  'unrest',
+  'unretired',
+  'unrevised',
+  'unrigged',
+  'unripe',
+  'unrivaled',
+  'unroasted',
+  'unrobed',
+  'unroll',
+  'unruffled',
+  'unruly',
+  'unrushed',
+  'unsaddle',
+  'unsafe',
+  'unsaid',
+  'unsalted',
+  'unsaved',
+  'unsavory',
+  'unscathed',
+  'unscented',
+  'unscrew',
+  'unsealed',
+  'unseated',
+  'unsecured',
+  'unseeing',
+  'unseemly',
+  'unseen',
+  'unselect',
+  'unselfish',
+  'unsent',
+  'unsettled',
+  'unshackle',
+  'unshaken',
+  'unshaved',
+  'unshaven',
+  'unsheathe',
+  'unshipped',
+  'unsightly',
+  'unsigned',
+  'unskilled',
+  'unsliced',
+  'unsmooth',
+  'unsnap',
+  'unsocial',
+  'unsoiled',
+  'unsold',
+  'unsolved',
+  'unsorted',
+  'unspoiled',
+  'unspoken',
+  'unstable',
+  'unstaffed',
+  'unstamped',
+  'unsteady',
+  'unsterile',
+  'unstirred',
+  'unstitch',
+  'unstopped',
+  'unstuck',
+  'unstuffed',
+  'unstylish',
+  'unsubtle',
+  'unsubtly',
+  'unsuited',
+  'unsure',
+  'unsworn',
+  'untagged',
+  'untainted',
+  'untaken',
+  'untamed',
+  'untangled',
+  'untapped',
+  'untaxed',
+  'unthawed',
+  'unthread',
+  'untidy',
+  'untie',
+  'until',
+  'untimed',
+  'untimely',
+  'untitled',
+  'untoasted',
+  'untold',
+  'untouched',
+  'untracked',
+  'untrained',
+  'untreated',
+  'untried',
+  'untrimmed',
+  'untrue',
+  'untruth',
+  'unturned',
+  'untwist',
+  'untying',
+  'unusable',
+  'unused',
+  'unusual',
+  'unvalued',
+  'unvaried',
+  'unvarying',
+  'unveiled',
+  'unveiling',
+  'unvented',
+  'unviable',
+  'unvisited',
+  'unvocal',
+  'unwanted',
+  'unwarlike',
+  'unwary',
+  'unwashed',
+  'unwatched',
+  'unweave',
+  'unwed',
+  'unwelcome',
+  'unwell',
+  'unwieldy',
+  'unwilling',
+  'unwind',
+  'unwired',
+  'unwitting',
+  'unwomanly',
+  'unworldly',
+  'unworn',
+  'unworried',
+  'unworthy',
+  'unwound',
+  'unwoven',
+  'unwrapped',
+  'unwritten',
+  'unzip',
+  'upbeat',
+  'upchuck',
+  'upcoming',
+  'upcountry',
+  'update',
+  'upfront',
+  'upgrade',
+  'upheaval',
+  'upheld',
+  'uphill',
+  'uphold',
+  'uplifted',
+  'uplifting',
+  'upload',
+  'upon',
+  'upper',
+  'upright',
+  'uprising',
+  'upriver',
+  'uproar',
+  'uproot',
+  'upscale',
+  'upside',
+  'upstage',
+  'upstairs',
+  'upstart',
+  'upstate',
+  'upstream',
+  'upstroke',
+  'upswing',
+  'uptake',
+  'uptight',
+  'uptown',
+  'upturned',
+  'upward',
+  'upwind',
+  'uranium',
+  'urban',
+  'urchin',
+  'urethane',
+  'urgency',
+  'urgent',
+  'urging',
+  'urologist',
+  'urology',
+  'usable',
+  'usage',
+  'useable',
+  'used',
+  'uselessly',
+  'user',
+  'usher',
+  'usual',
+  'utensil',
+  'utility',
+  'utilize',
+  'utmost',
+  'utopia',
+  'utter',
+  'vacancy',
+  'vacant',
+  'vacate',
+  'vacation',
+  'vagabond',
+  'vagrancy',
+  'vagrantly',
+  'vaguely',
+  'vagueness',
+  'valiant',
+  'valid',
+  'valium',
+  'valley',
+  'valuables',
+  'value',
+  'vanilla',
+  'vanish',
+  'vanity',
+  'vanquish',
+  'vantage',
+  'vaporizer',
+  'variable',
+  'variably',
+  'varied',
+  'variety',
+  'various',
+  'varmint',
+  'varnish',
+  'varsity',
+  'varying',
+  'vascular',
+  'vaseline',
+  'vastly',
+  'vastness',
+  'veal',
+  'vegan',
+  'veggie',
+  'vehicular',
+  'velcro',
+  'velocity',
+  'velvet',
+  'vendetta',
+  'vending',
+  'vendor',
+  'veneering',
+  'vengeful',
+  'venomous',
+  'ventricle',
+  'venture',
+  'venue',
+  'venus',
+  'verbalize',
+  'verbally',
+  'verbose',
+  'verdict',
+  'verify',
+  'verse',
+  'version',
+  'versus',
+  'vertebrae',
+  'vertical',
+  'vertigo',
+  'very',
+  'vessel',
+  'vest',
+  'veteran',
+  'veto',
+  'vexingly',
+  'viability',
+  'viable',
+  'vibes',
+  'vice',
+  'vicinity',
+  'victory',
+  'video',
+  'viewable',
+  'viewer',
+  'viewing',
+  'viewless',
+  'viewpoint',
+  'vigorous',
+  'village',
+  'villain',
+  'vindicate',
+  'vineyard',
+  'vintage',
+  'violate',
+  'violation',
+  'violator',
+  'violet',
+  'violin',
+  'viper',
+  'viral',
+  'virtual',
+  'virtuous',
+  'virus',
+  'visa',
+  'viscosity',
+  'viscous',
+  'viselike',
+  'visible',
+  'visibly',
+  'vision',
+  'visiting',
+  'visitor',
+  'visor',
+  'vista',
+  'vitality',
+  'vitalize',
+  'vitally',
+  'vitamins',
+  'vivacious',
+  'vividly',
+  'vividness',
+  'vixen',
+  'vocalist',
+  'vocalize',
+  'vocally',
+  'vocation',
+  'voice',
+  'voicing',
+  'void',
+  'volatile',
+  'volley',
+  'voltage',
+  'volumes',
+  'voter',
+  'voting',
+  'voucher',
+  'vowed',
+  'vowel',
+  'voyage',
+  'wackiness',
+  'wad',
+  'wafer',
+  'waffle',
+  'waged',
+  'wager',
+  'wages',
+  'waggle',
+  'wagon',
+  'wake',
+  'waking',
+  'walk',
+  'walmart',
+  'walnut',
+  'walrus',
+  'waltz',
+  'wand',
+  'wannabe',
+  'wanted',
+  'wanting',
+  'wasabi',
+  'washable',
+  'washbasin',
+  'washboard',
+  'washbowl',
+  'washcloth',
+  'washday',
+  'washed',
+  'washer',
+  'washhouse',
+  'washing',
+  'washout',
+  'washroom',
+  'washstand',
+  'washtub',
+  'wasp',
+  'wasting',
+  'watch',
+  'water',
+  'waviness',
+  'waving',
+  'wavy',
+  'whacking',
+  'whacky',
+  'wham',
+  'wharf',
+  'wheat',
+  'whenever',
+  'whiff',
+  'whimsical',
+  'whinny',
+  'whiny',
+  'whisking',
+  'whoever',
+  'whole',
+  'whomever',
+  'whoopee',
+  'whooping',
+  'whoops',
+  'why',
+  'wick',
+  'widely',
+  'widen',
+  'widget',
+  'widow',
+  'width',
+  'wieldable',
+  'wielder',
+  'wife',
+  'wifi',
+  'wikipedia',
+  'wildcard',
+  'wildcat',
+  'wilder',
+  'wildfire',
+  'wildfowl',
+  'wildland',
+  'wildlife',
+  'wildly',
+  'wildness',
+  'willed',
+  'willfully',
+  'willing',
+  'willow',
+  'willpower',
+  'wilt',
+  'wimp',
+  'wince',
+  'wincing',
+  'wind',
+  'wing',
+  'winking',
+  'winner',
+  'winnings',
+  'winter',
+  'wipe',
+  'wired',
+  'wireless',
+  'wiring',
+  'wiry',
+  'wisdom',
+  'wise',
+  'wish',
+  'wisplike',
+  'wispy',
+  'wistful',
+  'wizard',
+  'wobble',
+  'wobbling',
+  'wobbly',
+  'wok',
+  'wolf',
+  'wolverine',
+  'womanhood',
+  'womankind',
+  'womanless',
+  'womanlike',
+  'womanly',
+  'womb',
+  'woof',
+  'wooing',
+  'wool',
+  'woozy',
+  'word',
+  'work',
+  'worried',
+  'worrier',
+  'worrisome',
+  'worry',
+  'worsening',
+  'worshiper',
+  'worst',
+  'wound',
+  'woven',
+  'wow',
+  'wrangle',
+  'wrath',
+  'wreath',
+  'wreckage',
+  'wrecker',
+  'wrecking',
+  'wrench',
+  'wriggle',
+  'wriggly',
+  'wrinkle',
+  'wrinkly',
+  'wrist',
+  'writing',
+  'written',
+  'wrongdoer',
+  'wronged',
+  'wrongful',
+  'wrongly',
+  'wrongness',
+  'wrought',
+  'xbox',
+  'xerox',
+  'yahoo',
+  'yam',
+  'yanking',
+  'yapping',
+  'yard',
+  'yarn',
+  'yeah',
+  'yearbook',
+  'yearling',
+  'yearly',
+  'yearning',
+  'yeast',
+  'yelling',
+  'yelp',
+  'yen',
+  'yesterday',
+  'yiddish',
+  'yield',
+  'yin',
+  'yippee',
+  'yo-yo',
+  'yodel',
+  'yoga',
+  'yogurt',
+  'yonder',
+  'yoyo',
+  'yummy',
+  'zap',
+  'zealous',
+  'zebra',
+  'zen',
+  'zeppelin',
+  'zero',
+  'zestfully',
+  'zesty',
+  'zigzagged',
+  'zipfile',
+  'zipping',
+  'zippy',
+  'zips',
+  'zit',
+  'zodiac',
+  'zombie',
+  'zone',
+  'zoning',
+  'zookeeper',
+  'zoologist',
+  'zoology',
+  'zoom'
+];
diff --git a/js/src/api/local/ethkey/index.js b/js/src/api/local/ethkey/index.js
new file mode 100644
index 000000000..949b8c065
--- /dev/null
+++ b/js/src/api/local/ethkey/index.js
@@ -0,0 +1,87 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import dictionary from './dictionary';
+
+// Allow a web worker in the browser, with a fallback for Node.js
+const hasWebWorkers = typeof Worker !== 'undefined';
+const KeyWorker = hasWebWorkers ? require('worker-loader!./worker')
+                                : require('./worker').KeyWorker;
+
+// Local accounts should never be used outside of the browser
+export let keythereum = null;
+
+if (hasWebWorkers) {
+  require('keythereum/dist/keythereum');
+
+  keythereum = window.keythereum;
+}
+
+export function phraseToAddress (phrase) {
+  return phraseToWallet(phrase).then((wallet) => wallet.address);
+}
+
+export function phraseToWallet (phrase) {
+  return new Promise((resolve, reject) => {
+    const worker = new KeyWorker();
+
+    worker.postMessage(phrase);
+    worker.onmessage = ({ data }) => {
+      resolve(data);
+    };
+  });
+}
+
+export function randomBytes (length) {
+  if (keythereum) {
+    return keythereum.crypto.randomBytes(length);
+  }
+
+  const buf = Buffer.alloc(length);
+
+  for (let i = 0; i < length; i++) {
+    buf[i] = Math.random() * 255;
+  }
+
+  return buf;
+}
+
+export function randomNumber (max) {
+  // Use 24 bits to avoid the integer becoming signed via bitshifts
+  const rand = randomBytes(3);
+
+  const integer = (rand[0] << 16) | (rand[1] << 8) | rand[2];
+
+  // floor to integer value via bitor 0
+  return ((integer / 0xFFFFFF) * max) | 0;
+}
+
+export function randomWord () {
+  // TODO mh: use better entropy
+  const index = randomNumber(dictionary.length);
+
+  return dictionary[index];
+}
+
+export function randomPhrase (length) {
+  const words = [];
+
+  while (length--) {
+    words.push(randomWord());
+  }
+
+  return words.join(' ');
+}
diff --git a/js/src/api/local/ethkey/index.spec.js b/js/src/api/local/ethkey/index.spec.js
new file mode 100644
index 000000000..00fc5fec0
--- /dev/null
+++ b/js/src/api/local/ethkey/index.spec.js
@@ -0,0 +1,95 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import dictionary from './dictionary';
+import {
+  phraseToAddress,
+  phraseToWallet,
+  randomNumber,
+  randomWord,
+  randomPhrase
+} from './';
+
+describe('api/local/ethkey', () => {
+  describe('randomNumber', () => {
+    it('generates numbers in range', () => {
+      for (let i = 0; i < 100; i++) {
+        const number = randomNumber(7777);
+
+        expect(number).to.be.at.least(0);
+        expect(number).to.be.below(7777);
+        expect(number % 1).to.be.equal(0);
+      }
+    });
+  });
+
+  describe('randomWord', () => {
+    it('generates a random word from the dictionary', () => {
+      const word = randomWord();
+
+      expect(dictionary.includes(word)).to.be.equal(true);
+    });
+  });
+
+  describe('randomPhrase', () => {
+    it('generates a random phrase from the dictionary', () => {
+      const phrase = randomPhrase(7).split(' ');
+
+      expect(phrase.length).to.be.equal(7);
+
+      phrase.forEach((word) => {
+        expect(dictionary.includes(word)).to.be.equal(true);
+      });
+    });
+  });
+
+  describe('phraseToAddress', function () {
+    this.timeout(10000);
+
+    it('generates a valid address', () => {
+      const phrase = randomPhrase(12);
+
+      return phraseToAddress(phrase).then((address) => {
+        expect(address.length).to.be.equal(42);
+        expect(address.slice(0, 4)).to.be.equal('0x00');
+      });
+    });
+
+    it('generates valid address for empty phrase', () => {
+      return phraseToAddress('').then((address) => {
+        expect(address).to.be.equal('0x00a329c0648769a73afac7f9381e08fb43dbea72');
+      });
+    });
+  });
+
+  describe('phraseToWallet', function () {
+    this.timeout(10000);
+
+    it('generates a valid wallet object', () => {
+      const phrase = randomPhrase(12);
+
+      return phraseToWallet(phrase).then((wallet) => {
+        expect(wallet.address.length).to.be.equal(42);
+        expect(wallet.secret.length).to.be.equal(66);
+        expect(wallet.public.length).to.be.equal(130);
+
+        expect(wallet.address.slice(0, 4)).to.be.equal('0x00');
+        expect(wallet.secret.slice(0, 2)).to.be.equal('0x');
+        expect(wallet.public.slice(0, 2)).to.be.equal('0x');
+      });
+    });
+  });
+});
diff --git a/js/src/api/local/ethkey/worker.js b/js/src/api/local/ethkey/worker.js
new file mode 100644
index 000000000..a472ee29a
--- /dev/null
+++ b/js/src/api/local/ethkey/worker.js
@@ -0,0 +1,89 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import { keccak_256 as keccak256 } from 'js-sha3';
+import secp256k1 from 'secp256k1/js';
+
+// Stay compatible between environments
+if (typeof self !== 'object') {
+  const scope = typeof global === 'undefined' ? window : global;
+
+  scope.self = scope;
+}
+
+function bytesToHex (bytes) {
+  return '0x' + Array.from(bytes).map(n => ('0' + n.toString(16)).slice(-2)).join('');
+}
+
+// Logic ported from /ethkey/src/brain.rs
+function phraseToWallet (phrase) {
+  let secret = keccak256.array(phrase);
+
+  for (let i = 0; i < 16384; i++) {
+    secret = keccak256.array(secret);
+  }
+
+  while (true) {
+    secret = keccak256.array(secret);
+
+    const secretBuf = Buffer.from(secret);
+
+    if (secp256k1.privateKeyVerify(secretBuf)) {
+      // No compression, slice out last 64 bytes
+      const publicBuf = secp256k1.publicKeyCreate(secretBuf, false).slice(-64);
+      const address = keccak256.array(publicBuf).slice(12);
+
+      if (address[0] !== 0) {
+        continue;
+      }
+
+      const wallet = {
+        secret: bytesToHex(secretBuf),
+        public: bytesToHex(publicBuf),
+        address: bytesToHex(address)
+      };
+
+      return wallet;
+    }
+  }
+}
+
+self.onmessage = function ({ data }) {
+  const wallet = phraseToWallet(data);
+
+  postMessage(wallet);
+  close();
+};
+
+// Emulate a web worker in Node.js
+class KeyWorker {
+  postMessage (data) {
+    // Force async
+    setTimeout(() => {
+      const wallet = phraseToWallet(data);
+
+      this.onmessage({ data: wallet });
+    }, 0);
+  }
+
+  onmessage (event) {
+    // no-op to be overriden
+  }
+}
+
+if (exports != null) {
+  exports.KeyWorker = KeyWorker;
+}
diff --git a/js/src/api/local/index.js b/js/src/api/local/index.js
new file mode 100644
index 000000000..c1d4b60ca
--- /dev/null
+++ b/js/src/api/local/index.js
@@ -0,0 +1,17 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+export LocalAccountsMiddleware from './middleware';
diff --git a/js/src/api/local/middleware.js b/js/src/api/local/middleware.js
new file mode 100644
index 000000000..8b12d8248
--- /dev/null
+++ b/js/src/api/local/middleware.js
@@ -0,0 +1,173 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import EthereumTx from 'ethereumjs-tx';
+import accounts from './accounts';
+import transactions from './transactions';
+import { Middleware } from '../transport';
+import { inNumber16 } from '../format/input';
+import { phraseToWallet, phraseToAddress, randomPhrase } from './ethkey';
+
+export default class LocalAccountsMiddleware extends Middleware {
+  // Maps transaction requests to transaction hashes.
+  // This allows the locally-signed transactions to emulate the signer.
+  transactionHashes = {};
+  transactions = {};
+
+  // Current transaction id. This doesn't need to be stored, as it's
+  // only relevant for the current the session.
+  transactionId = 1;
+
+  constructor (transport) {
+    super(transport);
+
+    const register = this.register.bind(this);
+
+    register('eth_accounts', () => {
+      return accounts.mapArray((account) => account.address);
+    });
+
+    register('eth_coinbase', () => {
+      return accounts.lastAddress;
+    });
+
+    register('parity_accountsInfo', () => {
+      return accounts.mapObject(({ name }) => {
+        return { name };
+      });
+    });
+
+    register('parity_allAccountsInfo', () => {
+      return accounts.mapObject(({ name, meta, uuid }) => {
+        return { name, meta, uuid };
+      });
+    });
+
+    register('parity_checkRequest', ([id]) => {
+      return transactions.hash(id) || Promise.resolve(null);
+    });
+
+    register('parity_defaultAccount', () => {
+      return accounts.lastAddress;
+    });
+
+    register('parity_generateSecretPhrase', () => {
+      return randomPhrase(12);
+    });
+
+    register('parity_getNewDappsAddresses', () => {
+      return [];
+    });
+
+    register('parity_hardwareAccountsInfo', () => {
+      return {};
+    });
+
+    register('parity_newAccountFromPhrase', ([phrase, password]) => {
+      return phraseToWallet(phrase)
+        .then((wallet) => {
+          return accounts.create(wallet.secret, password);
+        });
+    });
+
+    register('parity_setAccountMeta', ([address, meta]) => {
+      accounts.get(address).meta = meta;
+
+      return true;
+    });
+
+    register('parity_setAccountName', ([address, name]) => {
+      accounts.get(address).name = name;
+
+      return true;
+    });
+
+    register('parity_postTransaction', ([tx]) => {
+      if (!tx.from) {
+        tx.from = accounts.lastAddress;
+      }
+
+      tx.nonce = null;
+      tx.condition = null;
+
+      return transactions.add(tx);
+    });
+
+    register('parity_phraseToAddress', ([phrase]) => {
+      return phraseToAddress(phrase);
+    });
+
+    register('parity_useLocalAccounts', () => {
+      return true;
+    });
+
+    register('parity_listGethAccounts', () => {
+      return [];
+    });
+
+    register('parity_listRecentDapps', () => {
+      return {};
+    });
+
+    register('parity_killAccount', ([address, password]) => {
+      return accounts.remove(address, password);
+    });
+
+    register('signer_confirmRequest', ([id, modify, password]) => {
+      const {
+        gasPrice,
+        gas: gasLimit,
+        from,
+        to,
+        value,
+        data
+      } = Object.assign(transactions.get(id), modify);
+
+      return this
+        .rpcRequest('parity_nextNonce', [from])
+        .then((nonce) => {
+          const tx = new EthereumTx({
+            nonce,
+            to,
+            data,
+            gasLimit: inNumber16(gasLimit),
+            gasPrice: inNumber16(gasPrice),
+            value: inNumber16(value)
+          });
+          const account = accounts.get(from);
+
+          tx.sign(account.decryptPrivateKey(password));
+
+          const serializedTx = `0x${tx.serialize().toString('hex')}`;
+
+          return this.rpcRequest('eth_sendRawTransaction', [serializedTx]);
+        })
+        .then((hash) => {
+          transactions.confirm(id, hash);
+
+          return {};
+        });
+    });
+
+    register('signer_rejectRequest', ([id]) => {
+      return transactions.reject(id);
+    });
+
+    register('signer_requestsToConfirm', () => {
+      return transactions.requestsToConfirm();
+    });
+  }
+}
diff --git a/js/src/api/local/transactions.js b/js/src/api/local/transactions.js
new file mode 100644
index 000000000..57d1eee62
--- /dev/null
+++ b/js/src/api/local/transactions.js
@@ -0,0 +1,123 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import { toHex } from '../util/format';
+import { TransportError } from '../transport';
+
+const AWAITING = Symbol('awaiting');
+const CONFIRMED = Symbol('confirmed');
+const REJECTED = Symbol('rejected');
+
+class Transactions {
+  constructor () {
+    this.reset();
+  }
+
+  // should only really be needed in the constructor and tests
+  reset () {
+    this._id = 1;
+    this._states = {};
+  }
+
+  nextId () {
+    return toHex(this._id++);
+  }
+
+  add (tx) {
+    const id = this.nextId();
+
+    this._states[id] = {
+      status: AWAITING,
+      transaction: tx
+    };
+
+    return id;
+  }
+
+  get (id) {
+    const state = this._states[id];
+
+    if (!state || state.status !== AWAITING) {
+      return null;
+    }
+
+    return state.transaction;
+  }
+
+  hash (id) {
+    const state = this._states[id];
+
+    if (!state) {
+      return null;
+    }
+
+    switch (state.status) {
+      case REJECTED:
+        throw TransportError.requestRejected();
+      case CONFIRMED:
+        return state.hash;
+      default:
+        return null;
+    }
+  }
+
+  confirm (id, hash) {
+    const state = this._states[id];
+
+    if (!state || state.status !== AWAITING) {
+      throw new Error('Trying to confirm an invalid transaction');
+    }
+
+    state.hash = hash;
+    state.status = CONFIRMED;
+  }
+
+  reject (id) {
+    const state = this._states[id];
+
+    if (!state) {
+      return false;
+    }
+
+    state.status = REJECTED;
+
+    return true;
+  }
+
+  requestsToConfirm () {
+    const result = [];
+
+    Object.keys(this._states).forEach((id) => {
+      const state = this._states[id];
+
+      if (state.status === AWAITING) {
+        result.push({
+          id,
+          origin: {
+            signer: '0x0'
+          },
+          payload: {
+            sendTransaction: state.transaction
+          }
+        });
+      }
+    });
+
+    return result;
+  }
+}
+
+export default new Transactions();
diff --git a/js/src/api/local/transactions.spec.js b/js/src/api/local/transactions.spec.js
new file mode 100644
index 000000000..84482ff57
--- /dev/null
+++ b/js/src/api/local/transactions.spec.js
@@ -0,0 +1,68 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import transactions from './transactions';
+import { TransportError } from '../transport/error';
+
+const DUMMY_TX = 'dummy';
+
+describe('api/local/transactions', () => {
+  beforeEach(() => {
+    transactions.reset();
+  });
+
+  it('can store transactions', () => {
+    const id1 = transactions.add(DUMMY_TX);
+    const id2 = transactions.add(DUMMY_TX);
+    const requests = transactions.requestsToConfirm();
+
+    expect(id1).to.be.equal('0x1');
+    expect(id2).to.be.equal('0x2');
+    expect(requests.length).to.be.equal(2);
+    expect(requests[0].id).to.be.equal(id1);
+    expect(requests[1].id).to.be.equal(id2);
+    expect(requests[0].payload.sendTransaction).to.be.equal(DUMMY_TX);
+    expect(requests[1].payload.sendTransaction).to.be.equal(DUMMY_TX);
+  });
+
+  it('can confirm transactions', () => {
+    const id1 = transactions.add(DUMMY_TX);
+    const id2 = transactions.add(DUMMY_TX);
+
+    const hash1 = '0x1111111111111111111111111111111111111111';
+    const hash2 = '0x2222222222222222222222222222222222222222';
+
+    transactions.confirm(id1, hash1);
+    transactions.confirm(id2, hash2);
+
+    const requests = transactions.requestsToConfirm();
+
+    expect(requests.length).to.be.equal(0);
+    expect(transactions.hash(id1)).to.be.equal(hash1);
+    expect(transactions.hash(id2)).to.be.equal(hash2);
+  });
+
+  it('can reject transactions', () => {
+    const id = transactions.add(DUMMY_TX);
+
+    transactions.reject(id);
+
+    const requests = transactions.requestsToConfirm();
+
+    expect(requests.length).to.be.equal(0);
+    expect(() => transactions.hash(id)).to.throw(TransportError);
+  });
+});
diff --git a/js/src/api/transport/error.js b/js/src/api/transport/error.js
index 50174f4e0..12fe6b898 100644
--- a/js/src/api/transport/error.js
+++ b/js/src/api/transport/error.js
@@ -42,6 +42,10 @@ export const ERROR_CODES = {
 };
 
 export default class TransportError extends ExtendableError {
+  static requestRejected (method = null) {
+    return new TransportError(method, ERROR_CODES.REQUEST_REJECTED, 'Request has been rejected.');
+  }
+
   constructor (method, code, message) {
     const m = `${method}: ${code}: ${message}`;
 
diff --git a/js/src/api/transport/http/http.js b/js/src/api/transport/http/http.js
index ba7d21ba0..fed28e9e6 100644
--- a/js/src/api/transport/http/http.js
+++ b/js/src/api/transport/http/http.js
@@ -46,7 +46,7 @@ export default class Http extends JsonRpcBase {
     };
   }
 
-  execute (method, ...params) {
+  _execute (method, params) {
     const request = this._encodeOptions(method, params);
 
     return fetch(this._url, request)
diff --git a/js/src/api/transport/index.js b/js/src/api/transport/index.js
index 0c674e7c1..fdd3861a8 100644
--- a/js/src/api/transport/index.js
+++ b/js/src/api/transport/index.js
@@ -16,4 +16,5 @@
 
 export Http from './http';
 export Ws from './ws';
-export TransportError from './error.js';
+export TransportError from './error';
+export Middleware from './middleware';
diff --git a/js/src/api/transport/jsonRpcBase.js b/js/src/api/transport/jsonRpcBase.js
index 5f2b35006..46df718a7 100644
--- a/js/src/api/transport/jsonRpcBase.js
+++ b/js/src/api/transport/jsonRpcBase.js
@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 import EventEmitter from 'eventemitter3';
+import { Logging } from '../subscriptions';
 
 export default class JsonRpcBase extends EventEmitter {
   constructor () {
@@ -23,6 +24,7 @@ export default class JsonRpcBase extends EventEmitter {
     this._id = 1;
     this._debug = false;
     this._connected = false;
+    this._middlewareList = Promise.resolve([]);
   }
 
   encode (method, params) {
@@ -36,6 +38,65 @@ export default class JsonRpcBase extends EventEmitter {
     return json;
   }
 
+  addMiddleware (middleware) {
+    this._middlewareList = Promise
+      .all([
+        middleware,
+        this._middlewareList
+      ])
+      .then(([middleware, middlewareList]) => {
+        // Do nothing if `handlerPromise` resolves to a null-y value.
+        if (middleware == null) {
+          return middlewareList;
+        }
+
+        // don't mutate the original array
+        return middlewareList.concat([middleware]);
+      });
+  }
+
+  _wrapSuccessResult (result) {
+    return {
+      id: this._id,
+      jsonrpc: '2.0',
+      result
+    };
+  }
+
+  _wrapErrorResult (error) {
+    return {
+      id: this._id,
+      jsonrpc: '2.0',
+      error: {
+        code: error.code,
+        message: error.text
+      }
+    };
+  }
+
+  execute (method, ...params) {
+    return this._middlewareList.then((middlewareList) => {
+      for (const middleware of middlewareList) {
+        const res = middleware.handle(method, params);
+
+        if (res != null) {
+          const result = this._wrapSuccessResult(res);
+          const json = this.encode(method, params);
+
+          Logging.send(method, params, { json, result });
+
+          return res;
+        }
+      }
+
+      return this._execute(method, params);
+    });
+  }
+
+  _execute () {
+    throw new Error('Missing implementation of JsonRpcBase#_execute');
+  }
+
   _setConnected () {
     if (!this._connected) {
       this._connected = true;
diff --git a/js/src/api/transport/middleware.js b/js/src/api/transport/middleware.js
new file mode 100644
index 000000000..5a4945e7e
--- /dev/null
+++ b/js/src/api/transport/middleware.js
@@ -0,0 +1,42 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+export default class Middleware {
+  constructor (transport) {
+    this._transport = transport;
+    this._handlers = {};
+  }
+
+  register (method, handler) {
+    this._handlers[method] = handler;
+  }
+
+  handle (method, params) {
+    const handler = this._handlers[method];
+
+    if (handler != null) {
+      const response = handler(params);
+
+      return response;
+    }
+
+    return null;
+  }
+
+  rpcRequest (method, params) {
+    return this._transport._execute(method, params);
+  }
+}
diff --git a/js/src/api/transport/middleware.spec.js b/js/src/api/transport/middleware.spec.js
new file mode 100644
index 000000000..27b81c49f
--- /dev/null
+++ b/js/src/api/transport/middleware.spec.js
@@ -0,0 +1,58 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+import Middleware from './middleware';
+import JsonRpcBase from './jsonRpcBase';
+
+const MOCKED = 'mocked!';
+
+class MockTransport extends JsonRpcBase {
+  _execute () {
+    return Promise.resolve(MOCKED);
+  }
+}
+
+describe('api/transport/Middleware', () => {
+  let middleware;
+  let transport;
+
+  beforeEach(() => {
+    transport = new MockTransport();
+    middleware = new Middleware(transport);
+
+    middleware.register('mock_rpc', ([num]) => num);
+    middleware.register('mock_null', () => null);
+    transport.addMiddleware(middleware);
+  });
+
+  it('Routes requests to middleware', () => {
+    return transport.execute('mock_rpc', 100).then((num) => {
+      expect(num).to.be.equal(100);
+    });
+  });
+
+  it('Passes non-mocked requests through', () => {
+    return transport.execute('not_moced', 200).then((result) => {
+      expect(result).to.be.equal(MOCKED);
+    });
+  });
+
+  it('Passes mocked requests through, if middleware returns null', () => {
+    return transport.execute('mock_null', 300).then((result) => {
+      expect(result).to.be.equal(MOCKED);
+    });
+  });
+});
diff --git a/js/src/api/transport/ws/ws.js b/js/src/api/transport/ws/ws.js
index 4b41935cd..8721bf78a 100644
--- a/js/src/api/transport/ws/ws.js
+++ b/js/src/api/transport/ws/ws.js
@@ -244,7 +244,7 @@ export default class Ws extends JsonRpcBase {
     message.timestamp = Date.now();
   }
 
-  execute (method, ...params) {
+  _execute (method, params) {
     return new Promise((resolve, reject) => {
       const id = this.id;
       const json = this.encode(method, params);
diff --git a/js/webpack/libraries.js b/js/webpack/libraries.js
index de005b1d2..76fa16f7d 100644
--- a/js/webpack/libraries.js
+++ b/js/webpack/libraries.js
@@ -56,6 +56,11 @@ module.exports = {
           'babel-loader?cacheDirectory=true'
         ]
       },
+      {
+        test: /\.js$/,
+        include: /node_modules\/ethereumjs-tx/,
+        use: 'babel-loader'
+      },
       {
         test: /\.json$/,
         use: [ 'json-loader' ]
diff --git a/parity/cli/config.full.toml b/parity/cli/config.full.toml
index 6800ec2dc..94c79cb15 100644
--- a/parity/cli/config.full.toml
+++ b/parity/cli/config.full.toml
@@ -4,6 +4,7 @@ mode_timeout = 300
 mode_alarm = 3600
 auto_update = "none"
 release_track = "current"
+public_node = false
 no_download = false
 no_consensus = false
 
diff --git a/parity/cli/mod.rs b/parity/cli/mod.rs
index b346cb9d8..65b1cfea4 100644
--- a/parity/cli/mod.rs
+++ b/parity/cli/mod.rs
@@ -88,6 +88,7 @@ usage! {
 		flag_mode_alarm: u64 = 3600u64, or |c: &Config| otry!(c.parity).mode_alarm.clone(),
 		flag_auto_update: String = "critical", or |c: &Config| otry!(c.parity).auto_update.clone(),
 		flag_release_track: String = "current", or |c: &Config| otry!(c.parity).release_track.clone(),
+		flag_public_node: bool = false, or |c: &Config| otry!(c.parity).public_node.clone(),
 		flag_no_download: bool = false, or |c: &Config| otry!(c.parity).no_download.clone(),
 		flag_no_consensus: bool = false, or |c: &Config| otry!(c.parity).no_consensus.clone(),
 		flag_chain: String = "foundation", or |c: &Config| otry!(c.parity).chain.clone(),
@@ -365,6 +366,7 @@ struct Operating {
 	mode_alarm: Option<u64>,
 	auto_update: Option<String>,
 	release_track: Option<String>,
+	public_node: Option<bool>,
 	no_download: Option<bool>,
 	no_consensus: Option<bool>,
 	chain: Option<String>,
@@ -623,6 +625,7 @@ mod tests {
 			flag_mode_alarm: 3600u64,
 			flag_auto_update: "none".into(),
 			flag_release_track: "current".into(),
+			flag_public_node: false,
 			flag_no_download: false,
 			flag_no_consensus: false,
 			flag_chain: "xyz".into(),
@@ -825,6 +828,7 @@ mod tests {
 				mode_alarm: Some(10u64),
 				auto_update: None,
 				release_track: None,
+				public_node: None,
 				no_download: None,
 				no_consensus: None,
 				chain: Some("./chain.json".into()),
diff --git a/parity/cli/usage.txt b/parity/cli/usage.txt
index 322543607..4c1abafbe 100644
--- a/parity/cli/usage.txt
+++ b/parity/cli/usage.txt
@@ -48,6 +48,9 @@ Operating Options:
                                  testing - Testing releases (do not use).
                                  current - Whatever track this executable was
                                  released on (default: {flag_release_track}).
+  --public-node                  Start Parity as a public web server. Account storage
+                                 and transaction signing will be delegated to the UI.
+                                 (default: {flag_public_node}).
   --no-download                  Normally new releases will be downloaded ready for
                                  updating. This disables it. Not recommended.
                                  (default: {flag_no_download}).
diff --git a/parity/configuration.rs b/parity/configuration.rs
index a9a9159e1..5dd11bd90 100644
--- a/parity/configuration.rs
+++ b/parity/configuration.rs
@@ -128,6 +128,7 @@ impl Configuration {
 			Some(true) if pruning == Pruning::Specific(Algorithm::Archive) => writeln!(&mut stderr(), "Warning: Warp Sync is disabled because pruning mode is set to archive").expect("Error writing to stderr"),
 			_ => {},
 		};
+		let public_node = self.args.flag_public_node;
 		let warp_sync = !self.args.flag_no_warp && fat_db != Switch::On && tracing != Switch::On && pruning != Pruning::Specific(Algorithm::Archive);
 		let geth_compatibility = self.args.flag_geth;
 		let ui_address = self.ui_port().map(|port| (self.ui_interface(), port));
@@ -360,6 +361,7 @@ impl Configuration {
 				wal: wal,
 				vm_type: vm_type,
 				warp_sync: warp_sync,
+				public_node: public_node,
 				geth_compatibility: geth_compatibility,
 				ui_address: ui_address,
 				net_settings: self.network_settings(),
@@ -709,14 +711,26 @@ impl Configuration {
 	}
 
 	fn rpc_apis(&self) -> String {
-		let mut apis = self.args.flag_rpcapi.clone().unwrap_or(self.args.flag_jsonrpc_apis.clone());
+		let mut apis: Vec<&str> = self.args.flag_rpcapi
+			.as_ref()
+			.unwrap_or(&self.args.flag_jsonrpc_apis)
+			.split(",")
+			.collect();
+
 		if self.args.flag_geth {
-			if !apis.is_empty() {
-				apis.push_str(",");
-			}
-			apis.push_str("personal");
+			apis.push("personal");
 		}
-		apis
+
+		if self.args.flag_public_node {
+			apis.retain(|api| {
+				match *api {
+					"eth" | "net" | "parity" | "rpc" | "web3" => true,
+					_ => false
+				}
+			});
+		}
+
+		apis.join(",")
 	}
 
 	fn cors(cors: Option<&String>) -> Option<Vec<String>> {
@@ -1167,6 +1181,7 @@ mod tests {
 			ipc_conf: Default::default(),
 			net_conf: default_network_config(),
 			network_id: None,
+			public_node: false,
 			warp_sync: true,
 			acc_conf: Default::default(),
 			gas_pricer: Default::default(),
diff --git a/parity/rpc_apis.rs b/parity/rpc_apis.rs
index cc45e3f8b..e168f029c 100644
--- a/parity/rpc_apis.rs
+++ b/parity/rpc_apis.rs
@@ -118,7 +118,7 @@ pub struct Dependencies {
 	pub snapshot: Arc<SnapshotService>,
 	pub sync: Arc<SyncProvider>,
 	pub net: Arc<ManageNetwork>,
-	pub secret_store: Arc<AccountProvider>,
+	pub secret_store: Option<Arc<AccountProvider>>,
 	pub miner: Arc<Miner>,
 	pub external_miner: Arc<ExternalMiner>,
 	pub logger: Arc<RotatingLogger>,
diff --git a/parity/run.rs b/parity/run.rs
index 86702edfc..c438c25a5 100644
--- a/parity/run.rs
+++ b/parity/run.rs
@@ -81,6 +81,7 @@ pub struct RunCmd {
 	pub net_conf: NetworkConfiguration,
 	pub network_id: Option<u64>,
 	pub warp_sync: bool,
+	pub public_node: bool,
 	pub acc_conf: AccountsConfig,
 	pub gas_pricer: GasPricerConfig,
 	pub miner_extras: MinerExtras,
@@ -407,6 +408,10 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc<RotatingLogger>) -> R
 	// set up dependencies for rpc servers
 	let rpc_stats = Arc::new(informant::RpcStats::default());
 	let signer_path = cmd.signer_conf.signer_path.clone();
+	let secret_store = match cmd.public_node {
+		true => None,
+		false => Some(account_provider.clone())
+	};
 	let deps_for_rpc_apis = Arc::new(rpc_apis::Dependencies {
 		signer_service: Arc::new(rpc_apis::SignerService::new(move || {
 			signer::generate_new_token(signer_path.clone()).map_err(|e| format!("{:?}", e))
@@ -415,7 +420,7 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc<RotatingLogger>) -> R
 		client: client.clone(),
 		sync: sync_provider.clone(),
 		net: manage_network.clone(),
-		secret_store: account_provider.clone(),
+		secret_store: secret_store,
 		miner: miner.clone(),
 		external_miner: external_miner.clone(),
 		logger: logger.clone(),
diff --git a/rpc/src/v1/helpers/accounts.rs b/rpc/src/v1/helpers/accounts.rs
new file mode 100644
index 000000000..329f25f0f
--- /dev/null
+++ b/rpc/src/v1/helpers/accounts.rs
@@ -0,0 +1,27 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::sync::{Arc, Weak};
+use ethcore::account_provider::AccountProvider;
+use jsonrpc_core::Error;
+use v1::helpers::errors;
+
+pub fn unwrap_provider(provider: &Option<Weak<AccountProvider>>) -> Result<Arc<AccountProvider>, Error> {
+	match *provider {
+		Some(ref weak) => weak.upgrade().ok_or_else(Error::internal_error),
+		None => Err(errors::public_unsupported(None)),
+	}
+}
diff --git a/rpc/src/v1/helpers/errors.rs b/rpc/src/v1/helpers/errors.rs
index e8fcee303..7a7e940b8 100644
--- a/rpc/src/v1/helpers/errors.rs
+++ b/rpc/src/v1/helpers/errors.rs
@@ -65,6 +65,14 @@ pub fn light_unimplemented(details: Option<String>) -> Error {
 	}
 }
 
+pub fn public_unsupported(details: Option<String>) -> Error {
+	Error {
+		code: ErrorCode::ServerError(codes::UNSUPPORTED_REQUEST),
+		message: "Method disallowed when running parity as a public node.".into(),
+		data: details.map(Value::String),
+	}
+}
+
 pub fn request_not_found() -> Error {
 	Error {
 		code: ErrorCode::ServerError(codes::REQUEST_NOT_FOUND),
diff --git a/rpc/src/v1/helpers/mod.rs b/rpc/src/v1/helpers/mod.rs
index bc99b65ff..9d2064aa8 100644
--- a/rpc/src/v1/helpers/mod.rs
+++ b/rpc/src/v1/helpers/mod.rs
@@ -17,6 +17,7 @@
 #[macro_use]
 pub mod errors;
 
+pub mod accounts;
 pub mod block_import;
 pub mod dispatch;
 pub mod fake_sign;
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 811d5aa90..73d4d9f9b 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -46,6 +46,7 @@ use jsonrpc_macros::Trailing;
 use v1::helpers::{errors, limit_logs, fake_sign};
 use v1::helpers::dispatch::{Dispatcher, FullDispatcher, default_gas_price};
 use v1::helpers::block_import::is_major_importing;
+use v1::helpers::accounts::unwrap_provider;
 use v1::traits::Eth;
 use v1::types::{
 	RichBlock, Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo,
@@ -97,7 +98,7 @@ pub struct EthClient<C, SN: ?Sized, S: ?Sized, M, EM> where
 	client: Weak<C>,
 	snapshot: Weak<SN>,
 	sync: Weak<S>,
-	accounts: Weak<AccountProvider>,
+	accounts: Option<Weak<AccountProvider>>,
 	miner: Weak<M>,
 	external_miner: Arc<EM>,
 	seed_compute: Mutex<SeedHashCompute>,
@@ -116,7 +117,7 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM> EthClient<C, SN, S, M, EM> where
 		client: &Arc<C>,
 		snapshot: &Arc<SN>,
 		sync: &Arc<S>,
-		accounts: &Arc<AccountProvider>,
+		accounts: &Option<Arc<AccountProvider>>,
 		miner: &Arc<M>,
 		em: &Arc<EM>,
 		options: EthClientOptions
@@ -126,13 +127,19 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM> EthClient<C, SN, S, M, EM> where
 			snapshot: Arc::downgrade(snapshot),
 			sync: Arc::downgrade(sync),
 			miner: Arc::downgrade(miner),
-			accounts: Arc::downgrade(accounts),
+			accounts: accounts.as_ref().map(Arc::downgrade),
 			external_miner: em.clone(),
 			seed_compute: Mutex::new(SeedHashCompute::new()),
 			options: options,
 		}
 	}
 
+	/// Attempt to get the `Arc<AccountProvider>`, errors if provider was not
+	/// set, or if upgrading the weak reference failed.
+	fn account_provider(&self) -> Result<Arc<AccountProvider>, Error> {
+		unwrap_provider(&self.accounts)
+	}
+
 	fn block(&self, id: BlockId, include_txs: bool) -> Result<Option<RichBlock>, Error> {
 		let client = take_weak!(self.client);
 		match (client.block(id.clone()), client.block_total_difficulty(id)) {
@@ -223,7 +230,7 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM> EthClient<C, SN, S, M, EM> where
 	}
 
 	fn dapp_accounts(&self, dapp: DappId) -> Result<Vec<H160>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		store
 			.note_dapp_used(dapp.clone())
 			.and_then(|_| store.dapp_addresses(dapp))
diff --git a/rpc/src/v1/impls/light/parity.rs b/rpc/src/v1/impls/light/parity.rs
index 46062b15a..569398193 100644
--- a/rpc/src/v1/impls/light/parity.rs
+++ b/rpc/src/v1/impls/light/parity.rs
@@ -40,7 +40,7 @@ use v1::types::{
 	TransactionStats, LocalTransactionStatus,
 	BlockNumber, ConsensusCapability, VersionInfo,
 	OperationsInfo, DappId, ChainStatus,
-	AccountInfo, HwAccountInfo
+	AccountInfo, HwAccountInfo,
 };
 
 /// Parity implementation for light client.
diff --git a/rpc/src/v1/impls/parity.rs b/rpc/src/v1/impls/parity.rs
index d6e16f267..83e0a505d 100644
--- a/rpc/src/v1/impls/parity.rs
+++ b/rpc/src/v1/impls/parity.rs
@@ -37,6 +37,7 @@ use updater::{Service as UpdateService};
 use jsonrpc_core::Error;
 use jsonrpc_macros::Trailing;
 use v1::helpers::{errors, SigningQueue, SignerService, NetworkSettings};
+use v1::helpers::accounts::unwrap_provider;
 use v1::helpers::dispatch::DEFAULT_MAC;
 use v1::metadata::Metadata;
 use v1::traits::Parity;
@@ -46,7 +47,7 @@ use v1::types::{
 	TransactionStats, LocalTransactionStatus,
 	BlockNumber, ConsensusCapability, VersionInfo,
 	OperationsInfo, DappId, ChainStatus,
-	AccountInfo, HwAccountInfo
+	AccountInfo, HwAccountInfo,
 };
 
 /// Parity implementation.
@@ -61,7 +62,7 @@ pub struct ParityClient<C, M, S: ?Sized, U> where
 	sync: Weak<S>,
 	updater: Weak<U>,
 	net: Weak<ManageNetwork>,
-	accounts: Weak<AccountProvider>,
+	accounts: Option<Weak<AccountProvider>>,
 	logger: Arc<RotatingLogger>,
 	settings: Arc<NetworkSettings>,
 	signer: Option<Arc<SignerService>>,
@@ -82,7 +83,7 @@ impl<C, M, S: ?Sized, U> ParityClient<C, M, S, U> where
 		sync: &Arc<S>,
 		updater: &Arc<U>,
 		net: &Arc<ManageNetwork>,
-		store: &Arc<AccountProvider>,
+		store: &Option<Arc<AccountProvider>>,
 		logger: Arc<RotatingLogger>,
 		settings: Arc<NetworkSettings>,
 		signer: Option<Arc<SignerService>>,
@@ -95,7 +96,7 @@ impl<C, M, S: ?Sized, U> ParityClient<C, M, S, U> where
 			sync: Arc::downgrade(sync),
 			updater: Arc::downgrade(updater),
 			net: Arc::downgrade(net),
-			accounts: Arc::downgrade(store),
+			accounts: store.as_ref().map(Arc::downgrade),
 			logger: logger,
 			settings: settings,
 			signer: signer,
@@ -103,6 +104,12 @@ impl<C, M, S: ?Sized, U> ParityClient<C, M, S, U> where
 			dapps_port: dapps_port,
 		}
 	}
+
+	/// Attempt to get the `Arc<AccountProvider>`, errors if provider was not
+	/// set, or if upgrading the weak reference failed.
+	fn account_provider(&self) -> Result<Arc<AccountProvider>, Error> {
+		unwrap_provider(&self.accounts)
+	}
 }
 
 impl<C, M, S: ?Sized, U> Parity for ParityClient<C, M, S, U> where
@@ -116,7 +123,7 @@ impl<C, M, S: ?Sized, U> Parity for ParityClient<C, M, S, U> where
 	fn accounts_info(&self, dapp: Trailing<DappId>) -> Result<BTreeMap<H160, AccountInfo>, Error> {
 		let dapp = dapp.0;
 
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		let dapp_accounts = store
 			.note_dapp_used(dapp.clone().into())
 			.and_then(|_| store.dapp_addresses(dapp.into()))
@@ -136,7 +143,7 @@ impl<C, M, S: ?Sized, U> Parity for ParityClient<C, M, S, U> where
 	}
 
 	fn hardware_accounts_info(&self) -> Result<BTreeMap<H160, HwAccountInfo>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		let info = store.hardware_accounts_info().map_err(|e| errors::account("Could not fetch account info.", e))?;
 		Ok(info
 			.into_iter()
@@ -148,7 +155,7 @@ impl<C, M, S: ?Sized, U> Parity for ParityClient<C, M, S, U> where
 	fn default_account(&self, meta: Self::Metadata) -> BoxFuture<H160, Error> {
 		let dapp_id = meta.dapp_id();
 		future::ok(
-			take_weakf!(self.accounts)
+			try_bf!(self.account_provider())
 				.dapp_default_address(dapp_id.into())
 				.map(Into::into)
 				.ok()
@@ -376,9 +383,13 @@ impl<C, M, S: ?Sized, U> Parity for ParityClient<C, M, S, U> where
 	fn node_kind(&self) -> Result<::v1::types::NodeKind, Error> {
 		use ::v1::types::{NodeKind, Availability, Capability};
 
-		// TODO [maciej]: public availability flag.
+		let availability = match self.accounts {
+			Some(_) => Availability::Personal,
+			None => Availability::Public
+		};
+
 		Ok(NodeKind {
-			availability: Availability::Personal,
+			availability: availability,
 			capability: Capability::Full,
 		})
 	}
diff --git a/rpc/src/v1/impls/parity_accounts.rs b/rpc/src/v1/impls/parity_accounts.rs
index 828dbf8f4..c22285cc9 100644
--- a/rpc/src/v1/impls/parity_accounts.rs
+++ b/rpc/src/v1/impls/parity_accounts.rs
@@ -25,26 +25,33 @@ use ethcore::account_provider::AccountProvider;
 
 use jsonrpc_core::Error;
 use v1::helpers::errors;
+use v1::helpers::accounts::unwrap_provider;
 use v1::traits::ParityAccounts;
 use v1::types::{H160 as RpcH160, H256 as RpcH256, DappId, Derive, DeriveHierarchical, DeriveHash};
 
 /// Account management (personal) rpc implementation.
 pub struct ParityAccountsClient {
-	accounts: Weak<AccountProvider>,
+	accounts: Option<Weak<AccountProvider>>,
 }
 
 impl ParityAccountsClient {
 	/// Creates new PersonalClient
-	pub fn new(store: &Arc<AccountProvider>) -> Self {
+	pub fn new(store: &Option<Arc<AccountProvider>>) -> Self {
 		ParityAccountsClient {
-			accounts: Arc::downgrade(store),
+			accounts: store.as_ref().map(Arc::downgrade),
 		}
 	}
+
+	/// Attempt to get the `Arc<AccountProvider>`, errors if provider was not
+	/// set, or if upgrading the weak reference failed.
+	fn account_provider(&self) -> Result<Arc<AccountProvider>, Error> {
+		unwrap_provider(&self.accounts)
+	}
 }
 
 impl ParityAccounts for ParityAccountsClient {
 	fn all_accounts_info(&self) -> Result<BTreeMap<RpcH160, BTreeMap<String, String>>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		let info = store.accounts_info().map_err(|e| errors::account("Could not fetch account info.", e))?;
 		let other = store.addresses_info();
 
@@ -66,7 +73,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn new_account_from_phrase(&self, phrase: String, pass: String) -> Result<RpcH160, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		let brain = Brain::new(phrase).generate().unwrap();
 		store.insert_account(brain.secret().clone(), &pass)
@@ -75,7 +82,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn new_account_from_wallet(&self, json: String, pass: String) -> Result<RpcH160, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.import_presale(json.as_bytes(), &pass)
 			.or_else(|_| store.import_wallet(json.as_bytes(), &pass))
@@ -84,7 +91,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn new_account_from_secret(&self, secret: RpcH256, pass: String) -> Result<RpcH160, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		let secret = Secret::from_slice(&secret.0)
 			.map_err(|e| errors::account("Could not create account.", e))?;
@@ -96,14 +103,14 @@ impl ParityAccounts for ParityAccountsClient {
 	fn test_password(&self, account: RpcH160, password: String) -> Result<bool, Error> {
 		let account: Address = account.into();
 
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.test_password(&account, &password)
 			.map_err(|e| errors::account("Could not fetch account info.", e))
 	}
 
 	fn change_password(&self, account: RpcH160, password: String, new_password: String) -> Result<bool, Error> {
 		let account: Address = account.into();
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.change_password(&account, password, new_password)
 			.map(|_| true)
 			.map_err(|e| errors::account("Could not fetch account info.", e))
@@ -111,14 +118,14 @@ impl ParityAccounts for ParityAccountsClient {
 
 	fn kill_account(&self, account: RpcH160, password: String) -> Result<bool, Error> {
 		let account: Address = account.into();
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.kill_account(&account, &password)
 			.map(|_| true)
 			.map_err(|e| errors::account("Could not delete account.", e))
 	}
 
 	fn remove_address(&self, addr: RpcH160) -> Result<bool, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		let addr: Address = addr.into();
 
 		store.remove_address(addr);
@@ -126,7 +133,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn set_account_name(&self, addr: RpcH160, name: String) -> Result<bool, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		let addr: Address = addr.into();
 
 		store.set_account_name(addr.clone(), name.clone())
@@ -135,7 +142,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn set_account_meta(&self, addr: RpcH160, meta: String) -> Result<bool, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		let addr: Address = addr.into();
 
 		store.set_account_meta(addr.clone(), meta.clone())
@@ -144,7 +151,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn set_dapp_addresses(&self, dapp: DappId, addresses: Option<Vec<RpcH160>>) -> Result<bool, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.set_dapp_addresses(dapp.into(), addresses.map(into_vec))
 			.map_err(|e| errors::account("Couldn't set dapp addresses.", e))
@@ -152,7 +159,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn dapp_addresses(&self, dapp: DappId) -> Result<Vec<RpcH160>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.dapp_addresses(dapp.into())
 			.map_err(|e| errors::account("Couldn't get dapp addresses.", e))
@@ -160,7 +167,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn set_dapp_default_address(&self, dapp: DappId, address: RpcH160) -> Result<bool, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.set_dapp_default_address(dapp.into(), address.into())
 			.map_err(|e| errors::account("Couldn't set dapp default address.", e))
@@ -168,7 +175,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn dapp_default_address(&self, dapp: DappId) -> Result<RpcH160, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.dapp_default_address(dapp.into())
 			.map_err(|e| errors::account("Couldn't get dapp default address.", e))
@@ -176,7 +183,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn set_new_dapps_addresses(&self, addresses: Option<Vec<RpcH160>>) -> Result<bool, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store
 			.set_new_dapps_addresses(addresses.map(into_vec))
@@ -185,7 +192,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn new_dapps_addresses(&self) -> Result<Option<Vec<RpcH160>>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.new_dapps_addresses()
 			.map_err(|e| errors::account("Couldn't get dapps addresses.", e))
@@ -193,7 +200,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn set_new_dapps_default_address(&self, address: RpcH160) -> Result<bool, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.set_new_dapps_default_address(address.into())
 			.map_err(|e| errors::account("Couldn't set new dapps default address.", e))
@@ -201,7 +208,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn new_dapps_default_address(&self) -> Result<RpcH160, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.new_dapps_default_address()
 			.map_err(|e| errors::account("Couldn't get new dapps default address.", e))
@@ -209,7 +216,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn recent_dapps(&self) -> Result<BTreeMap<DappId, u64>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.recent_dapps()
 			.map_err(|e| errors::account("Couldn't get recent dapps.", e))
@@ -217,7 +224,7 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn import_geth_accounts(&self, addresses: Vec<RpcH160>) -> Result<Vec<RpcH160>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store
 			.import_geth_accounts(into_vec(addresses), false)
@@ -226,66 +233,66 @@ impl ParityAccounts for ParityAccountsClient {
 	}
 
 	fn geth_accounts(&self) -> Result<Vec<RpcH160>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		Ok(into_vec(store.list_geth_accounts(false)))
 	}
 
 	fn create_vault(&self, name: String, password: String) -> Result<bool, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.create_vault(&name, &password)
 			.map_err(|e| errors::account("Could not create vault.", e))
 			.map(|_| true)
 	}
 
 	fn open_vault(&self, name: String, password: String) -> Result<bool, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.open_vault(&name, &password)
 			.map_err(|e| errors::account("Could not open vault.", e))
 			.map(|_| true)
 	}
 
 	fn close_vault(&self, name: String) -> Result<bool, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.close_vault(&name)
 			.map_err(|e| errors::account("Could not close vault.", e))
 			.map(|_| true)
 	}
 
 	fn list_vaults(&self) -> Result<Vec<String>, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.list_vaults()
 			.map_err(|e| errors::account("Could not list vaults.", e))
 	}
 
 	fn list_opened_vaults(&self) -> Result<Vec<String>, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.list_opened_vaults()
 			.map_err(|e| errors::account("Could not list vaults.", e))
 	}
 
 	fn change_vault_password(&self, name: String, new_password: String) -> Result<bool, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.change_vault_password(&name, &new_password)
 			.map_err(|e| errors::account("Could not change vault password.", e))
 			.map(|_| true)
 	}
 
 	fn change_vault(&self, address: RpcH160, new_vault: String) -> Result<bool, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.change_vault(address.into(), &new_vault)
 			.map_err(|e| errors::account("Could not change vault.", e))
 			.map(|_| true)
 	}
 
 	fn get_vault_meta(&self, name: String) -> Result<String, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.get_vault_meta(&name)
 			.map_err(|e| errors::account("Could not get vault metadata.", e))
 	}
 
 	fn set_vault_meta(&self, name: String, meta: String) -> Result<bool, Error> {
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.set_vault_meta(&name, &meta)
 			.map_err(|e| errors::account("Could not update vault metadata.", e))
 			.map(|_| true)
@@ -293,7 +300,7 @@ impl ParityAccounts for ParityAccountsClient {
 
 	fn derive_key_index(&self, addr: RpcH160, password: String, derivation: DeriveHierarchical, save_as_account: bool) -> Result<RpcH160, Error> {
 		let addr: Address = addr.into();
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.derive_account(
 				&addr,
 				Some(password),
@@ -306,7 +313,7 @@ impl ParityAccounts for ParityAccountsClient {
 
 	fn derive_key_hash(&self, addr: RpcH160, password: String, derivation: DeriveHash, save_as_account: bool) -> Result<RpcH160, Error> {
 		let addr: Address = addr.into();
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.derive_account(
 				&addr,
 				Some(password),
@@ -319,7 +326,7 @@ impl ParityAccounts for ParityAccountsClient {
 
 	fn export_account(&self, addr: RpcH160, password: String) -> Result<KeyFile, Error> {
 		let addr = addr.into();
-		take_weak!(self.accounts)
+		self.account_provider()?
 			.export_account(
 				&addr,
 				password,
diff --git a/rpc/src/v1/impls/personal.rs b/rpc/src/v1/impls/personal.rs
index 1f9cad92f..26551df45 100644
--- a/rpc/src/v1/impls/personal.rs
+++ b/rpc/src/v1/impls/personal.rs
@@ -26,39 +26,44 @@ use futures::{future, Future, BoxFuture};
 use jsonrpc_core::Error;
 use v1::helpers::errors;
 use v1::helpers::dispatch::{Dispatcher, SignWith};
+use v1::helpers::accounts::unwrap_provider;
 use v1::traits::Personal;
 use v1::types::{H160 as RpcH160, H256 as RpcH256, U128 as RpcU128, TransactionRequest};
 use v1::metadata::Metadata;
 
 /// Account management (personal) rpc implementation.
 pub struct PersonalClient<D: Dispatcher> {
-	accounts: Weak<AccountProvider>,
+	accounts: Option<Weak<AccountProvider>>,
 	dispatcher: D,
 	allow_perm_unlock: bool,
 }
 
 impl<D: Dispatcher> PersonalClient<D> {
 	/// Creates new PersonalClient
-	pub fn new(store: &Arc<AccountProvider>, dispatcher: D, allow_perm_unlock: bool) -> Self {
+	pub fn new(store: &Option<Arc<AccountProvider>>, dispatcher: D, allow_perm_unlock: bool) -> Self {
 		PersonalClient {
-			accounts: Arc::downgrade(store),
+			accounts: store.as_ref().map(Arc::downgrade),
 			dispatcher: dispatcher,
 			allow_perm_unlock: allow_perm_unlock,
 		}
 	}
+
+	fn account_provider(&self) -> Result<Arc<AccountProvider>, Error> {
+		unwrap_provider(&self.accounts)
+	}
 }
 
 impl<D: Dispatcher + 'static> Personal for PersonalClient<D> {
 	type Metadata = Metadata;
 
 	fn accounts(&self) -> Result<Vec<RpcH160>, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		let accounts = store.accounts().map_err(|e| errors::account("Could not fetch accounts.", e))?;
 		Ok(accounts.into_iter().map(Into::into).collect::<Vec<RpcH160>>())
 	}
 
 	fn new_account(&self, pass: String) -> Result<RpcH160, Error> {
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 
 		store.new_account(&pass)
 			.map(Into::into)
@@ -67,7 +72,7 @@ impl<D: Dispatcher + 'static> Personal for PersonalClient<D> {
 
 	fn unlock_account(&self, account: RpcH160, account_pass: String, duration: Option<RpcU128>) -> Result<bool, Error> {
 		let account: Address = account.into();
-		let store = take_weak!(self.accounts);
+		let store = self.account_provider()?;
 		let duration = match duration {
 			None => None,
 			Some(duration) => {
@@ -96,7 +101,7 @@ impl<D: Dispatcher + 'static> Personal for PersonalClient<D> {
 
 	fn send_transaction(&self, meta: Metadata, request: TransactionRequest, password: String) -> BoxFuture<RpcH256, Error> {
 		let dispatcher = self.dispatcher.clone();
-		let accounts = take_weakf!(self.accounts);
+		let accounts = try_bf!(self.account_provider());
 
 		let default = match request.from.as_ref() {
 			Some(account) => Ok(account.clone().into()),
diff --git a/rpc/src/v1/impls/signer.rs b/rpc/src/v1/impls/signer.rs
index f418a6760..d46bfdcc5 100644
--- a/rpc/src/v1/impls/signer.rs
+++ b/rpc/src/v1/impls/signer.rs
@@ -26,13 +26,14 @@ use futures::{future, BoxFuture, Future, IntoFuture};
 use jsonrpc_core::Error;
 use v1::helpers::{errors, SignerService, SigningQueue, ConfirmationPayload};
 use v1::helpers::dispatch::{self, Dispatcher, WithToken};
+use v1::helpers::accounts::unwrap_provider;
 use v1::traits::Signer;
 use v1::types::{TransactionModification, ConfirmationRequest, ConfirmationResponse, ConfirmationResponseWithToken, U256, Bytes};
 
 /// Transactions confirmation (personal) rpc implementation.
 pub struct SignerClient<D: Dispatcher> {
 	signer: Weak<SignerService>,
-	accounts: Weak<AccountProvider>,
+	accounts: Option<Weak<AccountProvider>>,
 	dispatcher: D
 }
 
@@ -40,17 +41,21 @@ impl<D: Dispatcher + 'static> SignerClient<D> {
 
 	/// Create new instance of signer client.
 	pub fn new(
-		store: &Arc<AccountProvider>,
+		store: &Option<Arc<AccountProvider>>,
 		dispatcher: D,
 		signer: &Arc<SignerService>,
 	) -> Self {
 		SignerClient {
 			signer: Arc::downgrade(signer),
-			accounts: Arc::downgrade(store),
+			accounts: store.as_ref().map(Arc::downgrade),
 			dispatcher: dispatcher,
 		}
 	}
 
+	fn account_provider(&self) -> Result<Arc<AccountProvider>, Error> {
+		unwrap_provider(&self.accounts)
+	}
+
 	fn confirm_internal<F, T>(&self, id: U256, modification: TransactionModification, f: F) -> BoxFuture<WithToken<ConfirmationResponse>, Error> where
 		F: FnOnce(D, Arc<AccountProvider>, ConfirmationPayload) -> T,
 		T: IntoFuture<Item=WithToken<ConfirmationResponse>, Error=Error>,
@@ -60,7 +65,7 @@ impl<D: Dispatcher + 'static> SignerClient<D> {
 		let dispatcher = self.dispatcher.clone();
 
 		let setup = || {
-			Ok((take_weak!(self.accounts), take_weak!(self.signer)))
+			Ok((self.account_provider()?, take_weak!(self.signer)))
 		};
 
 		let (accounts, signer) = match setup() {
diff --git a/rpc/src/v1/impls/signing.rs b/rpc/src/v1/impls/signing.rs
index 598b98763..dfb0c4f80 100644
--- a/rpc/src/v1/impls/signing.rs
+++ b/rpc/src/v1/impls/signing.rs
@@ -30,6 +30,7 @@ use v1::helpers::{
 	SIGNING_QUEUE_LIMIT, SigningQueue, ConfirmationPromise, ConfirmationResult, SignerService
 };
 use v1::helpers::dispatch::{self, Dispatcher};
+use v1::helpers::accounts::unwrap_provider;
 use v1::metadata::Metadata;
 use v1::traits::{EthSigning, ParitySigning};
 use v1::types::{
@@ -55,7 +56,7 @@ enum DispatchResult {
 /// Implementation of functions that require signing when no trusted signer is used.
 pub struct SigningQueueClient<D> {
 	signer: Weak<SignerService>,
-	accounts: Weak<AccountProvider>,
+	accounts: Option<Weak<AccountProvider>>,
 	dispatcher: D,
 	pending: Arc<Mutex<TransientHashMap<U256, ConfirmationPromise>>>,
 }
@@ -91,17 +92,21 @@ fn collect_garbage(map: &mut TransientHashMap<U256, ConfirmationPromise>) {
 
 impl<D: Dispatcher + 'static> SigningQueueClient<D> {
 	/// Creates a new signing queue client given shared signing queue.
-	pub fn new(signer: &Arc<SignerService>, dispatcher: D, accounts: &Arc<AccountProvider>) -> Self {
+	pub fn new(signer: &Arc<SignerService>, dispatcher: D, accounts: &Option<Arc<AccountProvider>>) -> Self {
 		SigningQueueClient {
 			signer: Arc::downgrade(signer),
-			accounts: Arc::downgrade(accounts),
+			accounts: accounts.as_ref().map(Arc::downgrade),
 			dispatcher: dispatcher,
 			pending: Arc::new(Mutex::new(TransientHashMap::new(MAX_PENDING_DURATION_SEC))),
 		}
 	}
 
+	fn account_provider(&self) -> Result<Arc<AccountProvider>, Error> {
+		unwrap_provider(&self.accounts)
+	}
+
 	fn dispatch(&self, payload: RpcConfirmationPayload, default_account: DefaultAccount, origin: Origin) -> BoxFuture<DispatchResult, Error> {
-		let accounts = take_weakf!(self.accounts);
+		let accounts = try_bf!(self.account_provider());
 		let default_account = match default_account {
 			DefaultAccount::Provided(acc) => acc,
 			DefaultAccount::ForDapp(dapp) => accounts.dapp_default_address(dapp).ok().unwrap_or_default(),
diff --git a/rpc/src/v1/impls/signing_unsafe.rs b/rpc/src/v1/impls/signing_unsafe.rs
index d48935e44..8fbb6595a 100644
--- a/rpc/src/v1/impls/signing_unsafe.rs
+++ b/rpc/src/v1/impls/signing_unsafe.rs
@@ -24,6 +24,7 @@ use futures::{future, BoxFuture, Future};
 use jsonrpc_core::Error;
 use v1::helpers::{errors, DefaultAccount};
 use v1::helpers::dispatch::{self, Dispatcher};
+use v1::helpers::accounts::unwrap_provider;
 use v1::metadata::Metadata;
 use v1::traits::{EthSigning, ParitySigning};
 use v1::types::{
@@ -38,21 +39,25 @@ use v1::types::{
 
 /// Implementation of functions that require signing when no trusted signer is used.
 pub struct SigningUnsafeClient<D> {
-	accounts: Weak<AccountProvider>,
+	accounts: Option<Weak<AccountProvider>>,
 	dispatcher: D,
 }
 
 impl<D: Dispatcher + 'static> SigningUnsafeClient<D> {
 	/// Creates new SigningUnsafeClient.
-	pub fn new(accounts: &Arc<AccountProvider>, dispatcher: D) -> Self {
+	pub fn new(accounts: &Option<Arc<AccountProvider>>, dispatcher: D) -> Self {
 		SigningUnsafeClient {
-			accounts: Arc::downgrade(accounts),
+			accounts: accounts.as_ref().map(Arc::downgrade),
 			dispatcher: dispatcher,
 		}
 	}
 
+	fn account_provider(&self) -> Result<Arc<AccountProvider>, Error> {
+		unwrap_provider(&self.accounts)
+	}
+
 	fn handle(&self, payload: RpcConfirmationPayload, account: DefaultAccount) -> BoxFuture<RpcConfirmationResponse, Error> {
-		let accounts = take_weakf!(self.accounts);
+		let accounts = try_bf!(self.account_provider());
 		let default = match account {
 			DefaultAccount::Provided(acc) => acc,
 			DefaultAccount::ForDapp(dapp) => accounts.dapp_default_address(dapp).ok().unwrap_or_default(),
diff --git a/rpc/src/v1/tests/mocked/eth.rs b/rpc/src/v1/tests/mocked/eth.rs
index dfd64d38d..ed312c363 100644
--- a/rpc/src/v1/tests/mocked/eth.rs
+++ b/rpc/src/v1/tests/mocked/eth.rs
@@ -84,15 +84,16 @@ impl EthTester {
 		let client = blockchain_client();
 		let sync = sync_provider();
 		let ap = accounts_provider();
+		let opt_ap = Some(ap.clone());
 		let miner = miner_service();
 		let snapshot = snapshot_service();
 		let hashrates = Arc::new(Mutex::new(HashMap::new()));
 		let external_miner = Arc::new(ExternalMiner::new(hashrates.clone()));
-		let eth = EthClient::new(&client, &snapshot, &sync, &ap, &miner, &external_miner, options).to_delegate();
+		let eth = EthClient::new(&client, &snapshot, &sync, &opt_ap, &miner, &external_miner, options).to_delegate();
 		let filter = EthFilterClient::new(&client, &miner).to_delegate();
 
 		let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner));
-		let sign = SigningUnsafeClient::new(&ap, dispatcher).to_delegate();
+		let sign = SigningUnsafeClient::new(&opt_ap, dispatcher).to_delegate();
 		let mut io: IoHandler<Metadata> = IoHandler::default();
 		io.extend_with(eth);
 		io.extend_with(sign);
diff --git a/rpc/src/v1/tests/mocked/parity.rs b/rpc/src/v1/tests/mocked/parity.rs
index e9b252af8..d47c810f1 100644
--- a/rpc/src/v1/tests/mocked/parity.rs
+++ b/rpc/src/v1/tests/mocked/parity.rs
@@ -72,13 +72,15 @@ impl Dependencies {
 	}
 
 	pub fn client(&self, signer: Option<Arc<SignerService>>) -> TestParityClient {
+		let opt_accounts = Some(self.accounts.clone());
+
 		ParityClient::new(
 			&self.client,
 			&self.miner,
 			&self.sync,
 			&self.updater,
 			&self.network,
-			&self.accounts,
+			&opt_accounts,
 			self.logger.clone(),
 			self.settings.clone(),
 			signer,
diff --git a/rpc/src/v1/tests/mocked/parity_accounts.rs b/rpc/src/v1/tests/mocked/parity_accounts.rs
index ef356cd42..949498c61 100644
--- a/rpc/src/v1/tests/mocked/parity_accounts.rs
+++ b/rpc/src/v1/tests/mocked/parity_accounts.rs
@@ -40,7 +40,8 @@ fn accounts_provider_with_vaults_support(temp_path: &str) -> Arc<AccountProvider
 }
 
 fn setup_with_accounts_provider(accounts_provider: Arc<AccountProvider>) -> ParityAccountsTester {
-	let parity_accounts = ParityAccountsClient::new(&accounts_provider);
+	let opt_ap = Some(accounts_provider.clone());
+	let parity_accounts = ParityAccountsClient::new(&opt_ap);
 	let mut io = IoHandler::default();
 	io.extend_with(parity_accounts.to_delegate());
 
diff --git a/rpc/src/v1/tests/mocked/personal.rs b/rpc/src/v1/tests/mocked/personal.rs
index ba20ad15a..6618ea61c 100644
--- a/rpc/src/v1/tests/mocked/personal.rs
+++ b/rpc/src/v1/tests/mocked/personal.rs
@@ -51,11 +51,12 @@ fn miner_service() -> Arc<TestMinerService> {
 
 fn setup() -> PersonalTester {
 	let accounts = accounts_provider();
+	let opt_accounts = Some(accounts.clone());
 	let client = blockchain_client();
 	let miner = miner_service();
 
 	let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner));
-	let personal = PersonalClient::new(&accounts, dispatcher, false);
+	let personal = PersonalClient::new(&opt_accounts, dispatcher, false);
 
 	let mut io = IoHandler::default();
 	io.extend_with(personal.to_delegate());
diff --git a/rpc/src/v1/tests/mocked/signer.rs b/rpc/src/v1/tests/mocked/signer.rs
index 06b75d911..a20e94bcc 100644
--- a/rpc/src/v1/tests/mocked/signer.rs
+++ b/rpc/src/v1/tests/mocked/signer.rs
@@ -57,12 +57,13 @@ fn miner_service() -> Arc<TestMinerService> {
 fn signer_tester() -> SignerTester {
 	let signer = Arc::new(SignerService::new_test(None));
 	let accounts = accounts_provider();
+	let opt_accounts = Some(accounts.clone());
 	let client = blockchain_client();
 	let miner = miner_service();
 
 	let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner));
 	let mut io = IoHandler::default();
-	io.extend_with(SignerClient::new(&accounts, dispatcher, &signer).to_delegate());
+	io.extend_with(SignerClient::new(&opt_accounts, dispatcher, &signer).to_delegate());
 
 	SignerTester {
 		signer: signer,
diff --git a/rpc/src/v1/tests/mocked/signing.rs b/rpc/src/v1/tests/mocked/signing.rs
index e5b068b52..70b163023 100644
--- a/rpc/src/v1/tests/mocked/signing.rs
+++ b/rpc/src/v1/tests/mocked/signing.rs
@@ -51,13 +51,14 @@ impl Default for SigningTester {
 		let client = Arc::new(TestBlockChainClient::default());
 		let miner = Arc::new(TestMinerService::default());
 		let accounts = Arc::new(AccountProvider::transient_provider());
+		let opt_accounts = Some(accounts.clone());
 		let mut io = IoHandler::default();
 
 		let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner));
 
-		let rpc = SigningQueueClient::new(&signer, dispatcher.clone(), &accounts);
+		let rpc = SigningQueueClient::new(&signer, dispatcher.clone(), &opt_accounts);
 		io.extend_with(EthSigning::to_delegate(rpc));
-		let rpc = SigningQueueClient::new(&signer, dispatcher, &accounts);
+		let rpc = SigningQueueClient::new(&signer, dispatcher, &opt_accounts);
 		io.extend_with(ParitySigning::to_delegate(rpc));
 
 		SigningTester {